vendor/lldb/lldb-release_39-r276489

1 files changed, 223 insertions, 236 deletions

diff --git a/source/Core/Debugger.cpp b/source/Core/Debugger.cpp
index d36800e20bc0..34608d0193fc 100644
--- a/source/Core/Debugger.cpp
+++ b/source/Core/Debugger.cpp
@@ -9,10 +9,16 @@
 
 #include "lldb/Core/Debugger.h"
 
+// C Includes
+// C++ Includes
 #include <map>
+#include <mutex>
 
+// Other libraries and framework includes
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/DynamicLibrary.h"
 
+// Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Module.h"
@@ -54,34 +60,17 @@
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/AnsiTerminal.h"
 
-#include "llvm/Support/DynamicLibrary.h"
-
 using namespace lldb;
 using namespace lldb_private;
 
-
 static lldb::user_id_t g_unique_id = 1;
 static size_t g_debugger_event_thread_stack_bytes = 8 * 1024 * 1024;
 
 #pragma mark Static Functions
 
-static Mutex &
-GetDebuggerListMutex ()
-{
-    static Mutex g_mutex(Mutex::eMutexTypeRecursive);
-    return g_mutex;
-}
-
 typedef std::vector<DebuggerSP> DebuggerList;
-
-static DebuggerList &
-GetDebuggerList()
-{
-    // hide the static debugger list inside a singleton accessor to avoid
-    // global init constructors
-    static DebuggerList g_list;
-    return g_list;
-}
+static std::recursive_mutex *g_debugger_list_mutex_ptr = nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
+static DebuggerList *g_debugger_list_ptr = nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
 
 OptionEnumValueElement
 g_show_disassembly_enum_values[] =
@@ -90,7 +79,7 @@ g_show_disassembly_enum_values[] =
     { Debugger::eStopDisassemblyTypeNoDebugInfo,    "no-debuginfo",     "Show disassembly when there is no debug information."},
     { Debugger::eStopDisassemblyTypeNoSource,       "no-source",        "Show disassembly when there is no source information, or the source file is missing when displaying a stop context."},
     { Debugger::eStopDisassemblyTypeAlways,         "always",           "Always show disassembly when displaying a stop context."},
-    { 0, NULL, NULL }
+    { 0, nullptr, nullptr }
 };
 
 OptionEnumValueElement
@@ -99,7 +88,7 @@ g_language_enumerators[] =
     { eScriptLanguageNone,      "none",     "Disable scripting languages."},
     { eScriptLanguagePython,    "python",   "Select python as the default scripting language."},
     { eScriptLanguageDefault,   "default",  "Select the lldb default as the default scripting language."},
-    { 0, NULL, NULL }
+    { 0, nullptr, nullptr }
 };
 
 #define MODULE_WITH_FUNC "{ ${module.file.basename}{`${function.name-with-args}${function.pc-offset}}}"
@@ -140,30 +129,29 @@ g_language_enumerators[] =
 // lldb's original format for disassembly would look like this format string -
 // {${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}: 
 
-
 static PropertyDefinition
 g_properties[] =
 {
-{   "auto-confirm",             OptionValue::eTypeBoolean     , true, false, NULL, NULL, "If true all confirmation prompts will receive their default reply." },
-{   "disassembly-format",       OptionValue::eTypeFormatEntity, true, 0    , DEFAULT_DISASSEMBLY_FORMAT, NULL, "The default disassembly format string to use when disassembling instruction sequences." },
-{   "frame-format",             OptionValue::eTypeFormatEntity, true, 0    , DEFAULT_FRAME_FORMAT, NULL, "The default frame format string to use when displaying stack frame information for threads." },
-{   "notify-void",              OptionValue::eTypeBoolean     , true, false, NULL, NULL, "Notify the user explicitly if an expression returns void (default: false)." },
-{   "prompt",                   OptionValue::eTypeString      , true, OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", NULL, "The debugger command line prompt displayed for the user." },
-{   "script-lang",              OptionValue::eTypeEnum        , true, eScriptLanguagePython, NULL, g_language_enumerators, "The script language to be used for evaluating user-written scripts." },
-{   "stop-disassembly-count",   OptionValue::eTypeSInt64      , true, 4    , NULL, NULL, "The number of disassembly lines to show when displaying a stopped context." },
-{   "stop-disassembly-display", OptionValue::eTypeEnum        , true, Debugger::eStopDisassemblyTypeNoDebugInfo, NULL, g_show_disassembly_enum_values, "Control when to display disassembly when displaying a stopped context." },
-{   "stop-line-count-after",    OptionValue::eTypeSInt64      , true, 3    , NULL, NULL, "The number of sources lines to display that come after the current source line when displaying a stopped context." },
-{   "stop-line-count-before",   OptionValue::eTypeSInt64      , true, 3    , NULL, NULL, "The number of sources lines to display that come before the current source line when displaying a stopped context." },
-{   "term-width",               OptionValue::eTypeSInt64      , true, 80   , NULL, NULL, "The maximum number of columns to use for displaying text." },
-{   "thread-format",            OptionValue::eTypeFormatEntity, true, 0    , DEFAULT_THREAD_FORMAT, NULL, "The default thread format string to use when displaying thread information." },
-{   "use-external-editor",      OptionValue::eTypeBoolean     , true, false, NULL, NULL, "Whether to use an external editor or not." },
-{   "use-color",                OptionValue::eTypeBoolean     , true, true , NULL, NULL, "Whether to use Ansi color codes or not." },
-{   "auto-one-line-summaries",  OptionValue::eTypeBoolean     , true, true, NULL, NULL, "If true, LLDB will automatically display small structs in one-liner format (default: true)." },
-{   "auto-indent",              OptionValue::eTypeBoolean     , true, true , NULL, NULL, "If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true)." },
-{   "print-decls",              OptionValue::eTypeBoolean     , true, true , NULL, NULL, "If true, LLDB will print the values of variables declared in an expression. Currently only supported in the REPL (default: true)." },
-{   "tab-size",                 OptionValue::eTypeUInt64      , true, 4    , NULL, NULL, "The tab size to use when indenting code in multi-line input mode (default: 4)." },
-{   "escape-non-printables",    OptionValue::eTypeBoolean     , true, true, NULL, NULL, "If true, LLDB will automatically escape non-printable and escape characters when formatting strings." },
-{   NULL,                       OptionValue::eTypeInvalid     , true, 0    , NULL, NULL, NULL }
+{   "auto-confirm",             OptionValue::eTypeBoolean     , true, false, nullptr, nullptr, "If true all confirmation prompts will receive their default reply." },
+{   "disassembly-format",       OptionValue::eTypeFormatEntity, true, 0    , DEFAULT_DISASSEMBLY_FORMAT, nullptr, "The default disassembly format string to use when disassembling instruction sequences." },
+{   "frame-format",             OptionValue::eTypeFormatEntity, true, 0    , DEFAULT_FRAME_FORMAT, nullptr, "The default frame format string to use when displaying stack frame information for threads." },
+{   "notify-void",              OptionValue::eTypeBoolean     , true, false, nullptr, nullptr, "Notify the user explicitly if an expression returns void (default: false)." },
+{   "prompt",                   OptionValue::eTypeString      , true, OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", nullptr, "The debugger command line prompt displayed for the user." },
+{   "script-lang",              OptionValue::eTypeEnum        , true, eScriptLanguagePython, nullptr, g_language_enumerators, "The script language to be used for evaluating user-written scripts." },
+{   "stop-disassembly-count",   OptionValue::eTypeSInt64      , true, 4    , nullptr, nullptr, "The number of disassembly lines to show when displaying a stopped context." },
+{   "stop-disassembly-display", OptionValue::eTypeEnum        , true, Debugger::eStopDisassemblyTypeNoDebugInfo, nullptr, g_show_disassembly_enum_values, "Control when to display disassembly when displaying a stopped context." },
+{   "stop-line-count-after",    OptionValue::eTypeSInt64      , true, 3    , nullptr, nullptr, "The number of sources lines to display that come after the current source line when displaying a stopped context." },
+{   "stop-line-count-before",   OptionValue::eTypeSInt64      , true, 3    , nullptr, nullptr, "The number of sources lines to display that come before the current source line when displaying a stopped context." },
+{   "term-width",               OptionValue::eTypeSInt64      , true, 80   , nullptr, nullptr, "The maximum number of columns to use for displaying text." },
+{   "thread-format",            OptionValue::eTypeFormatEntity, true, 0    , DEFAULT_THREAD_FORMAT, nullptr, "The default thread format string to use when displaying thread information." },
+{   "use-external-editor",      OptionValue::eTypeBoolean     , true, false, nullptr, nullptr, "Whether to use an external editor or not." },
+{   "use-color",                OptionValue::eTypeBoolean     , true, true , nullptr, nullptr, "Whether to use Ansi color codes or not." },
+{   "auto-one-line-summaries",  OptionValue::eTypeBoolean     , true, true, nullptr, nullptr, "If true, LLDB will automatically display small structs in one-liner format (default: true)." },
+{   "auto-indent",              OptionValue::eTypeBoolean     , true, true , nullptr, nullptr, "If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true)." },
+{   "print-decls",              OptionValue::eTypeBoolean     , true, true , nullptr, nullptr, "If true, LLDB will print the values of variables declared in an expression. Currently only supported in the REPL (default: true)." },
+{   "tab-size",                 OptionValue::eTypeUInt64      , true, 4    , nullptr, nullptr, "The tab size to use when indenting code in multi-line input mode (default: 4)." },
+{   "escape-non-printables",    OptionValue::eTypeBoolean     , true, true, nullptr, nullptr, "If true, LLDB will automatically escape non-printable and escape characters when formatting strings." },
+{   nullptr,                       OptionValue::eTypeInvalid     , true, 0    , nullptr, nullptr, nullptr }
 };
 
 enum
@@ -189,7 +177,7 @@ enum
     ePropertyEscapeNonPrintables
 };
 
-LoadPluginCallbackType Debugger::g_load_plugin_callback = NULL;
+LoadPluginCallbackType Debugger::g_load_plugin_callback = nullptr;
 
 Error
 Debugger::SetPropertyValue (const ExecutionContext *exe_ctx,
@@ -258,42 +246,42 @@ bool
 Debugger::GetAutoConfirm () const
 {
     const uint32_t idx = ePropertyAutoConfirm;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
 const FormatEntity::Entry *
 Debugger::GetDisassemblyFormat() const
 {
     const uint32_t idx = ePropertyDisassemblyFormat;
-    return m_collection_sp->GetPropertyAtIndexAsFormatEntity(NULL, idx);
+    return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 }
 
 const FormatEntity::Entry *
 Debugger::GetFrameFormat() const
 {
     const uint32_t idx = ePropertyFrameFormat;
-    return m_collection_sp->GetPropertyAtIndexAsFormatEntity(NULL, idx);
+    return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 }
 
 bool
 Debugger::GetNotifyVoid () const
 {
     const uint32_t idx = ePropertyNotiftVoid;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
 const char *
 Debugger::GetPrompt() const
 {
     const uint32_t idx = ePropertyPrompt;
-    return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, g_properties[idx].default_cstr_value);
+    return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, g_properties[idx].default_cstr_value);
 }
 
 void
 Debugger::SetPrompt(const char *p)
 {
     const uint32_t idx = ePropertyPrompt;
-    m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p);
+    m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
     const char *new_prompt = GetPrompt();
     std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes (new_prompt, GetUseColor());
     if (str.length())
@@ -305,63 +293,63 @@ const FormatEntity::Entry *
 Debugger::GetThreadFormat() const
 {
     const uint32_t idx = ePropertyThreadFormat;
-    return m_collection_sp->GetPropertyAtIndexAsFormatEntity(NULL, idx);
+    return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 }
 
 lldb::ScriptLanguage
 Debugger::GetScriptLanguage() const
 {
     const uint32_t idx = ePropertyScriptLanguage;
-    return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
+    return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
 }
 
 bool
 Debugger::SetScriptLanguage (lldb::ScriptLanguage script_lang)
 {
     const uint32_t idx = ePropertyScriptLanguage;
-    return m_collection_sp->SetPropertyAtIndexAsEnumeration (NULL, idx, script_lang);
+    return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx, script_lang);
 }
 
 uint32_t
 Debugger::GetTerminalWidth () const
 {
     const uint32_t idx = ePropertyTerminalWidth;
-    return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
+    return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value);
 }
 
 bool
 Debugger::SetTerminalWidth (uint32_t term_width)
 {
     const uint32_t idx = ePropertyTerminalWidth;
-    return m_collection_sp->SetPropertyAtIndexAsSInt64 (NULL, idx, term_width);
+    return m_collection_sp->SetPropertyAtIndexAsSInt64(nullptr, idx, term_width);
 }
 
 bool
 Debugger::GetUseExternalEditor () const
 {
     const uint32_t idx = ePropertyUseExternalEditor;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
 bool
 Debugger::SetUseExternalEditor (bool b)
 {
     const uint32_t idx = ePropertyUseExternalEditor;
-    return m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
+    return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 }
 
 bool
 Debugger::GetUseColor () const
 {
     const uint32_t idx = ePropertyUseColor;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
 bool
 Debugger::SetUseColor (bool b)
 {
     const uint32_t idx = ePropertyUseColor;
-    bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
+    bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
     SetPrompt (GetPrompt());
     return ret;
 }
@@ -370,80 +358,79 @@ uint32_t
 Debugger::GetStopSourceLineCount (bool before) const
 {
     const uint32_t idx = before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter;
-    return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
+    return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value);
 }
 
 Debugger::StopDisassemblyType
 Debugger::GetStopDisassemblyDisplay () const
 {
     const uint32_t idx = ePropertyStopDisassemblyDisplay;
-    return (Debugger::StopDisassemblyType)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
+    return (Debugger::StopDisassemblyType)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
 }
 
 uint32_t
 Debugger::GetDisassemblyLineCount () const
 {
     const uint32_t idx = ePropertyStopDisassemblyCount;
-    return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
+    return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value);
 }
 
 bool
 Debugger::GetAutoOneLineSummaries () const
 {
     const uint32_t idx = ePropertyAutoOneLineSummaries;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, true);
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
 }
 
 bool
 Debugger::GetEscapeNonPrintables () const
 {
     const uint32_t idx = ePropertyEscapeNonPrintables;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, true);
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
 }
 
 bool
 Debugger::GetAutoIndent () const
 {
     const uint32_t idx = ePropertyAutoIndent;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, true);
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
 }
 
 bool
 Debugger::SetAutoIndent (bool b)
 {
     const uint32_t idx = ePropertyAutoIndent;
-    return m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
+    return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 }
 
 bool
 Debugger::GetPrintDecls () const
 {
     const uint32_t idx = ePropertyPrintDecls;
-    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, true);
+    return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
 }
 
 bool
 Debugger::SetPrintDecls (bool b)
 {
     const uint32_t idx = ePropertyPrintDecls;
-    return m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
+    return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 }
 
 uint32_t
 Debugger::GetTabSize () const
 {
     const uint32_t idx = ePropertyTabSize;
-    return m_collection_sp->GetPropertyAtIndexAsUInt64 (NULL, idx, g_properties[idx].default_uint_value);
+    return m_collection_sp->GetPropertyAtIndexAsUInt64(nullptr, idx, g_properties[idx].default_uint_value);
 }
 
 bool
 Debugger::SetTabSize (uint32_t tab_size)
 {
     const uint32_t idx = ePropertyTabSize;
-    return m_collection_sp->SetPropertyAtIndexAsUInt64 (NULL, idx, tab_size);
+    return m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, tab_size);
 }
 
-
 #pragma mark Debugger
 
 //const DebuggerPropertiesSP &
@@ -453,28 +440,30 @@ Debugger::SetTabSize (uint32_t tab_size)
 //}
 //
 
-static bool lldb_initialized = false;
 void
 Debugger::Initialize(LoadPluginCallbackType load_plugin_callback)
 {
-    assert(!lldb_initialized && "Debugger::Initialize called more than once!");
-
-    lldb_initialized = true;
+    assert(g_debugger_list_ptr == nullptr && "Debugger::Initialize called more than once!");
+    g_debugger_list_mutex_ptr = new std::recursive_mutex();
+    g_debugger_list_ptr = new DebuggerList();
     g_load_plugin_callback = load_plugin_callback;
 }
 
 void
 Debugger::Terminate ()
 {
-    assert(lldb_initialized && "Debugger::Terminate called without a matching Debugger::Initialize!");
-
-    // Clear our master list of debugger objects
-    Mutex::Locker locker (GetDebuggerListMutex ());
-    auto& debuggers = GetDebuggerList();
-    for (const auto& debugger: debuggers)
-        debugger->Clear();
+    assert(g_debugger_list_ptr && "Debugger::Terminate called without a matching Debugger::Initialize!");
 
-    debuggers.clear();
+    if (g_debugger_list_ptr && g_debugger_list_mutex_ptr)
+    {
+        // Clear our master list of debugger objects
+        {
+            std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
+            for (const auto& debugger: *g_debugger_list_ptr)
+                debugger->Clear();
+            g_debugger_list_ptr->clear();
+        }
+    }
 }
 
 void
@@ -512,12 +501,9 @@ Debugger::LoadPlugin (const FileSpec& spec, Error& error)
 }
 
 static FileSpec::EnumerateDirectoryResult
-LoadPluginCallback
-(
- void *baton,
- FileSpec::FileType file_type,
- const FileSpec &file_spec
- )
+LoadPluginCallback(void *baton,
+                   FileSpec::FileType file_type,
+                   const FileSpec &file_spec)
 {
     Error error;
     
@@ -551,7 +537,6 @@ LoadPluginCallback
         
         return FileSpec::eEnumerateDirectoryResultNext;
     }
-    
     else if (file_type == FileSpec::eFileTypeUnknown     ||
         file_type == FileSpec::eFileTypeDirectory   ||
         file_type == FileSpec::eFileTypeSymbolicLink )
@@ -607,10 +592,10 @@ DebuggerSP
 Debugger::CreateInstance (lldb::LogOutputCallback log_callback, void *baton)
 {
     DebuggerSP debugger_sp (new Debugger(log_callback, baton));
-    if (lldb_initialized)
+    if (g_debugger_list_ptr && g_debugger_list_mutex_ptr)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
-        GetDebuggerList().push_back(debugger_sp);
+        std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
+        g_debugger_list_ptr->push_back(debugger_sp);
     }
     debugger_sp->InstanceInitialize ();
     return debugger_sp;
@@ -619,21 +604,20 @@ Debugger::CreateInstance (lldb::LogOutputCallback log_callback, void *baton)
 void
 Debugger::Destroy (DebuggerSP &debugger_sp)
 {
-    if (debugger_sp.get() == NULL)
+    if (!debugger_sp)
         return;
         
     debugger_sp->Clear();
 
-    if (lldb_initialized)
+    if (g_debugger_list_ptr && g_debugger_list_mutex_ptr)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
-        DebuggerList &debugger_list = GetDebuggerList ();
-        DebuggerList::iterator pos, end = debugger_list.end();
-        for (pos = debugger_list.begin (); pos != end; ++pos)
+        std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
+        DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
+        for (pos = g_debugger_list_ptr->begin (); pos != end; ++pos)
         {
             if ((*pos).get() == debugger_sp.get())
             {
-                debugger_list.erase (pos);
+                g_debugger_list_ptr->erase (pos);
                 return;
             }
         }
@@ -644,15 +628,13 @@ DebuggerSP
 Debugger::FindDebuggerWithInstanceName (const ConstString &instance_name)
 {
     DebuggerSP debugger_sp;
-    if (lldb_initialized)
+    if (g_debugger_list_ptr && g_debugger_list_mutex_ptr)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
-        DebuggerList &debugger_list = GetDebuggerList();
-        DebuggerList::iterator pos, end = debugger_list.end();
-
-        for (pos = debugger_list.begin(); pos != end; ++pos)
+        std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
+        DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
+        for (pos = g_debugger_list_ptr->begin (); pos != end; ++pos)
         {
-            if ((*pos).get()->m_instance_name == instance_name)
+            if ((*pos)->m_instance_name == instance_name)
             {
                 debugger_sp = *pos;
                 break;
@@ -666,12 +648,11 @@ TargetSP
 Debugger::FindTargetWithProcessID (lldb::pid_t pid)
 {
     TargetSP target_sp;
-    if (lldb_initialized)
+    if (g_debugger_list_ptr && g_debugger_list_mutex_ptr)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
-        DebuggerList &debugger_list = GetDebuggerList();
-        DebuggerList::iterator pos, end = debugger_list.end();
-        for (pos = debugger_list.begin(); pos != end; ++pos)
+        std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
+        DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
+        for (pos = g_debugger_list_ptr->begin (); pos != end; ++pos)
         {
             target_sp = (*pos)->GetTargetList().FindTargetWithProcessID (pid);
             if (target_sp)
@@ -685,12 +666,11 @@ TargetSP
 Debugger::FindTargetWithProcess (Process *process)
 {
     TargetSP target_sp;
-    if (lldb_initialized)
+    if (g_debugger_list_ptr && g_debugger_list_mutex_ptr)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
-        DebuggerList &debugger_list = GetDebuggerList();
-        DebuggerList::iterator pos, end = debugger_list.end();
-        for (pos = debugger_list.begin(); pos != end; ++pos)
+        std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
+        DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
+        for (pos = g_debugger_list_ptr->begin (); pos != end; ++pos)
         {
             target_sp = (*pos)->GetTargetList().FindTargetWithProcess (process);
             if (target_sp)
@@ -706,19 +686,22 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) :
     m_input_file_sp(new StreamFile(stdin, false)),
     m_output_file_sp(new StreamFile(stdout, false)),
     m_error_file_sp(new StreamFile(stderr, false)),
+    m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()),
     m_terminal_state(),
     m_target_list(*this),
     m_platform_list(),
-    m_listener("lldb.Debugger"),
+    m_listener_sp(Listener::MakeListener("lldb.Debugger")),
     m_source_manager_ap(),
     m_source_file_cache(),
     m_command_interpreter_ap(new CommandInterpreter(*this, eScriptLanguageDefault, false)),
     m_input_reader_stack(),
     m_instance_name(),
     m_loaded_plugins(),
-    m_event_handler_thread (),
-    m_io_handler_thread (),
-    m_sync_broadcaster (NULL, "lldb.debugger.sync")
+    m_event_handler_thread(),
+    m_io_handler_thread(),
+    m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
+    m_forward_listener_sp(),
+    m_clear_once()
 {
     char instance_cstr[256];
     snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID());
@@ -728,7 +711,7 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) :
     m_command_interpreter_ap->Initialize ();
     // Always add our default platform to the platform list
     PlatformSP default_platform_sp (Platform::GetHostPlatform());
-    assert (default_platform_sp.get());
+    assert(default_platform_sp);
     m_platform_list.Append (default_platform_sp, true);
     
     m_collection_sp->Initialize (g_properties);
@@ -740,14 +723,14 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) :
                                      ConstString("Platform settings."),
                                      true,
                                      Platform::GetGlobalPlatformProperties()->GetValueProperties());
-    if (m_command_interpreter_ap.get())
+    if (m_command_interpreter_ap)
     {
         m_collection_sp->AppendProperty (ConstString("interpreter"),
                                          ConstString("Settings specify to the debugger's command interpreter."),
                                          true,
                                          m_command_interpreter_ap->GetValueProperties());
     }
-    OptionValueSInt64 *term_width = m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64 (NULL, ePropertyTerminalWidth);
+    OptionValueSInt64 *term_width = m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64(nullptr, ePropertyTerminalWidth);
     term_width->SetMinimumValue(10);
     term_width->SetMaximumValue(1024);
 
@@ -765,31 +748,44 @@ Debugger::~Debugger ()
 void
 Debugger::Clear()
 {
-    ClearIOHandlers();
-    StopIOHandlerThread();
-    StopEventHandlerThread();
-    m_listener.Clear();
-    int num_targets = m_target_list.GetNumTargets();
-    for (int i = 0; i < num_targets; i++)
-    {
-        TargetSP target_sp (m_target_list.GetTargetAtIndex (i));
-        if (target_sp)
+    //----------------------------------------------------------------------
+    // Make sure we call this function only once. With the C++ global
+    // destructor chain having a list of debuggers and with code that can be
+    // running on other threads, we need to ensure this doesn't happen
+    // multiple times.
+    //
+    // The following functions call Debugger::Clear():
+    //     Debugger::~Debugger();
+    //     static void Debugger::Destroy(lldb::DebuggerSP &debugger_sp);
+    //     static void Debugger::Terminate();
+    //----------------------------------------------------------------------
+    std::call_once(m_clear_once, [this]() {
+        ClearIOHandlers();
+        StopIOHandlerThread();
+        StopEventHandlerThread();
+        m_listener_sp->Clear();
+        int num_targets = m_target_list.GetNumTargets();
+        for (int i = 0; i < num_targets; i++)
         {
-            ProcessSP process_sp (target_sp->GetProcessSP());
-            if (process_sp)
-                process_sp->Finalize();
-            target_sp->Destroy();
+            TargetSP target_sp (m_target_list.GetTargetAtIndex (i));
+            if (target_sp)
+            {
+                ProcessSP process_sp (target_sp->GetProcessSP());
+                if (process_sp)
+                    process_sp->Finalize();
+                target_sp->Destroy();
+            }
         }
-    }
-    BroadcasterManager::Clear ();
-    
-    // Close the input file _before_ we close the input read communications class
-    // as it does NOT own the input file, our m_input_file does.
-    m_terminal_state.Clear();
-    if (m_input_file_sp)
-        m_input_file_sp->GetFile().Close ();
-    
-    m_command_interpreter_ap->Clear();
+        m_broadcaster_manager_sp->Clear ();
+        
+        // Close the input file _before_ we close the input read communications class
+        // as it does NOT own the input file, our m_input_file does.
+        m_terminal_state.Clear();
+        if (m_input_file_sp)
+            m_input_file_sp->GetFile().Close ();
+        
+        m_command_interpreter_ap->Clear();
+    });
 }
 
 bool
@@ -817,7 +813,6 @@ Debugger::SetAsyncExecution (bool async_execution)
     m_command_interpreter_ap->SetSynchronous (!async_execution);
 }
 
-    
 void
 Debugger::SetInputFileHandle (FILE *fh, bool tranfer_ownership)
 {
@@ -827,7 +822,7 @@ Debugger::SetInputFileHandle (FILE *fh, bool tranfer_ownership)
         m_input_file_sp.reset (new StreamFile (fh, tranfer_ownership));
 
     File &in_file = m_input_file_sp->GetFile();
-    if (in_file.IsValid() == false)
+    if (!in_file.IsValid())
         in_file.SetStream (stdin, true);
 
     // Save away the terminal state if that is relevant, so that we can restore it in RestoreInputState.
@@ -843,7 +838,7 @@ Debugger::SetOutputFileHandle (FILE *fh, bool tranfer_ownership)
         m_output_file_sp.reset (new StreamFile (fh, tranfer_ownership));
     
     File &out_file = m_output_file_sp->GetFile();
-    if (out_file.IsValid() == false)
+    if (!out_file.IsValid())
         out_file.SetStream (stdout, false);
     
     // do not create the ScriptInterpreter just for setting the output file handle
@@ -863,7 +858,7 @@ Debugger::SetErrorFileHandle (FILE *fh, bool tranfer_ownership)
         m_error_file_sp.reset (new StreamFile (fh, tranfer_ownership));
     
     File &err_file = m_error_file_sp->GetFile();
-    if (err_file.IsValid() == false)
+    if (!err_file.IsValid())
         err_file.SetStream (stderr, false);
 }
 
@@ -895,14 +890,14 @@ Debugger::GetSelectedExecutionContext ()
     {
         ProcessSP process_sp (target_sp->GetProcessSP());
         exe_ctx.SetProcessSP (process_sp);
-        if (process_sp && process_sp->IsRunning() == false)
+        if (process_sp && !process_sp->IsRunning())
         {
             ThreadSP thread_sp (process_sp->GetThreadList().GetSelectedThread());
             if (thread_sp)
             {
                 exe_ctx.SetThreadSP (thread_sp);
                 exe_ctx.SetFrameSP (thread_sp->GetSelectedFrame());
-                if (exe_ctx.GetFramePtr() == NULL)
+                if (exe_ctx.GetFramePtr() == nullptr)
                     exe_ctx.SetFrameSP (thread_sp->GetStackFrameAtIndex (0));
             }
         }
@@ -911,40 +906,40 @@ Debugger::GetSelectedExecutionContext ()
 }
 
 void
-Debugger::DispatchInputInterrupt ()
+Debugger::DispatchInputInterrupt()
 {
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
-    IOHandlerSP reader_sp (m_input_reader_stack.Top());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
+    IOHandlerSP reader_sp(m_input_reader_stack.Top());
     if (reader_sp)
         reader_sp->Interrupt();
 }
 
 void
-Debugger::DispatchInputEndOfFile ()
+Debugger::DispatchInputEndOfFile()
 {
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
-    IOHandlerSP reader_sp (m_input_reader_stack.Top());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
+    IOHandlerSP reader_sp(m_input_reader_stack.Top());
     if (reader_sp)
         reader_sp->GotEOF();
 }
 
 void
-Debugger::ClearIOHandlers ()
+Debugger::ClearIOHandlers()
 {
     // The bottom input reader should be the main debugger input reader.  We do not want to close that one here.
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
     while (m_input_reader_stack.GetSize() > 1)
     {
-        IOHandlerSP reader_sp (m_input_reader_stack.Top());
+        IOHandlerSP reader_sp(m_input_reader_stack.Top());
         if (reader_sp)
-            PopIOHandler (reader_sp);
+            PopIOHandler(reader_sp);
     }
 }
 
 void
 Debugger::ExecuteIOHandlers()
 {
-    while (1)
+    while (true)
     {
         IOHandlerSP reader_sp(m_input_reader_stack.Top());
         if (!reader_sp)
@@ -953,7 +948,7 @@ Debugger::ExecuteIOHandlers()
         reader_sp->Run();
 
         // Remove all input readers that are done from the top of the stack
-        while (1)
+        while (true)
         {
             IOHandlerSP top_reader_sp = m_input_reader_stack.Top();
             if (top_reader_sp && top_reader_sp->GetIsDone())
@@ -1018,7 +1013,7 @@ Debugger::RunIOHandler (const IOHandlerSP& reader_sp)
                 break;
         }
 
-        while (1)
+        while (true)
         {
             top_reader_sp = m_input_reader_stack.Top();
             if (top_reader_sp && top_reader_sp->GetIsDone())
@@ -1030,16 +1025,16 @@ Debugger::RunIOHandler (const IOHandlerSP& reader_sp)
 }
 
 void
-Debugger::AdoptTopIOHandlerFilesIfInvalid (StreamFileSP &in, StreamFileSP &out, StreamFileSP &err)
+Debugger::AdoptTopIOHandlerFilesIfInvalid(StreamFileSP &in, StreamFileSP &out, StreamFileSP &err)
 {
     // Before an IOHandler runs, it must have in/out/err streams.
     // This function is called when one ore more of the streams
-    // are NULL. We use the top input reader's in/out/err streams,
+    // are nullptr. We use the top input reader's in/out/err streams,
     // or fall back to the debugger file handles, or we fall back
     // onto stdin/stdout/stderr as a last resort.
-    
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
-    IOHandlerSP top_reader_sp (m_input_reader_stack.Top());
+
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
+    IOHandlerSP top_reader_sp(m_input_reader_stack.Top());
     // If no STDIN has been set, then set it appropriately
     if (!in)
     {
@@ -1047,7 +1042,7 @@ Debugger::AdoptTopIOHandlerFilesIfInvalid (StreamFileSP &in, StreamFileSP &out,
             in = top_reader_sp->GetInputStreamFile();
         else
             in = GetInputFile();
-        
+
         // If there is nothing, use stdin
         if (!in)
             in = StreamFileSP(new StreamFile(stdin, false));
@@ -1059,7 +1054,7 @@ Debugger::AdoptTopIOHandlerFilesIfInvalid (StreamFileSP &in, StreamFileSP &out,
             out = top_reader_sp->GetOutputStreamFile();
         else
             out = GetOutputFile();
-        
+
         // If there is nothing, use stdout
         if (!out)
             out = StreamFileSP(new StreamFile(stdout, false));
@@ -1071,31 +1066,30 @@ Debugger::AdoptTopIOHandlerFilesIfInvalid (StreamFileSP &in, StreamFileSP &out,
             err = top_reader_sp->GetErrorStreamFile();
         else
             err = GetErrorFile();
-        
+
         // If there is nothing, use stderr
         if (!err)
             err = StreamFileSP(new StreamFile(stdout, false));
-        
     }
 }
 
 void
-Debugger::PushIOHandler (const IOHandlerSP& reader_sp)
+Debugger::PushIOHandler(const IOHandlerSP &reader_sp)
 {
     if (!reader_sp)
         return;
- 
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
+
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
 
     // Get the current top input reader...
-    IOHandlerSP top_reader_sp (m_input_reader_stack.Top());
-    
+    IOHandlerSP top_reader_sp(m_input_reader_stack.Top());
+
     // Don't push the same IO handler twice...
     if (reader_sp == top_reader_sp)
         return;
 
     // Push our new input reader
-    m_input_reader_stack.Push (reader_sp);
+    m_input_reader_stack.Push(reader_sp);
     reader_sp->Activate();
 
     // Interrupt the top input reader to it will exit its Run() function
@@ -1108,12 +1102,12 @@ Debugger::PushIOHandler (const IOHandlerSP& reader_sp)
 }
 
 bool
-Debugger::PopIOHandler (const IOHandlerSP& pop_reader_sp)
+Debugger::PopIOHandler(const IOHandlerSP &pop_reader_sp)
 {
-    if (! pop_reader_sp)
+    if (!pop_reader_sp)
         return false;
 
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
 
     // The reader on the stop of the stack is done, so let the next
     // read on the stack refresh its prompt and if there is one...
@@ -1127,7 +1121,7 @@ Debugger::PopIOHandler (const IOHandlerSP& pop_reader_sp)
 
     reader_sp->Deactivate();
     reader_sp->Cancel();
-    m_input_reader_stack.Pop ();
+    m_input_reader_stack.Pop();
 
     reader_sp = m_input_reader_stack.Top();
     if (reader_sp)
@@ -1151,10 +1145,10 @@ Debugger::GetAsyncErrorStream ()
 size_t
 Debugger::GetNumDebuggers()
 {
-    if (lldb_initialized)
+    if (g_debugger_list_ptr && g_debugger_list_mutex_ptr)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
-        return GetDebuggerList().size();
+        std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
+        return g_debugger_list_ptr->size();
     }
     return 0;
 }
@@ -1164,13 +1158,11 @@ Debugger::GetDebuggerAtIndex (size_t index)
 {
     DebuggerSP debugger_sp;
     
-    if (lldb_initialized)
+    if (g_debugger_list_ptr && g_debugger_list_mutex_ptr)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
-        DebuggerList &debugger_list = GetDebuggerList();
-        
-        if (index < debugger_list.size())
-            debugger_sp = debugger_list[index];
+        std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
+        if (index < g_debugger_list_ptr->size())
+            debugger_sp = g_debugger_list_ptr->at(index);
     }
 
     return debugger_sp;
@@ -1181,14 +1173,13 @@ Debugger::FindDebuggerWithID (lldb::user_id_t id)
 {
     DebuggerSP debugger_sp;
 
-    if (lldb_initialized)
+    if (g_debugger_list_ptr && g_debugger_list_mutex_ptr)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
-        DebuggerList &debugger_list = GetDebuggerList();
-        DebuggerList::iterator pos, end = debugger_list.end();
-        for (pos = debugger_list.begin(); pos != end; ++pos)
+        std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
+        DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
+        for (pos = g_debugger_list_ptr->begin (); pos != end; ++pos)
         {
-            if ((*pos).get()->GetID() == id)
+            if ((*pos)->GetID() == id)
             {
                 debugger_sp = *pos;
                 break;
@@ -1202,7 +1193,7 @@ Debugger::FindDebuggerWithID (lldb::user_id_t id)
 static void
 TestPromptFormats (StackFrame *frame)
 {
-    if (frame == NULL)
+    if (frame == nullptr)
         return;
 
     StreamString s;
@@ -1277,11 +1268,11 @@ Debugger::FormatDisassemblerAddress (const FormatEntity::Entry *format,
 {
     FormatEntity::Entry format_entry;
 
-    if (format == NULL)
+    if (format == nullptr)
     {
-        if (exe_ctx != NULL && exe_ctx->HasTargetScope())
+        if (exe_ctx != nullptr && exe_ctx->HasTargetScope())
             format = exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat();
-        if (format == NULL)
+        if (format == nullptr)
         {
             FormatEntity::Parse("${addr}: ", format_entry);
             format = &format_entry;
@@ -1313,14 +1304,13 @@ Debugger::FormatDisassemblerAddress (const FormatEntity::Entry *format,
     // has no Function or Symbol -- if SymbolContext had an IsValid() method, it
     // would return false.  But we do get a prev_sc pointer.
     if ((sc && (sc->function || sc->symbol))
-        && prev_sc && (prev_sc->function == NULL && prev_sc->symbol == NULL))
+        && prev_sc && (prev_sc->function == nullptr && prev_sc->symbol == nullptr))
     {
         initial_function = true;
     }
-    return FormatEntity::Format(*format, s, sc, exe_ctx, addr, NULL, function_changed, initial_function);
+    return FormatEntity::Format(*format, s, sc, exe_ctx, addr, nullptr, function_changed, initial_function);
 }
 
-
 void
 Debugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
 {
@@ -1340,7 +1330,7 @@ Debugger::EnableLog (const char *channel, const char **categories, const char *l
         // For now when using the callback mode you always get thread & timestamp.
         log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
     }
-    else if (log_file == NULL || *log_file == '\0')
+    else if (log_file == nullptr || *log_file == '\0')
     {
         log_stream_sp = GetOutputFile();
     }
@@ -1360,7 +1350,7 @@ Debugger::EnableLog (const char *channel, const char **categories, const char *l
             m_log_streams[log_file] = log_stream_sp;
         }
     }
-    assert (log_stream_sp.get());
+    assert(log_stream_sp);
     
     if (log_options == 0)
         log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE;
@@ -1371,13 +1361,11 @@ Debugger::EnableLog (const char *channel, const char **categories, const char *l
 SourceManager &
 Debugger::GetSourceManager ()
 {
-    if (m_source_manager_ap.get() == NULL)
+    if (!m_source_manager_ap)
         m_source_manager_ap.reset (new SourceManager (shared_from_this()));
     return *m_source_manager_ap;
 }
 
-
-
 // This function handles events that were broadcast by the process.
 void
 Debugger::HandleBreakpointEvent (const EventSP &event_sp)
@@ -1428,13 +1416,13 @@ size_t
 Debugger::GetProcessSTDOUT (Process *process, Stream *stream)
 {
     size_t total_bytes = 0;
-    if (stream == NULL)
+    if (stream == nullptr)
         stream = GetOutputFile().get();
 
     if (stream)
     {
         //  The process has stuff waiting for stdout; get it and write it out to the appropriate place.
-        if (process == NULL)
+        if (process == nullptr)
         {
             TargetSP target_sp = GetTargetList().GetSelectedTarget();
             if (target_sp)
@@ -1460,13 +1448,13 @@ size_t
 Debugger::GetProcessSTDERR (Process *process, Stream *stream)
 {
     size_t total_bytes = 0;
-    if (stream == NULL)
+    if (stream == nullptr)
         stream = GetOutputFile().get();
     
     if (stream)
     {
         //  The process has stuff waiting for stderr; get it and write it out to the appropriate place.
-        if (process == NULL)
+        if (process == nullptr)
         {
             TargetSP target_sp = GetTargetList().GetSelectedTarget();
             if (target_sp)
@@ -1588,7 +1576,7 @@ Debugger::CancelForwardEvents (const ListenerSP &listener_sp)
 void
 Debugger::DefaultEventHandler()
 {
-    Listener& listener(GetListener());
+    ListenerSP listener_sp(GetListener());
     ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass());
     ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass());
     ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass());
@@ -1604,10 +1592,10 @@ Debugger::DefaultEventHandler()
                                           Thread::eBroadcastBitStackChanged     |
                                           Thread::eBroadcastBitThreadSelected   );
     
-    listener.StartListeningForEventSpec (*this, target_event_spec);
-    listener.StartListeningForEventSpec (*this, process_event_spec);
-    listener.StartListeningForEventSpec (*this, thread_event_spec);
-    listener.StartListeningForEvents (m_command_interpreter_ap.get(),
+    listener_sp->StartListeningForEventSpec (m_broadcaster_manager_sp, target_event_spec);
+    listener_sp->StartListeningForEventSpec (m_broadcaster_manager_sp, process_event_spec);
+    listener_sp->StartListeningForEventSpec (m_broadcaster_manager_sp, thread_event_spec);
+    listener_sp->StartListeningForEvents (m_command_interpreter_ap.get(),
                                       CommandInterpreter::eBroadcastBitQuitCommandReceived      |
                                       CommandInterpreter::eBroadcastBitAsynchronousOutputData   |
                                       CommandInterpreter::eBroadcastBitAsynchronousErrorData    );
@@ -1620,7 +1608,7 @@ Debugger::DefaultEventHandler()
     while (!done)
     {
         EventSP event_sp;
-        if (listener.WaitForEvent(NULL, event_sp))
+        if (listener_sp->WaitForEvent(nullptr, event_sp))
         {
             if (event_sp)
             {
@@ -1702,21 +1690,22 @@ Debugger::StartEventHandlerThread()
         // it is up and running and listening to events before we return from
         // this function. We do this by listening to events for the
         // eBroadcastBitEventThreadIsListening from the m_sync_broadcaster
-        Listener listener("lldb.debugger.event-handler");
-        listener.StartListeningForEvents(&m_sync_broadcaster, eBroadcastBitEventThreadIsListening);
+        ListenerSP listener_sp(Listener::MakeListener("lldb.debugger.event-handler"));
+        listener_sp->StartListeningForEvents(&m_sync_broadcaster, eBroadcastBitEventThreadIsListening);
 
         // Use larger 8MB stack for this thread
-        m_event_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.event-handler", EventHandlerThread,
+        m_event_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.event-handler",
+                                                              EventHandlerThread,
                                                               this,
-                                                              NULL,
+                                                              nullptr,
                                                               g_debugger_event_thread_stack_bytes);
 
         // Make sure DefaultEventHandler() is running and listening to events before we return
         // from this function. We are only listening for events of type
         // eBroadcastBitEventThreadIsListening so we don't need to check the event, we just need
-        // to wait an infinite amount of time for it (NULL timeout as the first parameter)
+        // to wait an infinite amount of time for it (nullptr timeout as the first parameter)
         lldb::EventSP event_sp;
-        listener.WaitForEvent(NULL, event_sp);
+        listener_sp->WaitForEvent(nullptr, event_sp);
     }
     return m_event_handler_thread.IsJoinable();
 }
@@ -1731,7 +1720,6 @@ Debugger::StopEventHandlerThread()
     }
 }
 
-
 lldb::thread_result_t
 Debugger::IOHandlerThread (lldb::thread_arg_t arg)
 {
@@ -1751,11 +1739,11 @@ bool
 Debugger::StartIOHandlerThread()
 {
     if (!m_io_handler_thread.IsJoinable())
-        m_io_handler_thread = ThreadLauncher::LaunchThread ("lldb.debugger.io-handler",
-                                                            IOHandlerThread,
-                                                            this,
-                                                            NULL,
-                                                            8*1024*1024); // Use larger 8MB stack for this thread
+        m_io_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.io-handler",
+                                                           IOHandlerThread,
+                                                           this,
+                                                           nullptr,
+                                                           8*1024*1024); // Use larger 8MB stack for this thread
     return m_io_handler_thread.IsJoinable();
 }
 
@@ -1817,9 +1805,9 @@ Debugger::RunREPL (LanguageType language, const char *repl_options)
         {
             language = *repl_languages.begin();
         }
-        else if (repl_languages.size() == 0)
+        else if (repl_languages.empty())
         {
-            err.SetErrorStringWithFormat("LLDB isn't configured with support support for any REPLs.");
+            err.SetErrorStringWithFormat("LLDB isn't configured with REPL support for any languages.");
             return err;
         }
         else
@@ -1849,4 +1837,3 @@ Debugger::RunREPL (LanguageType language, const char *repl_options)
     
     return err;
 }
-