Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release:

MFC r309142 (by emaste):

Add WITH_LLD_AS_LD build knob

If set it installs LLD as /usr/bin/ld.  LLD (as of version 3.9) is not
capable of linking the world and kernel, but can self-host and link many
substantial applications. GNU ld continues to be used for the world and
kernel build, regardless of how this knob is set.

It is on by default for arm64, and off for all other CPU architectures.

Sponsored by:	The FreeBSD Foundation

MFC r310840:

Reapply 310775, now it also builds correctly if lldb is disabled:

Move llvm-objdump from CLANG_EXTRAS to installed by default

We currently install three tools from binutils 2.17.50: as, ld, and
objdump. Work is underway to migrate to a permissively-licensed
tool-chain, with one goal being the retirement of binutils 2.17.50.

LLVM's llvm-objdump is intended to be compatible with GNU objdump
although it is currently missing some options and may have formatting
differences. Enable it by default for testing and further investigation.
It may later be changed to install as /usr/bin/objdump, it becomes a
fully viable replacement.

Reviewed by:	emaste
Differential Revision:	https://reviews.freebsd.org/D8879

MFC r312855 (by emaste):

Rename LLD_AS_LD to LLD_IS_LD, for consistency with CLANG_IS_CC

Reported by:	Dan McGregor <dan.mcgregor usask.ca>

MFC r313559 | glebius | 2017-02-10 18:34:48 +0100 (Fri, 10 Feb 2017) | 5 lines

Don't check struct rtentry on FreeBSD, it is an internal kernel structure.
On other systems it may be API structure for SIOCADDRT/SIOCDELRT.

Reviewed by:	emaste, dim

MFC r314152 (by jkim):

Remove an assembler flag, which is redundant since r309124.  The upstream
took care of it by introducing a macro NO_EXEC_STACK_DIRECTIVE.

http://llvm.org/viewvc/llvm-project?rev=273500&view=rev

Reviewed by:	dim

MFC r314564:

Upgrade our copies of clang, llvm, lld, lldb, compiler-rt and libc++ to
4.0.0 (branches/release_40 296509).  The release will follow soon.

Please note that from 3.5.0 onwards, clang, llvm and lldb require C++11
support to build; see UPDATING for more information.

Also note that as of 4.0.0, lld should be able to link the base system
on amd64 and aarch64.  See the WITH_LLD_IS_LLD setting in src.conf(5).
Though please be aware that this is work in progress.

Release notes for llvm, clang and lld will be available here:
<http://releases.llvm.org/4.0.0/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/clang/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/lld/docs/ReleaseNotes.html>

Thanks to Ed Maste, Jan Beich, Antoine Brodin and Eric Fiselier for
their help.

Relnotes:	yes
Exp-run:	antoine
PR:		215969, 216008

MFC r314708:

For now, revert r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

This commit is the cause of excessive compile times on skein_block.c
(and possibly other files) during kernel builds on amd64.

We never saw the problematic behavior described in this upstream commit,
so for now it is better to revert it.  An upstream bug has been filed
here: https://bugs.llvm.org/show_bug.cgi?id=32142

Reported by:	mjg

MFC r314795:

Reapply r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

Pull in r296992 from upstream llvm trunk (by Sanjoy Das):

  [SCEV] Decrease the recursion threshold for CompareValueComplexity

  Fixes PR32142.

  r287232 accidentally increased the recursion threshold for
  CompareValueComplexity from 2 to 32.  This change reverses that
  change by introducing a separate flag for CompareValueComplexity's
  threshold.

The latter revision fixes the excessive compile times for skein_block.c.

MFC r314907 | mmel | 2017-03-08 12:40:27 +0100 (Wed, 08 Mar 2017) | 7 lines

Unbreak ARMv6 world.

The new compiler_rt library imported with clang 4.0.0 have several fatal
issues (non-functional __udivsi3 for example) with ARM specific instrict
functions. As temporary workaround, until upstream solve these problems,
disable all thumb[1][2] related feature.

MFC r315016:

Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release.
We were already very close to the last release candidate, so this is a
pretty minor update.

Relnotes:	yes

MFC r316005:

Revert r314907, and pull in r298713 from upstream compiler-rt trunk (by
Weiming Zhao):

  builtins: Select correct code fragments when compiling for Thumb1/Thum2/ARM ISA.

  Summary:
  Value of __ARM_ARCH_ISA_THUMB isn't based on the actual compilation
  mode (-mthumb, -marm), it reflect's capability of given CPU.

  Due to this:
   - use  __tbumb__ and __thumb2__ insteand of __ARM_ARCH_ISA_THUMB
   - use '.thumb' directive consistently  in all affected files
   - decorate all thumb functions using
     DEFINE_COMPILERRT_THUMB_FUNCTION()

  ---------
  Note: This patch doesn't fix broken Thumb1 variant of __udivsi3 !

  Reviewers: weimingz, rengolin, compnerd

  Subscribers: aemerson, dim

  Differential Revision: https://reviews.llvm.org/D30938

Discussed with:	mmel

1 files changed, 847 insertions, 1087 deletions

diff --git a/contrib/llvm/tools/lldb/source/API/SBDebugger.cpp b/contrib/llvm/tools/lldb/source/API/SBDebugger.cpp
index 3493ad5..97e6f7b 100644
--- a/contrib/llvm/tools/lldb/source/API/SBDebugger.cpp
+++ b/contrib/llvm/tools/lldb/source/API/SBDebugger.cpp
@@ -15,14 +15,13 @@
 
 #include "lldb/lldb-private.h"
 
-#include "lldb/API/SystemInitializerFull.h"
-#include "lldb/API/SBListener.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
+#include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBSourceManager.h"
 #include "lldb/API/SBStream.h"
@@ -30,11 +29,12 @@
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/API/SBTypeCategory.h"
-#include "lldb/API/SBTypeFormat.h"
 #include "lldb/API/SBTypeFilter.h"
+#include "lldb/API/SBTypeFormat.h"
 #include "lldb/API/SBTypeNameSpecifier.h"
 #include "lldb/API/SBTypeSummary.h"
 #include "lldb/API/SBTypeSynthetic.h"
+#include "lldb/API/SystemInitializerFull.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/State.h"
@@ -48,1332 +48,1092 @@
 #include "lldb/Target/TargetList.h"
 
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/ManagedStatic.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DynamicLibrary.h"
+#include "llvm/Support/ManagedStatic.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-static llvm::sys::DynamicLibrary
-LoadPlugin (const lldb::DebuggerSP &debugger_sp, const FileSpec& spec, Error& error)
-{
-    llvm::sys::DynamicLibrary dynlib = llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
-    if (dynlib.isValid())
-    {
-        typedef bool (*LLDBCommandPluginInit) (lldb::SBDebugger& debugger);
-        
-        lldb::SBDebugger debugger_sb(debugger_sp);
-        // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) function.
-        // TODO: mangle this differently for your system - on OSX, the first underscore needs to be removed and the second one stays
-        LLDBCommandPluginInit init_func = (LLDBCommandPluginInit)dynlib.getAddressOfSymbol("_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
-        if (init_func)
-        {
-            if (init_func(debugger_sb))
-                return dynlib;
-            else
-                error.SetErrorString("plug-in refused to load (lldb::PluginInitialize(lldb::SBDebugger) returned false)");
-        }
-        else
-        {
-            error.SetErrorString("plug-in is missing the required initialization: lldb::PluginInitialize(lldb::SBDebugger)");
-        }
+static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp,
+                                            const FileSpec &spec,
+                                            Error &error) {
+  llvm::sys::DynamicLibrary dynlib =
+      llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
+  if (dynlib.isValid()) {
+    typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
+
+    lldb::SBDebugger debugger_sb(debugger_sp);
+    // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
+    // function.
+    // TODO: mangle this differently for your system - on OSX, the first
+    // underscore needs to be removed and the second one stays
+    LLDBCommandPluginInit init_func =
+        (LLDBCommandPluginInit)dynlib.getAddressOfSymbol(
+            "_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
+    if (init_func) {
+      if (init_func(debugger_sb))
+        return dynlib;
+      else
+        error.SetErrorString("plug-in refused to load "
+                             "(lldb::PluginInitialize(lldb::SBDebugger) "
+                             "returned false)");
+    } else {
+      error.SetErrorString("plug-in is missing the required initialization: "
+                           "lldb::PluginInitialize(lldb::SBDebugger)");
     }
+  } else {
+    if (spec.Exists())
+      error.SetErrorString("this file does not represent a loadable dylib");
     else
-    {
-        if (spec.Exists())
-            error.SetErrorString("this file does not represent a loadable dylib");
-        else
-            error.SetErrorString("no such file");
-    }
-    return llvm::sys::DynamicLibrary();
+      error.SetErrorString("no such file");
+  }
+  return llvm::sys::DynamicLibrary();
 }
 
 static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
 
-SBError
-SBInputReader::Initialize(lldb::SBDebugger &sb_debugger,
-                          unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction, char const *,
-                                            unsigned long),
-                          void *, lldb::InputReaderGranularity, char const *, char const *, bool)
-{
-    return SBError();
+SBError SBInputReader::Initialize(
+    lldb::SBDebugger &sb_debugger,
+    unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
+                      char const *, unsigned long),
+    void *, lldb::InputReaderGranularity, char const *, char const *, bool) {
+  return SBError();
 }
 
-void
-SBInputReader::SetIsDone(bool)
-{
-}
+void SBInputReader::SetIsDone(bool) {}
 
-bool
-SBInputReader::IsActive() const
-{
-    return false;
-}
+bool SBInputReader::IsActive() const { return false; }
 
 SBDebugger::SBDebugger() = default;
 
-SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) :
-    m_opaque_sp(debugger_sp)
-{
-}
+SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
+    : m_opaque_sp(debugger_sp) {}
 
-SBDebugger::SBDebugger(const SBDebugger &rhs) :
-    m_opaque_sp (rhs.m_opaque_sp)
-{
-}
+SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
 
 SBDebugger::~SBDebugger() = default;
 
-SBDebugger &
-SBDebugger::operator = (const SBDebugger &rhs)
-{
-    if (this != &rhs)
-    {
-        m_opaque_sp = rhs.m_opaque_sp;
-    }
-    return *this;
+SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
+  if (this != &rhs) {
+    m_opaque_sp = rhs.m_opaque_sp;
+  }
+  return *this;
 }
 
-void
-SBDebugger::Initialize ()
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+void SBDebugger::Initialize() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    if (log)
-        log->Printf ("SBDebugger::Initialize ()");
+  if (log)
+    log->Printf("SBDebugger::Initialize ()");
 
-    g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerFull>(), LoadPlugin);
+  g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerFull>(),
+                                  LoadPlugin);
 }
 
-void
-SBDebugger::Terminate ()
-{
-    g_debugger_lifetime->Terminate();
-}
+void SBDebugger::Terminate() { g_debugger_lifetime->Terminate(); }
 
-void
-SBDebugger::Clear ()
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+void SBDebugger::Clear() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    if (log)
-        log->Printf ("SBDebugger(%p)::Clear ()",
-                     static_cast<void*>(m_opaque_sp.get()));
+  if (log)
+    log->Printf("SBDebugger(%p)::Clear ()",
+                static_cast<void *>(m_opaque_sp.get()));
 
-    if (m_opaque_sp)
-        m_opaque_sp->ClearIOHandlers ();
+  if (m_opaque_sp)
+    m_opaque_sp->ClearIOHandlers();
 
-    m_opaque_sp.reset();
+  m_opaque_sp.reset();
 }
 
-SBDebugger
-SBDebugger::Create()
-{
-    return SBDebugger::Create(false, nullptr, nullptr);
+SBDebugger SBDebugger::Create() {
+  return SBDebugger::Create(false, nullptr, nullptr);
 }
 
-SBDebugger
-SBDebugger::Create(bool source_init_files)
-{
-    return SBDebugger::Create (source_init_files, nullptr, nullptr);
+SBDebugger SBDebugger::Create(bool source_init_files) {
+  return SBDebugger::Create(source_init_files, nullptr, nullptr);
 }
 
-SBDebugger
-SBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton)
+SBDebugger SBDebugger::Create(bool source_init_files,
+                              lldb::LogOutputCallback callback, void *baton)
 
 {
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    SBDebugger debugger;
-    
-    // Currently we have issues if this function is called simultaneously on two different
-    // threads. The issues mainly revolve around the fact that the lldb_private::FormatManager
-    // uses global collections and having two threads parsing the .lldbinit files can cause
-    // mayhem. So to get around this for now we need to use a mutex to prevent bad things
-    // from happening.
-    static std::recursive_mutex g_mutex;
-    std::lock_guard<std::recursive_mutex> guard(g_mutex);
-
-    debugger.reset(Debugger::CreateInstance(callback, baton));
-
-    if (log)
-    {
-        SBStream sstr;
-        debugger.GetDescription (sstr);
-        log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s",
-                     static_cast<void*>(debugger.m_opaque_sp.get()),
-                     sstr.GetData());
-    }
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    SBCommandInterpreter interp = debugger.GetCommandInterpreter();
-    if (source_init_files)
-    {
-        interp.get()->SkipLLDBInitFiles(false);
-        interp.get()->SkipAppInitFiles (false);
-        SBCommandReturnObject result;
-        interp.SourceInitFileInHomeDirectory(result);
-    }
-    else
-    {
-        interp.get()->SkipLLDBInitFiles(true);
-        interp.get()->SkipAppInitFiles (true);
-    }
-    return debugger;
-}
+  SBDebugger debugger;
 
-void
-SBDebugger::Destroy (SBDebugger &debugger)
-{
-    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    if (log)
-    {
-        SBStream sstr;
-        debugger.GetDescription (sstr);
-        log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s",
-                     static_cast<void*>(debugger.m_opaque_sp.get()),
-                     sstr.GetData());
-    }
+  // Currently we have issues if this function is called simultaneously on two
+  // different
+  // threads. The issues mainly revolve around the fact that the
+  // lldb_private::FormatManager
+  // uses global collections and having two threads parsing the .lldbinit files
+  // can cause
+  // mayhem. So to get around this for now we need to use a mutex to prevent bad
+  // things
+  // from happening.
+  static std::recursive_mutex g_mutex;
+  std::lock_guard<std::recursive_mutex> guard(g_mutex);
 
-    Debugger::Destroy (debugger.m_opaque_sp);
+  debugger.reset(Debugger::CreateInstance(callback, baton));
 
-    if (debugger.m_opaque_sp.get() != nullptr)
-        debugger.m_opaque_sp.reset();
+  if (log) {
+    SBStream sstr;
+    debugger.GetDescription(sstr);
+    log->Printf("SBDebugger::Create () => SBDebugger(%p): %s",
+                static_cast<void *>(debugger.m_opaque_sp.get()),
+                sstr.GetData());
+  }
+
+  SBCommandInterpreter interp = debugger.GetCommandInterpreter();
+  if (source_init_files) {
+    interp.get()->SkipLLDBInitFiles(false);
+    interp.get()->SkipAppInitFiles(false);
+    SBCommandReturnObject result;
+    interp.SourceInitFileInHomeDirectory(result);
+  } else {
+    interp.get()->SkipLLDBInitFiles(true);
+    interp.get()->SkipAppInitFiles(true);
+  }
+  return debugger;
 }
 
-void
-SBDebugger::MemoryPressureDetected ()
-{
-    // Since this function can be call asynchronously, we allow it to be
-    // non-mandatory. We have seen deadlocks with this function when called
-    // so we need to safeguard against this until we can determine what is
-    // causing the deadlocks.
-    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    
-    const bool mandatory = false;
-    if (log)
-    {
-        log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory);
-    }
-    
-    ModuleList::RemoveOrphanSharedModules(mandatory);
+void SBDebugger::Destroy(SBDebugger &debugger) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  if (log) {
+    SBStream sstr;
+    debugger.GetDescription(sstr);
+    log->Printf("SBDebugger::Destroy () => SBDebugger(%p): %s",
+                static_cast<void *>(debugger.m_opaque_sp.get()),
+                sstr.GetData());
+  }
+
+  Debugger::Destroy(debugger.m_opaque_sp);
+
+  if (debugger.m_opaque_sp.get() != nullptr)
+    debugger.m_opaque_sp.reset();
 }
 
-bool
-SBDebugger::IsValid() const
-{
-    return m_opaque_sp.get() != nullptr;
+void SBDebugger::MemoryPressureDetected() {
+  // Since this function can be call asynchronously, we allow it to be
+  // non-mandatory. We have seen deadlocks with this function when called
+  // so we need to safeguard against this until we can determine what is
+  // causing the deadlocks.
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  const bool mandatory = false;
+  if (log) {
+    log->Printf("SBDebugger::MemoryPressureDetected (), mandatory = %d",
+                mandatory);
+  }
+
+  ModuleList::RemoveOrphanSharedModules(mandatory);
 }
 
-void
-SBDebugger::SetAsync (bool b)
-{
-    if (m_opaque_sp)
-        m_opaque_sp->SetAsyncExecution(b);
+bool SBDebugger::IsValid() const { return m_opaque_sp.get() != nullptr; }
+
+void SBDebugger::SetAsync(bool b) {
+  if (m_opaque_sp)
+    m_opaque_sp->SetAsyncExecution(b);
 }
 
-bool
-SBDebugger::GetAsync()
-{
-    return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
+bool SBDebugger::GetAsync() {
+  return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
 }
 
-void
-SBDebugger::SkipLLDBInitFiles (bool b)
-{
-    if (m_opaque_sp)
-        m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b);
+void SBDebugger::SkipLLDBInitFiles(bool b) {
+  if (m_opaque_sp)
+    m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
 }
 
-void
-SBDebugger::SkipAppInitFiles (bool b)
-{
-    if (m_opaque_sp)
-        m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b);
+void SBDebugger::SkipAppInitFiles(bool b) {
+  if (m_opaque_sp)
+    m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
 }
 
-// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users
+// Shouldn't really be settable after initialization as this could cause lots of
+// problems; don't want users
 // trying to switch modes in the middle of a debugging session.
-void
-SBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership)
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    if (log)
-        log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(fh), transfer_ownership);
+  if (log)
+    log->Printf(
+        "SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)",
+        static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
+        transfer_ownership);
 
-    if (m_opaque_sp)
-        m_opaque_sp->SetInputFileHandle (fh, transfer_ownership);
+  if (m_opaque_sp)
+    m_opaque_sp->SetInputFileHandle(fh, transfer_ownership);
 }
 
-void
-SBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership)
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
+void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    if (log)
-        log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(fh), transfer_ownership);
+  if (log)
+    log->Printf(
+        "SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)",
+        static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
+        transfer_ownership);
 
-    if (m_opaque_sp)
-        m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership);
+  if (m_opaque_sp)
+    m_opaque_sp->SetOutputFileHandle(fh, transfer_ownership);
 }
 
-void
-SBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership)
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
+void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    if (log)
-        log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(fh), transfer_ownership);
+  if (log)
+    log->Printf(
+        "SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)",
+        static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
+        transfer_ownership);
 
-    if (m_opaque_sp)
-        m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership);
+  if (m_opaque_sp)
+    m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
 }
 
-FILE *
-SBDebugger::GetInputFileHandle ()
-{
-    if (m_opaque_sp)
-    {
-        StreamFileSP stream_file_sp (m_opaque_sp->GetInputFile());
-        if (stream_file_sp)
-            return stream_file_sp->GetFile().GetStream();
-    }
-    return nullptr;
+FILE *SBDebugger::GetInputFileHandle() {
+  if (m_opaque_sp) {
+    StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
+    if (stream_file_sp)
+      return stream_file_sp->GetFile().GetStream();
+  }
+  return nullptr;
 }
 
-FILE *
-SBDebugger::GetOutputFileHandle ()
-{
-    if (m_opaque_sp)
-    {
-        StreamFileSP stream_file_sp (m_opaque_sp->GetOutputFile());
-        if (stream_file_sp)
-            return stream_file_sp->GetFile().GetStream();
-    }
-    return nullptr;
+FILE *SBDebugger::GetOutputFileHandle() {
+  if (m_opaque_sp) {
+    StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
+    if (stream_file_sp)
+      return stream_file_sp->GetFile().GetStream();
+  }
+  return nullptr;
 }
 
-FILE *
-SBDebugger::GetErrorFileHandle ()
-{
-    if (m_opaque_sp)
-    {
-        StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
-        if (stream_file_sp)
-            return stream_file_sp->GetFile().GetStream();
-    }
-    return nullptr;
+FILE *SBDebugger::GetErrorFileHandle() {
+  if (m_opaque_sp) {
+    StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
+    if (stream_file_sp)
+      return stream_file_sp->GetFile().GetStream();
+  }
+  return nullptr;
 }
 
-void
-SBDebugger::SaveInputTerminalState()
-{
-    if (m_opaque_sp)
-        m_opaque_sp->SaveInputTerminalState();
+void SBDebugger::SaveInputTerminalState() {
+  if (m_opaque_sp)
+    m_opaque_sp->SaveInputTerminalState();
 }
 
-void
-SBDebugger::RestoreInputTerminalState()
-{
-    if (m_opaque_sp)
-        m_opaque_sp->RestoreInputTerminalState();
-
+void SBDebugger::RestoreInputTerminalState() {
+  if (m_opaque_sp)
+    m_opaque_sp->RestoreInputTerminalState();
 }
-SBCommandInterpreter
-SBDebugger::GetCommandInterpreter ()
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    SBCommandInterpreter sb_interpreter;
-    if (m_opaque_sp)
-        sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter());
+  SBCommandInterpreter sb_interpreter;
+  if (m_opaque_sp)
+    sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
 
-    if (log)
-        log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(sb_interpreter.get()));
+  if (log)
+    log->Printf(
+        "SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
+        static_cast<void *>(m_opaque_sp.get()),
+        static_cast<void *>(sb_interpreter.get()));
 
-    return sb_interpreter;
+  return sb_interpreter;
 }
 
-void
-SBDebugger::HandleCommand (const char *command)
-{
-    if (m_opaque_sp)
-    {
-        TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
-        std::unique_lock<std::recursive_mutex> lock;
-        if (target_sp)
-            lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
-
-        SBCommandInterpreter sb_interpreter(GetCommandInterpreter ());
-        SBCommandReturnObject result;
-
-        sb_interpreter.HandleCommand (command, result, false);
-
-        if (GetErrorFileHandle() != nullptr)
-            result.PutError (GetErrorFileHandle());
-        if (GetOutputFileHandle() != nullptr)
-            result.PutOutput (GetOutputFileHandle());
-
-        if (!m_opaque_sp->GetAsyncExecution())
-        {
-            SBProcess process(GetCommandInterpreter().GetProcess ());
-            ProcessSP process_sp (process.GetSP());
-            if (process_sp)
-            {
-                EventSP event_sp;
-                ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
-                while (lldb_listener_sp->GetNextEventForBroadcaster (process_sp.get(), event_sp))
-                {
-                    SBEvent event(event_sp);
-                    HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle());
-                }
-            }
-        }
-    }
-}
+void SBDebugger::HandleCommand(const char *command) {
+  if (m_opaque_sp) {
+    TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
+    std::unique_lock<std::recursive_mutex> lock;
+    if (target_sp)
+      lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 
-SBListener
-SBDebugger::GetListener ()
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+    SBCommandInterpreter sb_interpreter(GetCommandInterpreter());
+    SBCommandReturnObject result;
 
-    SBListener sb_listener;
-    if (m_opaque_sp)
-        sb_listener.reset(m_opaque_sp->GetListener());
+    sb_interpreter.HandleCommand(command, result, false);
 
-    if (log)
-        log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(sb_listener.get()));
+    if (GetErrorFileHandle() != nullptr)
+      result.PutError(GetErrorFileHandle());
+    if (GetOutputFileHandle() != nullptr)
+      result.PutOutput(GetOutputFileHandle());
 
-    return sb_listener;
+    if (!m_opaque_sp->GetAsyncExecution()) {
+      SBProcess process(GetCommandInterpreter().GetProcess());
+      ProcessSP process_sp(process.GetSP());
+      if (process_sp) {
+        EventSP event_sp;
+        ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
+        while (lldb_listener_sp->GetEventForBroadcaster(
+            process_sp.get(), event_sp, std::chrono::seconds(0))) {
+          SBEvent event(event_sp);
+          HandleProcessEvent(process, event, GetOutputFileHandle(),
+                             GetErrorFileHandle());
+        }
+      }
+    }
+  }
 }
 
-void
-SBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err)
-{
-    if (!process.IsValid())
-        return;
-
-    TargetSP target_sp (process.GetTarget().GetSP());
-    if (!target_sp)
-        return;
+SBListener SBDebugger::GetListener() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    const uint32_t event_type = event.GetType();
-    char stdio_buffer[1024];
-    size_t len;
+  SBListener sb_listener;
+  if (m_opaque_sp)
+    sb_listener.reset(m_opaque_sp->GetListener());
 
-    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+  if (log)
+    log->Printf("SBDebugger(%p)::GetListener () => SBListener(%p)",
+                static_cast<void *>(m_opaque_sp.get()),
+                static_cast<void *>(sb_listener.get()));
 
-    if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged))
-    {
-        // Drain stdout when we stop just in case we have any bytes
-        while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0)
-            if (out != nullptr)
-                ::fwrite (stdio_buffer, 1, len, out);
-    }
-    
-    if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged))
-    {
-        // Drain stderr when we stop just in case we have any bytes
-        while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0)
-            if (err != nullptr)
-                ::fwrite (stdio_buffer, 1, len, err);
-    }
-    
-    if (event_type & Process::eBroadcastBitStateChanged)
-    {
-        StateType event_state = SBProcess::GetStateFromEvent (event);
-        
-        if (event_state == eStateInvalid)
-            return;
-        
-        bool is_stopped = StateIsStoppedState (event_state);
-        if (!is_stopped)
-            process.ReportEventState (event, out);
-    }
+  return sb_listener;
 }
 
-SBSourceManager
-SBDebugger::GetSourceManager ()
-{
-    SBSourceManager sb_source_manager (*this);
-    return sb_source_manager;
-}
+void SBDebugger::HandleProcessEvent(const SBProcess &process,
+                                    const SBEvent &event, FILE *out,
+                                    FILE *err) {
+  if (!process.IsValid())
+    return;
 
-bool
-SBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len)
-{
-    if (arch_name && arch_name_len)
-    {
-        ArchSpec default_arch = Target::GetDefaultArchitecture ();
-
-        if (default_arch.IsValid())
-        {
-            const std::string &triple_str = default_arch.GetTriple().str();
-            if (!triple_str.empty())
-                ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str());
-            else
-                ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName());
-            return true;
-        }
-    }
-    if (arch_name && arch_name_len)
-        arch_name[0] = '\0';
-    return false;
-}
+  TargetSP target_sp(process.GetTarget().GetSP());
+  if (!target_sp)
+    return;
 
-bool
-SBDebugger::SetDefaultArchitecture (const char *arch_name)
-{
-    if (arch_name)
-    {
-        ArchSpec arch (arch_name);
-        if (arch.IsValid())
-        {
-            Target::SetDefaultArchitecture (arch);
-            return true;
-        }
-    }
-    return false;
-}
+  const uint32_t event_type = event.GetType();
+  char stdio_buffer[1024];
+  size_t len;
 
-ScriptLanguage
-SBDebugger::GetScriptingLanguage(const char *script_language_name)
-{
-    return Args::StringToScriptLanguage(script_language_name,
-                                        eScriptLanguageDefault,
-                                        nullptr);
-}
+  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
-const char *
-SBDebugger::GetVersionString ()
-{
-    return lldb_private::GetVersion();
-}
+  if (event_type &
+      (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) {
+    // Drain stdout when we stop just in case we have any bytes
+    while ((len = process.GetSTDOUT(stdio_buffer, sizeof(stdio_buffer))) > 0)
+      if (out != nullptr)
+        ::fwrite(stdio_buffer, 1, len, out);
+  }
 
-const char *
-SBDebugger::StateAsCString (StateType state)
-{
-    return lldb_private::StateAsCString (state);
-}
+  if (event_type &
+      (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) {
+    // Drain stderr when we stop just in case we have any bytes
+    while ((len = process.GetSTDERR(stdio_buffer, sizeof(stdio_buffer))) > 0)
+      if (err != nullptr)
+        ::fwrite(stdio_buffer, 1, len, err);
+  }
 
-bool
-SBDebugger::StateIsRunningState (StateType state)
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+  if (event_type & Process::eBroadcastBitStateChanged) {
+    StateType event_state = SBProcess::GetStateFromEvent(event);
 
-    const bool result = lldb_private::StateIsRunningState (state);
-    if (log)
-        log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i", 
-                     StateAsCString (state), result);
+    if (event_state == eStateInvalid)
+      return;
 
-    return result;
+    bool is_stopped = StateIsStoppedState(event_state);
+    if (!is_stopped)
+      process.ReportEventState(event, out);
+  }
 }
 
-bool
-SBDebugger::StateIsStoppedState (StateType state)
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    const bool result = lldb_private::StateIsStoppedState (state, false);
-    if (log)
-        log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i", 
-                     StateAsCString (state), result);
-
-    return result;
+SBSourceManager SBDebugger::GetSourceManager() {
+  SBSourceManager sb_source_manager(*this);
+  return sb_source_manager;
 }
 
-lldb::SBTarget
-SBDebugger::CreateTarget (const char *filename,
-                          const char *target_triple,
-                          const char *platform_name,
-                          bool add_dependent_modules,
-                          lldb::SBError& sb_error)
-{
-    SBTarget sb_target;
-    TargetSP target_sp;
-    if (m_opaque_sp)
-    {
-        sb_error.Clear();
-        OptionGroupPlatform platform_options (false);
-        platform_options.SetPlatformName (platform_name);
-
-        sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 
-                                                                    filename, 
-                                                                    target_triple, 
-                                                                    add_dependent_modules, 
-                                                                    &platform_options,
-                                                                    target_sp);
-
-        if (sb_error.Success())
-            sb_target.SetSP (target_sp);
+bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
+  if (arch_name && arch_name_len) {
+    ArchSpec default_arch = Target::GetDefaultArchitecture();
+
+    if (default_arch.IsValid()) {
+      const std::string &triple_str = default_arch.GetTriple().str();
+      if (!triple_str.empty())
+        ::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str());
+      else
+        ::snprintf(arch_name, arch_name_len, "%s",
+                   default_arch.GetArchitectureName());
+      return true;
     }
-    else
-    {
-        sb_error.SetErrorString("invalid debugger");
+  }
+  if (arch_name && arch_name_len)
+    arch_name[0] = '\0';
+  return false;
+}
+
+bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
+  if (arch_name) {
+    ArchSpec arch(arch_name);
+    if (arch.IsValid()) {
+      Target::SetDefaultArchitecture(arch);
+      return true;
     }
-
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)",
-                     static_cast<void*>(m_opaque_sp.get()), filename,
-                     target_triple, platform_name, add_dependent_modules,
-                     sb_error.GetCString(), static_cast<void*>(target_sp.get()));
-
-    return sb_target;
+  }
+  return false;
 }
 
-SBTarget
-SBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename,
-                                                 const char *target_triple)
-{
-    SBTarget sb_target;
-    TargetSP target_sp;
-    if (m_opaque_sp)
-    {
-        const bool add_dependent_modules = true;
-        Error error (m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp,
-                                                               filename,
-                                                               target_triple,
-                                                               add_dependent_modules,
-                                                               nullptr,
-                                                               target_sp));
-        sb_target.SetSP (target_sp);
-    }
-
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)",
-                     static_cast<void*>(m_opaque_sp.get()), filename,
-                     target_triple, static_cast<void*>(target_sp.get()));
-
-    return sb_target;
+ScriptLanguage
+SBDebugger::GetScriptingLanguage(const char *script_language_name) {
+  if (!script_language_name) return eScriptLanguageDefault;
+  return Args::StringToScriptLanguage(llvm::StringRef(script_language_name),
+                                      eScriptLanguageDefault, nullptr);
 }
 
-SBTarget
-SBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr)
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    SBTarget sb_target;
-    TargetSP target_sp;
-    if (m_opaque_sp)
-    {
-        Error error;
-        const bool add_dependent_modules = true;
-
-        error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp,
-                                                          filename,
-                                                          arch_cstr,
-                                                          add_dependent_modules,
-                                                          nullptr,
-                                                          target_sp);
-
-        if (error.Success())
-        {
-            m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
-            sb_target.SetSP (target_sp);
-        }
-    }
-
-    if (log)
-        log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)",
-                     static_cast<void*>(m_opaque_sp.get()), filename, arch_cstr,
-                     static_cast<void*>(target_sp.get()));
-
-    return sb_target;
+const char *SBDebugger::GetVersionString() {
+  return lldb_private::GetVersion();
 }
 
-SBTarget
-SBDebugger::CreateTarget (const char *filename)
-{
-    SBTarget sb_target;
-    TargetSP target_sp;
-    if (m_opaque_sp)
-    {
-        Error error;
-        const bool add_dependent_modules = true;
-        error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp,
-                                                          filename,
-                                                          nullptr,
-                                                          add_dependent_modules,
-                                                          nullptr,
-                                                          target_sp);
-
-        if (error.Success())
-        {
-            m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
-            sb_target.SetSP (target_sp);
-        }
-    }
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
-                     static_cast<void*>(m_opaque_sp.get()), filename,
-                     static_cast<void*>(target_sp.get()));
-    return sb_target;
+const char *SBDebugger::StateAsCString(StateType state) {
+  return lldb_private::StateAsCString(state);
 }
 
-bool
-SBDebugger::DeleteTarget (lldb::SBTarget &target)
-{
-    bool result = false;
-    if (m_opaque_sp)
-    {
-        TargetSP target_sp(target.GetSP());
-        if (target_sp)
-        {
-            // No need to lock, the target list is thread safe
-            result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp);
-            target_sp->Destroy();
-            target.Clear();
-            const bool mandatory = true;
-            ModuleList::RemoveOrphanSharedModules(mandatory);
-        }
-    }
+bool SBDebugger::StateIsRunningState(StateType state) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(target.m_opaque_sp.get()), result);
+  const bool result = lldb_private::StateIsRunningState(state);
+  if (log)
+    log->Printf("SBDebugger::StateIsRunningState (state=%s) => %i",
+                StateAsCString(state), result);
 
-    return result;
+  return result;
 }
 
-SBTarget
-SBDebugger::GetTargetAtIndex (uint32_t idx)
-{
-    SBTarget sb_target;
-    if (m_opaque_sp)
-    {
-        // No need to lock, the target list is thread safe
-        sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx));
-    }
-    return sb_target;
-}
+bool SBDebugger::StateIsStoppedState(StateType state) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-uint32_t
-SBDebugger::GetIndexOfTarget (lldb::SBTarget target)
-{
+  const bool result = lldb_private::StateIsStoppedState(state, false);
+  if (log)
+    log->Printf("SBDebugger::StateIsStoppedState (state=%s) => %i",
+                StateAsCString(state), result);
 
-    lldb::TargetSP target_sp = target.GetSP();
-    if (!target_sp)
-        return UINT32_MAX;
+  return result;
+}
 
-    if (!m_opaque_sp)
-        return UINT32_MAX;
+lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
+                                        const char *target_triple,
+                                        const char *platform_name,
+                                        bool add_dependent_modules,
+                                        lldb::SBError &sb_error) {
+  SBTarget sb_target;
+  TargetSP target_sp;
+  if (m_opaque_sp) {
+    sb_error.Clear();
+    OptionGroupPlatform platform_options(false);
+    platform_options.SetPlatformName(platform_name);
 
-    return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP());
-}
+    sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
+        *m_opaque_sp, filename, target_triple, add_dependent_modules,
+        &platform_options, target_sp);
 
-SBTarget
-SBDebugger::FindTargetWithProcessID (lldb::pid_t pid)
-{
-    SBTarget sb_target;
-    if (m_opaque_sp)
-    {
-        // No need to lock, the target list is thread safe
-        sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid));
-    }
-    return sb_target;
-}
+    if (sb_error.Success())
+      sb_target.SetSP(target_sp);
+  } else {
+    sb_error.SetErrorString("invalid debugger");
+  }
 
-SBTarget
-SBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name)
-{
-    SBTarget sb_target;
-    if (m_opaque_sp && filename && filename[0])
-    {
-        // No need to lock, the target list is thread safe
-        ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get());
-        TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(FileSpec(filename, false), arch_name ? &arch : nullptr));
-        sb_target.SetSP (target_sp);
-    }
-    return sb_target;
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, "
+                "platform_name=%s, add_dependent_modules=%u, error=%s) => "
+                "SBTarget(%p)",
+                static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
+                platform_name, add_dependent_modules, sb_error.GetCString(),
+                static_cast<void *>(target_sp.get()));
+
+  return sb_target;
 }
 
 SBTarget
-SBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp)
-{
-    SBTarget sb_target;
-    if (m_opaque_sp)
-    {
-        // No need to lock, the target list is thread safe
-        sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get()));
-    }
-    return sb_target;
-}
+SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
+                                                const char *target_triple) {
+  SBTarget sb_target;
+  TargetSP target_sp;
+  if (m_opaque_sp) {
+    const bool add_dependent_modules = true;
+    Error error(m_opaque_sp->GetTargetList().CreateTarget(
+        *m_opaque_sp, filename, target_triple, add_dependent_modules, nullptr,
+        target_sp));
+    sb_target.SetSP(target_sp);
+  }
+
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple "
+                "(filename=\"%s\", triple=%s) => SBTarget(%p)",
+                static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
+                static_cast<void *>(target_sp.get()));
+
+  return sb_target;
+}
+
+SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
+                                                 const char *arch_cstr) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  SBTarget sb_target;
+  TargetSP target_sp;
+  if (m_opaque_sp) {
+    Error error;
+    const bool add_dependent_modules = true;
 
-uint32_t
-SBDebugger::GetNumTargets ()
-{
-    if (m_opaque_sp)
-    {
-        // No need to lock, the target list is thread safe
-        return m_opaque_sp->GetTargetList().GetNumTargets ();
-    }
-    return 0;
-}
+    error = m_opaque_sp->GetTargetList().CreateTarget(
+        *m_opaque_sp, filename, arch_cstr, add_dependent_modules, nullptr,
+        target_sp);
 
-SBTarget
-SBDebugger::GetSelectedTarget ()
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    SBTarget sb_target;
-    TargetSP target_sp;
-    if (m_opaque_sp)
-    {
-        // No need to lock, the target list is thread safe
-        target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget ();
-        sb_target.SetSP (target_sp);
+    if (error.Success()) {
+      m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
+      sb_target.SetSP(target_sp);
     }
+  }
 
-    if (log)
-    {
-        SBStream sstr;
-        sb_target.GetDescription (sstr, eDescriptionLevelBrief);
-        log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(target_sp.get()), sstr.GetData());
-    }
+  if (log)
+    log->Printf("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", "
+                "arch=%s) => SBTarget(%p)",
+                static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
+                static_cast<void *>(target_sp.get()));
 
-    return sb_target;
+  return sb_target;
 }
 
-void
-SBDebugger::SetSelectedTarget (SBTarget &sb_target)
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+SBTarget SBDebugger::CreateTarget(const char *filename) {
+  SBTarget sb_target;
+  TargetSP target_sp;
+  if (m_opaque_sp) {
+    Error error;
+    const bool add_dependent_modules = true;
+    error = m_opaque_sp->GetTargetList().CreateTarget(
+        *m_opaque_sp, filename, "", add_dependent_modules, nullptr, target_sp);
 
-    TargetSP target_sp (sb_target.GetSP());
-    if (m_opaque_sp)
-    {
-        m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
+    if (error.Success()) {
+      m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
+      sb_target.SetSP(target_sp);
     }
-    if (log)
-    {
-        SBStream sstr;
-        sb_target.GetDescription (sstr, eDescriptionLevelBrief);
-        log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(target_sp.get()), sstr.GetData());
+  }
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf(
+        "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
+        static_cast<void *>(m_opaque_sp.get()), filename,
+        static_cast<void *>(target_sp.get()));
+  return sb_target;
+}
+
+bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
+  bool result = false;
+  if (m_opaque_sp) {
+    TargetSP target_sp(target.GetSP());
+    if (target_sp) {
+      // No need to lock, the target list is thread safe
+      result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp);
+      target_sp->Destroy();
+      target.Clear();
+      const bool mandatory = true;
+      ModuleList::RemoveOrphanSharedModules(mandatory);
     }
-}
-
-SBPlatform
-SBDebugger::GetSelectedPlatform()
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+  }
 
-    SBPlatform sb_platform;
-    DebuggerSP debugger_sp(m_opaque_sp);
-    if (debugger_sp)
-    {
-        sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
-    }
-    if (log)
-        log->Printf ("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(sb_platform.GetSP().get()),
-                     sb_platform.GetName());
-    return sb_platform;
-}
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
+                static_cast<void *>(m_opaque_sp.get()),
+                static_cast<void *>(target.m_opaque_sp.get()), result);
+
+  return result;
+}
+
+SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
+  SBTarget sb_target;
+  if (m_opaque_sp) {
+    // No need to lock, the target list is thread safe
+    sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
+  }
+  return sb_target;
+}
+
+uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
+
+  lldb::TargetSP target_sp = target.GetSP();
+  if (!target_sp)
+    return UINT32_MAX;
+
+  if (!m_opaque_sp)
+    return UINT32_MAX;
+
+  return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
+}
+
+SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
+  SBTarget sb_target;
+  if (m_opaque_sp) {
+    // No need to lock, the target list is thread safe
+    sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid));
+  }
+  return sb_target;
+}
+
+SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
+                                               const char *arch_name) {
+  SBTarget sb_target;
+  if (m_opaque_sp && filename && filename[0]) {
+    // No need to lock, the target list is thread safe
+    ArchSpec arch(arch_name,
+                  m_opaque_sp->GetPlatformList().GetSelectedPlatform().get());
+    TargetSP target_sp(
+        m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
+            FileSpec(filename, false), arch_name ? &arch : nullptr));
+    sb_target.SetSP(target_sp);
+  }
+  return sb_target;
+}
+
+SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
+  SBTarget sb_target;
+  if (m_opaque_sp) {
+    // No need to lock, the target list is thread safe
+    sb_target.SetSP(
+        m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get()));
+  }
+  return sb_target;
+}
+
+uint32_t SBDebugger::GetNumTargets() {
+  if (m_opaque_sp) {
+    // No need to lock, the target list is thread safe
+    return m_opaque_sp->GetTargetList().GetNumTargets();
+  }
+  return 0;
+}
 
-void
-SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform)
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+SBTarget SBDebugger::GetSelectedTarget() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  SBTarget sb_target;
+  TargetSP target_sp;
+  if (m_opaque_sp) {
+    // No need to lock, the target list is thread safe
+    target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget();
+    sb_target.SetSP(target_sp);
+  }
 
-    DebuggerSP debugger_sp(m_opaque_sp);
-    if (debugger_sp)
-    {
-        debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
-    }
+  if (log) {
+    SBStream sstr;
+    sb_target.GetDescription(sstr, eDescriptionLevelBrief);
+    log->Printf("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
+                static_cast<void *>(m_opaque_sp.get()),
+                static_cast<void *>(target_sp.get()), sstr.GetData());
+  }
 
-    if (log)
-        log->Printf ("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(sb_platform.GetSP().get()),
-                     sb_platform.GetName());
+  return sb_target;
 }
 
-void
-SBDebugger::DispatchInput (void* baton, const void *data, size_t data_len)
-{
-    DispatchInput (data,data_len);
+void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  TargetSP target_sp(sb_target.GetSP());
+  if (m_opaque_sp) {
+    m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
+  }
+  if (log) {
+    SBStream sstr;
+    sb_target.GetDescription(sstr, eDescriptionLevelBrief);
+    log->Printf("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
+                static_cast<void *>(m_opaque_sp.get()),
+                static_cast<void *>(target_sp.get()), sstr.GetData());
+  }
+}
+
+SBPlatform SBDebugger::GetSelectedPlatform() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  SBPlatform sb_platform;
+  DebuggerSP debugger_sp(m_opaque_sp);
+  if (debugger_sp) {
+    sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
+  }
+  if (log)
+    log->Printf("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
+                static_cast<void *>(m_opaque_sp.get()),
+                static_cast<void *>(sb_platform.GetSP().get()),
+                sb_platform.GetName());
+  return sb_platform;
 }
 
-void
-SBDebugger::DispatchInput (const void *data, size_t data_len)
-{
-//    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-//
-//    if (log)
-//        log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")",
-//                     m_opaque_sp.get(),
-//                     (int) data_len,
-//                     (const char *) data,
-//                     (uint64_t)data_len);
-//
-//    if (m_opaque_sp)
-//        m_opaque_sp->DispatchInput ((const char *) data, data_len);
-}
+void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  DebuggerSP debugger_sp(m_opaque_sp);
+  if (debugger_sp) {
+    debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
+  }
 
-void
-SBDebugger::DispatchInputInterrupt ()
-{
-    if (m_opaque_sp)
-        m_opaque_sp->DispatchInputInterrupt ();
+  if (log)
+    log->Printf("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
+                static_cast<void *>(m_opaque_sp.get()),
+                static_cast<void *>(sb_platform.GetSP().get()),
+                sb_platform.GetName());
+}
+
+void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
+  DispatchInput(data, data_len);
+}
+
+void SBDebugger::DispatchInput(const void *data, size_t data_len) {
+  //    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+  //
+  //    if (log)
+  //        log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\",
+  //        size_t=%" PRIu64 ")",
+  //                     m_opaque_sp.get(),
+  //                     (int) data_len,
+  //                     (const char *) data,
+  //                     (uint64_t)data_len);
+  //
+  //    if (m_opaque_sp)
+  //        m_opaque_sp->DispatchInput ((const char *) data, data_len);
 }
 
-void
-SBDebugger::DispatchInputEndOfFile ()
-{
-    if (m_opaque_sp)
-        m_opaque_sp->DispatchInputEndOfFile ();
+void SBDebugger::DispatchInputInterrupt() {
+  if (m_opaque_sp)
+    m_opaque_sp->DispatchInputInterrupt();
 }
 
-void
-SBDebugger::PushInputReader (SBInputReader &reader)
-{
+void SBDebugger::DispatchInputEndOfFile() {
+  if (m_opaque_sp)
+    m_opaque_sp->DispatchInputEndOfFile();
 }
 
-void
-SBDebugger::RunCommandInterpreter (bool auto_handle_events,
-                                   bool spawn_thread)
-{
-    if (m_opaque_sp)
-    {
-        CommandInterpreterRunOptions options;
+void SBDebugger::PushInputReader(SBInputReader &reader) {}
 
-        m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(auto_handle_events,
-                                                                   spawn_thread,
-                                                                   options);
-    }
+void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
+                                       bool spawn_thread) {
+  if (m_opaque_sp) {
+    CommandInterpreterRunOptions options;
+
+    m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
+        auto_handle_events, spawn_thread, options);
+  }
 }
 
-void
-SBDebugger::RunCommandInterpreter (bool auto_handle_events,
-                                   bool spawn_thread,
-                                   SBCommandInterpreterRunOptions &options,
-                                   int  &num_errors,
-                                   bool &quit_requested,
-                                   bool &stopped_for_crash)
+void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
+                                       bool spawn_thread,
+                                       SBCommandInterpreterRunOptions &options,
+                                       int &num_errors, bool &quit_requested,
+                                       bool &stopped_for_crash)
 
 {
-    if (m_opaque_sp)
-    {
-        CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
-        interp.RunCommandInterpreter(auto_handle_events, spawn_thread, options.ref());
-        num_errors = interp.GetNumErrors();
-        quit_requested = interp.GetQuitRequested();
-        stopped_for_crash = interp.GetStoppedForCrash();
-    }
+  if (m_opaque_sp) {
+    CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
+    interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
+                                 options.ref());
+    num_errors = interp.GetNumErrors();
+    quit_requested = interp.GetQuitRequested();
+    stopped_for_crash = interp.GetStoppedForCrash();
+  }
 }
 
-SBError
-SBDebugger::RunREPL (lldb::LanguageType language, const char *repl_options)
-{
-    SBError error;
-    if (m_opaque_sp)
-        error.ref() = m_opaque_sp->RunREPL(language, repl_options);
-    else
-        error.SetErrorString ("invalid debugger");
-    return error;
+SBError SBDebugger::RunREPL(lldb::LanguageType language,
+                            const char *repl_options) {
+  SBError error;
+  if (m_opaque_sp)
+    error.ref() = m_opaque_sp->RunREPL(language, repl_options);
+  else
+    error.SetErrorString("invalid debugger");
+  return error;
 }
 
-void
-SBDebugger::reset (const DebuggerSP &debugger_sp)
-{
-    m_opaque_sp = debugger_sp;
+void SBDebugger::reset(const DebuggerSP &debugger_sp) {
+  m_opaque_sp = debugger_sp;
 }
 
-Debugger *
-SBDebugger::get () const
-{
-    return m_opaque_sp.get();
-}
+Debugger *SBDebugger::get() const { return m_opaque_sp.get(); }
 
-Debugger &
-SBDebugger::ref () const
-{
-    assert (m_opaque_sp.get());
-    return *m_opaque_sp;
+Debugger &SBDebugger::ref() const {
+  assert(m_opaque_sp.get());
+  return *m_opaque_sp;
 }
 
-const lldb::DebuggerSP &
-SBDebugger::get_sp () const
-{
-    return m_opaque_sp;
-}
+const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
 
-SBDebugger
-SBDebugger::FindDebuggerWithID (int id)
-{
-    // No need to lock, the debugger list is thread safe
-    SBDebugger sb_debugger;
-    DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id);
-    if (debugger_sp)
-        sb_debugger.reset (debugger_sp);
-    return sb_debugger;
+SBDebugger SBDebugger::FindDebuggerWithID(int id) {
+  // No need to lock, the debugger list is thread safe
+  SBDebugger sb_debugger;
+  DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id);
+  if (debugger_sp)
+    sb_debugger.reset(debugger_sp);
+  return sb_debugger;
 }
 
-const char *
-SBDebugger::GetInstanceName()
-{
-    return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
+const char *SBDebugger::GetInstanceName() {
+  return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
 }
 
-SBError
-SBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name)
-{
-    SBError sb_error;
-    DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
-    Error error;
-    if (debugger_sp)
-    {
-        ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
-        error = debugger_sp->SetPropertyValue (&exe_ctx,
-                                               eVarSetOperationAssign,
-                                               var_name,
-                                               value);
-    }
-    else
-    {
-        error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name);
-    }
-    if (error.Fail())
-        sb_error.SetError(error);
-    return sb_error;
+SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
+                                        const char *debugger_instance_name) {
+  SBError sb_error;
+  DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
+      ConstString(debugger_instance_name)));
+  Error error;
+  if (debugger_sp) {
+    ExecutionContext exe_ctx(
+        debugger_sp->GetCommandInterpreter().GetExecutionContext());
+    error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
+                                          var_name, value);
+  } else {
+    error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
+                                   debugger_instance_name);
+  }
+  if (error.Fail())
+    sb_error.SetError(error);
+  return sb_error;
 }
 
 SBStringList
-SBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name)
-{
-    SBStringList ret_value;
-    DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
-    Error error;
-    if (debugger_sp)
-    {
-        ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
-        lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx,
-                                                                     var_name,
-                                                                     false,
-                                                                     error));
-        if (value_sp)
-        {
-            StreamString value_strm;
-            value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
-            const std::string &value_str = value_strm.GetString();
-            if (!value_str.empty())
-            {
-                StringList string_list;
-                string_list.SplitIntoLines(value_str);
-                return SBStringList(&string_list);
-            }
-        }
+SBDebugger::GetInternalVariableValue(const char *var_name,
+                                     const char *debugger_instance_name) {
+  SBStringList ret_value;
+  DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
+      ConstString(debugger_instance_name)));
+  Error error;
+  if (debugger_sp) {
+    ExecutionContext exe_ctx(
+        debugger_sp->GetCommandInterpreter().GetExecutionContext());
+    lldb::OptionValueSP value_sp(
+        debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
+    if (value_sp) {
+      StreamString value_strm;
+      value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
+      const std::string &value_str = value_strm.GetString();
+      if (!value_str.empty()) {
+        StringList string_list;
+        string_list.SplitIntoLines(value_str);
+        return SBStringList(&string_list);
+      }
     }
-    return SBStringList();
+  }
+  return SBStringList();
 }
 
-uint32_t
-SBDebugger::GetTerminalWidth() const
-{
-    return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
+uint32_t SBDebugger::GetTerminalWidth() const {
+  return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
 }
 
-void
-SBDebugger::SetTerminalWidth (uint32_t term_width)
-{
-    if (m_opaque_sp)
-        m_opaque_sp->SetTerminalWidth (term_width);
+void SBDebugger::SetTerminalWidth(uint32_t term_width) {
+  if (m_opaque_sp)
+    m_opaque_sp->SetTerminalWidth(term_width);
 }
 
-const char *
-SBDebugger::GetPrompt() const
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+const char *SBDebugger::GetPrompt() const {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    if (log)
-        log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     (m_opaque_sp ? m_opaque_sp->GetPrompt() : ""));
+  if (log)
+    log->Printf("SBDebugger(%p)::GetPrompt () => \"%s\"",
+                static_cast<void *>(m_opaque_sp.get()),
+                (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
 
-    return (m_opaque_sp ? m_opaque_sp->GetPrompt() : nullptr);
+  return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
+                      : nullptr);
 }
 
-void
-SBDebugger::SetPrompt (const char *prompt)
-{
-    if (m_opaque_sp)
-        m_opaque_sp->SetPrompt (prompt);
+void SBDebugger::SetPrompt(const char *prompt) {
+  if (m_opaque_sp)
+    m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
 }
-    
-ScriptLanguage 
-SBDebugger::GetScriptLanguage() const
-{
-    return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
+
+ScriptLanguage SBDebugger::GetScriptLanguage() const {
+  return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
 }
 
-void
-SBDebugger::SetScriptLanguage (ScriptLanguage script_lang)
-{
-    if (m_opaque_sp)
-    {
-        m_opaque_sp->SetScriptLanguage (script_lang);
-    }
+void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
+  if (m_opaque_sp) {
+    m_opaque_sp->SetScriptLanguage(script_lang);
+  }
 }
 
-bool
-SBDebugger::SetUseExternalEditor(bool value)
-{
-    return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
+bool SBDebugger::SetUseExternalEditor(bool value) {
+  return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
 }
 
-bool
-SBDebugger::GetUseExternalEditor()
-{
-    return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
+bool SBDebugger::GetUseExternalEditor() {
+  return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
 }
 
-bool
-SBDebugger::SetUseColor(bool value)
-{
-    return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
+bool SBDebugger::SetUseColor(bool value) {
+  return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
 }
 
-bool
-SBDebugger::GetUseColor() const
-{
-    return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
+bool SBDebugger::GetUseColor() const {
+  return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
 }
 
-bool
-SBDebugger::GetDescription (SBStream &description)
-{
-    Stream &strm = description.ref();
+bool SBDebugger::GetDescription(SBStream &description) {
+  Stream &strm = description.ref();
 
-    if (m_opaque_sp)
-    {
-        const char *name = m_opaque_sp->GetInstanceName().AsCString();
-        user_id_t id = m_opaque_sp->GetID();
-        strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
-    }
-    else
-        strm.PutCString ("No value");
-    
-    return true;
+  if (m_opaque_sp) {
+    const char *name = m_opaque_sp->GetInstanceName().AsCString();
+    user_id_t id = m_opaque_sp->GetID();
+    strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
+  } else
+    strm.PutCString("No value");
+
+  return true;
 }
 
-user_id_t
-SBDebugger::GetID()
-{
-    return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
+user_id_t SBDebugger::GetID() {
+  return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
 }
 
-SBError
-SBDebugger::SetCurrentPlatform (const char *platform_name_cstr)
-{
-    SBError sb_error;
-    if (m_opaque_sp)
-    {
-        if (platform_name_cstr && platform_name_cstr[0])
-        {
-            ConstString platform_name (platform_name_cstr);
-            PlatformSP platform_sp (Platform::Find (platform_name));
-
-            if (platform_sp)
-            {
-                // Already have a platform with this name, just select it
-                m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
-            }
-            else
-            {
-                // We don't have a platform by this name yet, create one
-                platform_sp = Platform::Create (platform_name, sb_error.ref());
-                if (platform_sp)
-                {
-                    // We created the platform, now append and select it
-                    bool make_selected = true;
-                    m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected);
-                }
-            }
-        }
-        else
-        {
-            sb_error.ref().SetErrorString("invalid platform name");
+SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
+  SBError sb_error;
+  if (m_opaque_sp) {
+    if (platform_name_cstr && platform_name_cstr[0]) {
+      ConstString platform_name(platform_name_cstr);
+      PlatformSP platform_sp(Platform::Find(platform_name));
+
+      if (platform_sp) {
+        // Already have a platform with this name, just select it
+        m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
+      } else {
+        // We don't have a platform by this name yet, create one
+        platform_sp = Platform::Create(platform_name, sb_error.ref());
+        if (platform_sp) {
+          // We created the platform, now append and select it
+          bool make_selected = true;
+          m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected);
         }
+      }
+    } else {
+      sb_error.ref().SetErrorString("invalid platform name");
     }
-    else
-    {
-        sb_error.ref().SetErrorString("invalid debugger");
+  } else {
+    sb_error.ref().SetErrorString("invalid debugger");
+  }
+  return sb_error;
+}
+
+bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (m_opaque_sp) {
+    PlatformSP platform_sp(
+        m_opaque_sp->GetPlatformList().GetSelectedPlatform());
+
+    if (platform_sp) {
+      if (log && sysroot)
+        log->Printf("SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", sysroot);
+      platform_sp->SetSDKRootDirectory(ConstString(sysroot));
+      return true;
     }
-    return sb_error;
+  }
+  return false;
 }
 
-bool
-SBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot)
-{
-    if (m_opaque_sp)
-    {
-        PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform());
-        
-        if (platform_sp)
-        {
-            platform_sp->SetSDKRootDirectory (ConstString (sysroot));
-            return true;
-        }
-    }
-    return false;
+bool SBDebugger::GetCloseInputOnEOF() const {
+  return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
 }
 
-bool
-SBDebugger::GetCloseInputOnEOF() const
-{
-    return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
+void SBDebugger::SetCloseInputOnEOF(bool b) {
+  if (m_opaque_sp)
+    m_opaque_sp->SetCloseInputOnEOF(b);
 }
 
-void
-SBDebugger::SetCloseInputOnEOF (bool b)
-{
-    if (m_opaque_sp)
-        m_opaque_sp->SetCloseInputOnEOF (b);
-}
+SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
+  if (!category_name || *category_name == 0)
+    return SBTypeCategory();
 
-SBTypeCategory
-SBDebugger::GetCategory (const char* category_name)
-{
-    if (!category_name || *category_name == 0)
-        return SBTypeCategory();
-    
-    TypeCategoryImplSP category_sp;
-    
-    if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false))
-        return SBTypeCategory(category_sp);
-    else
-        return SBTypeCategory();
+  TypeCategoryImplSP category_sp;
+
+  if (DataVisualization::Categories::GetCategory(ConstString(category_name),
+                                                 category_sp, false))
+    return SBTypeCategory(category_sp);
+  else
+    return SBTypeCategory();
 }
 
-SBTypeCategory
-SBDebugger::GetCategory (lldb::LanguageType lang_type)
-{
-    TypeCategoryImplSP category_sp;
-    if (DataVisualization::Categories::GetCategory(lang_type, category_sp))
-        return SBTypeCategory(category_sp);
-    else
-        return SBTypeCategory();
+SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
+  TypeCategoryImplSP category_sp;
+  if (DataVisualization::Categories::GetCategory(lang_type, category_sp))
+    return SBTypeCategory(category_sp);
+  else
+    return SBTypeCategory();
 }
 
-SBTypeCategory
-SBDebugger::CreateCategory (const char* category_name)
-{
-    if (!category_name || *category_name == 0)
-        return SBTypeCategory();
-    
-    TypeCategoryImplSP category_sp;
-    
-    if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true))
-        return SBTypeCategory(category_sp);
-    else
-        return SBTypeCategory();
+SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
+  if (!category_name || *category_name == 0)
+    return SBTypeCategory();
+
+  TypeCategoryImplSP category_sp;
+
+  if (DataVisualization::Categories::GetCategory(ConstString(category_name),
+                                                 category_sp, true))
+    return SBTypeCategory(category_sp);
+  else
+    return SBTypeCategory();
 }
 
-bool
-SBDebugger::DeleteCategory (const char* category_name)
-{
-    if (!category_name || *category_name == 0)
-        return false;
-    
-    return DataVisualization::Categories::Delete(ConstString(category_name));
+bool SBDebugger::DeleteCategory(const char *category_name) {
+  if (!category_name || *category_name == 0)
+    return false;
+
+  return DataVisualization::Categories::Delete(ConstString(category_name));
 }
 
-uint32_t
-SBDebugger::GetNumCategories()
-{
-    return DataVisualization::Categories::GetCount();
+uint32_t SBDebugger::GetNumCategories() {
+  return DataVisualization::Categories::GetCount();
 }
 
-SBTypeCategory
-SBDebugger::GetCategoryAtIndex (uint32_t index)
-{
-    return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index));
+SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
+  return SBTypeCategory(
+      DataVisualization::Categories::GetCategoryAtIndex(index));
 }
 
-SBTypeCategory
-SBDebugger::GetDefaultCategory()
-{
-    return GetCategory("default");
+SBTypeCategory SBDebugger::GetDefaultCategory() {
+  return GetCategory("default");
 }
 
-SBTypeFormat
-SBDebugger::GetFormatForType (SBTypeNameSpecifier type_name)
-{
-    SBTypeCategory default_category_sb = GetDefaultCategory();
-    if (default_category_sb.GetEnabled())
-        return default_category_sb.GetFormatForType(type_name);
-    return SBTypeFormat();
+SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
+  SBTypeCategory default_category_sb = GetDefaultCategory();
+  if (default_category_sb.GetEnabled())
+    return default_category_sb.GetFormatForType(type_name);
+  return SBTypeFormat();
 }
 
 #ifndef LLDB_DISABLE_PYTHON
-SBTypeSummary
-SBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name)
-{
-    if (!type_name.IsValid())
-        return SBTypeSummary();
-    return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
+SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
+  if (!type_name.IsValid())
+    return SBTypeSummary();
+  return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
 }
 #endif // LLDB_DISABLE_PYTHON
 
-SBTypeFilter
-SBDebugger::GetFilterForType (SBTypeNameSpecifier type_name)
-{
-    if (!type_name.IsValid())
-        return SBTypeFilter();
-    return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
+SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
+  if (!type_name.IsValid())
+    return SBTypeFilter();
+  return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
 }
 
 #ifndef LLDB_DISABLE_PYTHON
-SBTypeSynthetic
-SBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name)
-{
-    if (!type_name.IsValid())
-        return SBTypeSynthetic();
-    return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP()));
+SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
+  if (!type_name.IsValid())
+    return SBTypeSynthetic();
+  return SBTypeSynthetic(
+      DataVisualization::GetSyntheticForType(type_name.GetSP()));
 }
 #endif // LLDB_DISABLE_PYTHON
 
-bool
-SBDebugger::EnableLog (const char *channel, const char **categories)
-{
-    if (m_opaque_sp)
-    {
-        uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
-        StreamString errors;
-        return m_opaque_sp->EnableLog(channel, categories, nullptr, log_options, errors);
-    }
-    else
-        return false;
+bool SBDebugger::EnableLog(const char *channel, const char **categories) {
+  if (m_opaque_sp) {
+    uint32_t log_options =
+        LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
+    StreamString errors;
+    return m_opaque_sp->EnableLog(channel, categories, nullptr, log_options,
+                                  errors);
+  } else
+    return false;
 }
 
-void
-SBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
-{
-    if (m_opaque_sp)
-    {
-        return m_opaque_sp->SetLoggingCallback (log_callback, baton);
-    }
+void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
+                                    void *baton) {
+  if (m_opaque_sp) {
+    return m_opaque_sp->SetLoggingCallback(log_callback, baton);
+  }
 }