*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 795 insertions, 992 deletions

diff --git a/lldb/source/Core/ModuleList.cpp b/lldb/source/Core/ModuleList.cpp
index bfd53e7d1c2..a97be86fae1 100644
--- a/lldb/source/Core/ModuleList.cpp
+++ b/lldb/source/Core/ModuleList.cpp
@@ -28,1131 +28,934 @@
 using namespace lldb;
 using namespace lldb_private;
 
-ModuleList::ModuleList() : m_modules(), m_modules_mutex(), m_notifier(nullptr)
-{
+ModuleList::ModuleList()
+    : m_modules(), m_modules_mutex(), m_notifier(nullptr) {}
+
+ModuleList::ModuleList(const ModuleList &rhs)
+    : m_modules(), m_modules_mutex(), m_notifier(nullptr) {
+  std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
+  std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
+  m_modules = rhs.m_modules;
+}
+
+ModuleList::ModuleList(ModuleList::Notifier *notifier)
+    : m_modules(), m_modules_mutex(), m_notifier(notifier) {}
+
+const ModuleList &ModuleList::operator=(const ModuleList &rhs) {
+  if (this != &rhs) {
+    // That's probably me nit-picking, but in theoretical situation:
+    //
+    // * that two threads A B and
+    // * two ModuleList's x y do opposite assignments ie.:
+    //
+    //  in thread A: | in thread B:
+    //    x = y;     |   y = x;
+    //
+    // This establishes correct(same) lock taking order and thus
+    // avoids priority inversion.
+    if (uintptr_t(this) > uintptr_t(&rhs)) {
+      std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
+      std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
+      m_modules = rhs.m_modules;
+    } else {
+      std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
+      std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
+      m_modules = rhs.m_modules;
+    }
+  }
+  return *this;
 }
 
-ModuleList::ModuleList(const ModuleList &rhs) : m_modules(), m_modules_mutex(), m_notifier(nullptr)
-{
-    std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
-    std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
-    m_modules = rhs.m_modules;
-}
-
-ModuleList::ModuleList(ModuleList::Notifier *notifier) : m_modules(), m_modules_mutex(), m_notifier(notifier)
-{
-}
+ModuleList::~ModuleList() = default;
 
-const ModuleList&
-ModuleList::operator= (const ModuleList& rhs)
-{
-    if (this != &rhs)
-    {
-        // That's probably me nit-picking, but in theoretical situation:
-        //
-        // * that two threads A B and
-        // * two ModuleList's x y do opposite assignments ie.:
-        //
-        //  in thread A: | in thread B:
-        //    x = y;     |   y = x;
-        //
-        // This establishes correct(same) lock taking order and thus
-        // avoids priority inversion.
-        if (uintptr_t(this) > uintptr_t(&rhs))
-        {
-            std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
-            std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
-            m_modules = rhs.m_modules;
-        }
-        else
-        {
-            std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
-            std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
-            m_modules = rhs.m_modules;
-        }
-    }
-    return *this;
+void ModuleList::AppendImpl(const ModuleSP &module_sp, bool use_notifier) {
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+    m_modules.push_back(module_sp);
+    if (use_notifier && m_notifier)
+      m_notifier->ModuleAdded(*this, module_sp);
+  }
 }
 
-ModuleList::~ModuleList() = default;
+void ModuleList::Append(const ModuleSP &module_sp) { AppendImpl(module_sp); }
 
-void
-ModuleList::AppendImpl (const ModuleSP &module_sp, bool use_notifier)
-{
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        m_modules.push_back(module_sp);
-        if (use_notifier && m_notifier)
-            m_notifier->ModuleAdded(*this, module_sp);
-    }
-}
+void ModuleList::ReplaceEquivalent(const ModuleSP &module_sp) {
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 
-void
-ModuleList::Append (const ModuleSP &module_sp)
-{
-    AppendImpl (module_sp);
-}
+    // First remove any equivalent modules. Equivalent modules are modules
+    // whose path, platform path and architecture match.
+    ModuleSpec equivalent_module_spec(module_sp->GetFileSpec(),
+                                      module_sp->GetArchitecture());
+    equivalent_module_spec.GetPlatformFileSpec() =
+        module_sp->GetPlatformFileSpec();
 
-void
-ModuleList::ReplaceEquivalent (const ModuleSP &module_sp)
-{
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-
-        // First remove any equivalent modules. Equivalent modules are modules
-        // whose path, platform path and architecture match.
-        ModuleSpec equivalent_module_spec (module_sp->GetFileSpec(), module_sp->GetArchitecture());
-        equivalent_module_spec.GetPlatformFileSpec() = module_sp->GetPlatformFileSpec();
-
-        size_t idx = 0;
-        while (idx < m_modules.size())
-        {
-            ModuleSP module_sp (m_modules[idx]);
-            if (module_sp->MatchesModuleSpec (equivalent_module_spec))
-                RemoveImpl(m_modules.begin() + idx);
-            else
-                ++idx;
-        }
-        // Now add the new module to the list
-        Append(module_sp);
+    size_t idx = 0;
+    while (idx < m_modules.size()) {
+      ModuleSP module_sp(m_modules[idx]);
+      if (module_sp->MatchesModuleSpec(equivalent_module_spec))
+        RemoveImpl(m_modules.begin() + idx);
+      else
+        ++idx;
     }
+    // Now add the new module to the list
+    Append(module_sp);
+  }
 }
 
-bool
-ModuleList::AppendIfNeeded (const ModuleSP &module_sp)
-{
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::iterator pos, end = m_modules.end();
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            if (pos->get() == module_sp.get())
-                return false; // Already in the list
-        }
-        // Only push module_sp on the list if it wasn't already in there.
-        Append(module_sp);
-        return true;
+bool ModuleList::AppendIfNeeded(const ModuleSP &module_sp) {
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+    collection::iterator pos, end = m_modules.end();
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      if (pos->get() == module_sp.get())
+        return false; // Already in the list
     }
-    return false;
+    // Only push module_sp on the list if it wasn't already in there.
+    Append(module_sp);
+    return true;
+  }
+  return false;
 }
 
-void
-ModuleList::Append (const ModuleList& module_list)
-{
-    for (auto pos : module_list.m_modules)
-        Append(pos);
+void ModuleList::Append(const ModuleList &module_list) {
+  for (auto pos : module_list.m_modules)
+    Append(pos);
 }
 
-bool
-ModuleList::AppendIfNeeded (const ModuleList& module_list)
-{
-    bool any_in = false;
-    for (auto pos : module_list.m_modules)
-    {
-        if (AppendIfNeeded(pos))
-            any_in = true;
-    }
-    return any_in;
+bool ModuleList::AppendIfNeeded(const ModuleList &module_list) {
+  bool any_in = false;
+  for (auto pos : module_list.m_modules) {
+    if (AppendIfNeeded(pos))
+      any_in = true;
+  }
+  return any_in;
 }
 
-bool
-ModuleList::RemoveImpl (const ModuleSP &module_sp, bool use_notifier)
-{
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::iterator pos, end = m_modules.end();
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            if (pos->get() == module_sp.get())
-            {
-                m_modules.erase (pos);
-                if (use_notifier && m_notifier)
-                    m_notifier->ModuleRemoved(*this, module_sp);
-                return true;
-            }
-        }
+bool ModuleList::RemoveImpl(const ModuleSP &module_sp, bool use_notifier) {
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+    collection::iterator pos, end = m_modules.end();
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      if (pos->get() == module_sp.get()) {
+        m_modules.erase(pos);
+        if (use_notifier && m_notifier)
+          m_notifier->ModuleRemoved(*this, module_sp);
+        return true;
+      }
     }
-    return false;
+  }
+  return false;
 }
 
 ModuleList::collection::iterator
-ModuleList::RemoveImpl (ModuleList::collection::iterator pos, bool use_notifier)
-{
-    ModuleSP module_sp(*pos);
-    collection::iterator retval = m_modules.erase(pos);
-    if (use_notifier && m_notifier)
-        m_notifier->ModuleRemoved(*this, module_sp);
-    return retval;
+ModuleList::RemoveImpl(ModuleList::collection::iterator pos,
+                       bool use_notifier) {
+  ModuleSP module_sp(*pos);
+  collection::iterator retval = m_modules.erase(pos);
+  if (use_notifier && m_notifier)
+    m_notifier->ModuleRemoved(*this, module_sp);
+  return retval;
 }
 
-bool
-ModuleList::Remove (const ModuleSP &module_sp)
-{
-    return RemoveImpl (module_sp);
+bool ModuleList::Remove(const ModuleSP &module_sp) {
+  return RemoveImpl(module_sp);
 }
 
-bool
-ModuleList::ReplaceModule (const lldb::ModuleSP &old_module_sp, const lldb::ModuleSP &new_module_sp)
-{
-    if (!RemoveImpl(old_module_sp, false))
-        return false;
-    AppendImpl (new_module_sp, false);
-    if (m_notifier)
-        m_notifier->ModuleUpdated(*this, old_module_sp,new_module_sp);
-    return true;
-}
-
-bool
-ModuleList::RemoveIfOrphaned (const Module *module_ptr)
-{
-    if (module_ptr)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::iterator pos, end = m_modules.end();
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            if (pos->get() == module_ptr)
-            {
-                if (pos->unique())
-                {
-                    pos = RemoveImpl(pos);
-                    return true;
-                }
-                else
-                    return false;
-            }
-        }
-    }
+bool ModuleList::ReplaceModule(const lldb::ModuleSP &old_module_sp,
+                               const lldb::ModuleSP &new_module_sp) {
+  if (!RemoveImpl(old_module_sp, false))
     return false;
+  AppendImpl(new_module_sp, false);
+  if (m_notifier)
+    m_notifier->ModuleUpdated(*this, old_module_sp, new_module_sp);
+  return true;
 }
 
-size_t
-ModuleList::RemoveOrphans (bool mandatory)
-{
-    std::unique_lock<std::recursive_mutex> lock(m_modules_mutex, std::defer_lock);
-
-    if (mandatory)
-    {
-        lock.lock();
-    }
-    else
-    {
-        // Not mandatory, remove orphans if we can get the mutex
-        if (!lock.try_lock())
-            return 0;
-    }
-    collection::iterator pos = m_modules.begin();
-    size_t remove_count = 0;
-    while (pos != m_modules.end())
-    {
-        if (pos->unique())
-        {
-            pos = RemoveImpl(pos);
-            ++remove_count;
-        }
-        else
-        {
-            ++pos;
-        }
-    }
-    return remove_count;
-}
-
-size_t
-ModuleList::Remove (ModuleList &module_list)
-{
+bool ModuleList::RemoveIfOrphaned(const Module *module_ptr) {
+  if (module_ptr) {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    size_t num_removed = 0;
-    collection::iterator pos, end = module_list.m_modules.end();
-    for (pos = module_list.m_modules.begin(); pos != end; ++pos)
-    {
-        if (Remove (*pos))
-            ++num_removed;
+    collection::iterator pos, end = m_modules.end();
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      if (pos->get() == module_ptr) {
+        if (pos->unique()) {
+          pos = RemoveImpl(pos);
+          return true;
+        } else
+          return false;
+      }
     }
-    return num_removed;
+  }
+  return false;
 }
 
+size_t ModuleList::RemoveOrphans(bool mandatory) {
+  std::unique_lock<std::recursive_mutex> lock(m_modules_mutex, std::defer_lock);
 
-void
-ModuleList::Clear()
-{
-    ClearImpl();
+  if (mandatory) {
+    lock.lock();
+  } else {
+    // Not mandatory, remove orphans if we can get the mutex
+    if (!lock.try_lock())
+      return 0;
+  }
+  collection::iterator pos = m_modules.begin();
+  size_t remove_count = 0;
+  while (pos != m_modules.end()) {
+    if (pos->unique()) {
+      pos = RemoveImpl(pos);
+      ++remove_count;
+    } else {
+      ++pos;
+    }
+  }
+  return remove_count;
 }
 
-void
-ModuleList::Destroy()
-{
-    ClearImpl();
+size_t ModuleList::Remove(ModuleList &module_list) {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  size_t num_removed = 0;
+  collection::iterator pos, end = module_list.m_modules.end();
+  for (pos = module_list.m_modules.begin(); pos != end; ++pos) {
+    if (Remove(*pos))
+      ++num_removed;
+  }
+  return num_removed;
 }
 
-void
-ModuleList::ClearImpl (bool use_notifier)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    if (use_notifier && m_notifier)
-        m_notifier->WillClearList(*this);
-    m_modules.clear();
-}
+void ModuleList::Clear() { ClearImpl(); }
 
-Module*
-ModuleList::GetModulePointerAtIndex (size_t idx) const
-{
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    return GetModulePointerAtIndexUnlocked(idx);
-}
+void ModuleList::Destroy() { ClearImpl(); }
 
-Module*
-ModuleList::GetModulePointerAtIndexUnlocked (size_t idx) const
-{
-    if (idx < m_modules.size())
-        return m_modules[idx].get();
-    return nullptr;
+void ModuleList::ClearImpl(bool use_notifier) {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  if (use_notifier && m_notifier)
+    m_notifier->WillClearList(*this);
+  m_modules.clear();
 }
 
-ModuleSP
-ModuleList::GetModuleAtIndex(size_t idx) const
-{
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    return GetModuleAtIndexUnlocked(idx);
+Module *ModuleList::GetModulePointerAtIndex(size_t idx) const {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  return GetModulePointerAtIndexUnlocked(idx);
 }
 
-ModuleSP
-ModuleList::GetModuleAtIndexUnlocked(size_t idx) const
-{
-    ModuleSP module_sp;
-    if (idx < m_modules.size())
-        module_sp = m_modules[idx];
-    return module_sp;
+Module *ModuleList::GetModulePointerAtIndexUnlocked(size_t idx) const {
+  if (idx < m_modules.size())
+    return m_modules[idx].get();
+  return nullptr;
 }
 
-size_t
-ModuleList::FindFunctions (const ConstString &name, 
-                           uint32_t name_type_mask, 
-                           bool include_symbols,
-                           bool include_inlines,
-                           bool append, 
-                           SymbolContextList &sc_list) const
-{
-    if (!append)
-        sc_list.Clear();
-    
-    const size_t old_size = sc_list.GetSize();
-    
-    if (name_type_mask & eFunctionNameTypeAuto)
-    {
-        Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
-
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::const_iterator pos, end = m_modules.end();
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            (*pos)->FindFunctions(lookup_info.GetLookupName(),
-                                  nullptr,
-                                  lookup_info.GetNameTypeMask(),
-                                  include_symbols,
-                                  include_inlines,
-                                  true,
-                                  sc_list);
-        }
-        
-        const size_t new_size = sc_list.GetSize();
-
-        if (old_size < new_size)
-            lookup_info.Prune (sc_list, old_size);
-    }
-    else
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::const_iterator pos, end = m_modules.end();
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            (*pos)->FindFunctions(name, nullptr, name_type_mask, include_symbols, include_inlines, true, sc_list);
-        }
-    }
-    return sc_list.GetSize() - old_size;
+ModuleSP ModuleList::GetModuleAtIndex(size_t idx) const {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  return GetModuleAtIndexUnlocked(idx);
 }
 
-size_t
-ModuleList::FindFunctionSymbols (const ConstString &name,
-                                 uint32_t name_type_mask,
-                                 SymbolContextList& sc_list)
-{
-    const size_t old_size = sc_list.GetSize();
-
-    if (name_type_mask & eFunctionNameTypeAuto)
-    {
-        Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
-
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::const_iterator pos, end = m_modules.end();
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            (*pos)->FindFunctionSymbols (lookup_info.GetLookupName(),
-                                         lookup_info.GetNameTypeMask(),
-                                         sc_list);
-        }
+ModuleSP ModuleList::GetModuleAtIndexUnlocked(size_t idx) const {
+  ModuleSP module_sp;
+  if (idx < m_modules.size())
+    module_sp = m_modules[idx];
+  return module_sp;
+}
 
+size_t ModuleList::FindFunctions(const ConstString &name,
+                                 uint32_t name_type_mask, bool include_symbols,
+                                 bool include_inlines, bool append,
+                                 SymbolContextList &sc_list) const {
+  if (!append)
+    sc_list.Clear();
 
-        const size_t new_size = sc_list.GetSize();
+  const size_t old_size = sc_list.GetSize();
 
-        if (old_size < new_size)
-            lookup_info.Prune (sc_list, old_size);
-    }
-    else
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::const_iterator pos, end = m_modules.end();
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            (*pos)->FindFunctionSymbols (name, name_type_mask, sc_list);
-        }
-    }
-
-    return sc_list.GetSize() - old_size;
-}
-
-size_t
-ModuleList::FindFunctions(const RegularExpression &name,
-                          bool include_symbols,
-                          bool include_inlines,
-                          bool append,
-                          SymbolContextList& sc_list)
-{
-    const size_t old_size = sc_list.GetSize();
+  if (name_type_mask & eFunctionNameTypeAuto) {
+    Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
 
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        (*pos)->FindFunctions (name, include_symbols, include_inlines, append, sc_list);
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      (*pos)->FindFunctions(lookup_info.GetLookupName(), nullptr,
+                            lookup_info.GetNameTypeMask(), include_symbols,
+                            include_inlines, true, sc_list);
     }
 
-    return sc_list.GetSize() - old_size;
-}
-
-size_t
-ModuleList::FindCompileUnits (const FileSpec &path, 
-                              bool append, 
-                              SymbolContextList &sc_list) const
-{
-    if (!append)
-        sc_list.Clear();
+    const size_t new_size = sc_list.GetSize();
 
+    if (old_size < new_size)
+      lookup_info.Prune(sc_list, old_size);
+  } else {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        (*pos)->FindCompileUnits (path, true, sc_list);
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      (*pos)->FindFunctions(name, nullptr, name_type_mask, include_symbols,
+                            include_inlines, true, sc_list);
     }
-    
-    return sc_list.GetSize();
+  }
+  return sc_list.GetSize() - old_size;
 }
 
-size_t
-ModuleList::FindGlobalVariables (const ConstString &name, 
-                                 bool append, 
-                                 size_t max_matches,
-                                 VariableList& variable_list) const
-{
-    size_t initial_size = variable_list.GetSize();
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        (*pos)->FindGlobalVariables(name, nullptr, append, max_matches, variable_list);
-    }
-    return variable_list.GetSize() - initial_size;
-}
+size_t ModuleList::FindFunctionSymbols(const ConstString &name,
+                                       uint32_t name_type_mask,
+                                       SymbolContextList &sc_list) {
+  const size_t old_size = sc_list.GetSize();
+
+  if (name_type_mask & eFunctionNameTypeAuto) {
+    Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
 
-size_t
-ModuleList::FindGlobalVariables (const RegularExpression& regex, 
-                                 bool append, 
-                                 size_t max_matches,
-                                 VariableList& variable_list) const
-{
-    size_t initial_size = variable_list.GetSize();
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        (*pos)->FindGlobalVariables (regex, append, max_matches, variable_list);
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      (*pos)->FindFunctionSymbols(lookup_info.GetLookupName(),
+                                  lookup_info.GetNameTypeMask(), sc_list);
     }
-    return variable_list.GetSize() - initial_size;
-}
 
-size_t
-ModuleList::FindSymbolsWithNameAndType (const ConstString &name, 
-                                        SymbolType symbol_type, 
-                                        SymbolContextList &sc_list,
-                                        bool append) const
-{
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    if (!append)
-        sc_list.Clear();
-    size_t initial_size = sc_list.GetSize();
-    
-    collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-        (*pos)->FindSymbolsWithNameAndType (name, symbol_type, sc_list);
-    return sc_list.GetSize() - initial_size;
-}
+    const size_t new_size = sc_list.GetSize();
 
-size_t
-ModuleList::FindSymbolsMatchingRegExAndType (const RegularExpression &regex, 
-                                             lldb::SymbolType symbol_type, 
-                                             SymbolContextList &sc_list,
-                                             bool append) const
-{
+    if (old_size < new_size)
+      lookup_info.Prune(sc_list, old_size);
+  } else {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    if (!append)
-        sc_list.Clear();
-    size_t initial_size = sc_list.GetSize();
-    
     collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-        (*pos)->FindSymbolsMatchingRegExAndType (regex, symbol_type, sc_list);
-    return sc_list.GetSize() - initial_size;
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      (*pos)->FindFunctionSymbols(name, name_type_mask, sc_list);
+    }
+  }
+
+  return sc_list.GetSize() - old_size;
+}
+
+size_t ModuleList::FindFunctions(const RegularExpression &name,
+                                 bool include_symbols, bool include_inlines,
+                                 bool append, SymbolContextList &sc_list) {
+  const size_t old_size = sc_list.GetSize();
+
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    (*pos)->FindFunctions(name, include_symbols, include_inlines, append,
+                          sc_list);
+  }
+
+  return sc_list.GetSize() - old_size;
+}
+
+size_t ModuleList::FindCompileUnits(const FileSpec &path, bool append,
+                                    SymbolContextList &sc_list) const {
+  if (!append)
+    sc_list.Clear();
+
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    (*pos)->FindCompileUnits(path, true, sc_list);
+  }
+
+  return sc_list.GetSize();
+}
+
+size_t ModuleList::FindGlobalVariables(const ConstString &name, bool append,
+                                       size_t max_matches,
+                                       VariableList &variable_list) const {
+  size_t initial_size = variable_list.GetSize();
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    (*pos)->FindGlobalVariables(name, nullptr, append, max_matches,
+                                variable_list);
+  }
+  return variable_list.GetSize() - initial_size;
+}
+
+size_t ModuleList::FindGlobalVariables(const RegularExpression &regex,
+                                       bool append, size_t max_matches,
+                                       VariableList &variable_list) const {
+  size_t initial_size = variable_list.GetSize();
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    (*pos)->FindGlobalVariables(regex, append, max_matches, variable_list);
+  }
+  return variable_list.GetSize() - initial_size;
+}
+
+size_t ModuleList::FindSymbolsWithNameAndType(const ConstString &name,
+                                              SymbolType symbol_type,
+                                              SymbolContextList &sc_list,
+                                              bool append) const {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  if (!append)
+    sc_list.Clear();
+  size_t initial_size = sc_list.GetSize();
+
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos)
+    (*pos)->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
+  return sc_list.GetSize() - initial_size;
+}
+
+size_t ModuleList::FindSymbolsMatchingRegExAndType(
+    const RegularExpression &regex, lldb::SymbolType symbol_type,
+    SymbolContextList &sc_list, bool append) const {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  if (!append)
+    sc_list.Clear();
+  size_t initial_size = sc_list.GetSize();
+
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos)
+    (*pos)->FindSymbolsMatchingRegExAndType(regex, symbol_type, sc_list);
+  return sc_list.GetSize() - initial_size;
+}
+
+size_t ModuleList::FindModules(const ModuleSpec &module_spec,
+                               ModuleList &matching_module_list) const {
+  size_t existing_matches = matching_module_list.GetSize();
+
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    ModuleSP module_sp(*pos);
+    if (module_sp->MatchesModuleSpec(module_spec))
+      matching_module_list.Append(module_sp);
+  }
+  return matching_module_list.GetSize() - existing_matches;
 }
 
-size_t
-ModuleList::FindModules (const ModuleSpec &module_spec, ModuleList& matching_module_list) const
-{
-    size_t existing_matches = matching_module_list.GetSize();
+ModuleSP ModuleList::FindModule(const Module *module_ptr) const {
+  ModuleSP module_sp;
 
+  // Scope for "locker"
+  {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        ModuleSP module_sp(*pos);
-        if (module_sp->MatchesModuleSpec (module_spec))
-            matching_module_list.Append(module_sp);
-    }
-    return matching_module_list.GetSize() - existing_matches;
-}
 
-ModuleSP
-ModuleList::FindModule (const Module *module_ptr) const
-{
-    ModuleSP module_sp;
-
-    // Scope for "locker"
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::const_iterator pos, end = m_modules.end();
-
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            if ((*pos).get() == module_ptr)
-            {
-                module_sp = (*pos);
-                break;
-            }
-        }
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      if ((*pos).get() == module_ptr) {
+        module_sp = (*pos);
+        break;
+      }
     }
-    return module_sp;
+  }
+  return module_sp;
 }
 
-ModuleSP
-ModuleList::FindModule (const UUID &uuid) const
-{
-    ModuleSP module_sp;
-    
-    if (uuid.IsValid())
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::const_iterator pos, end = m_modules.end();
-        
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            if ((*pos)->GetUUID() == uuid)
-            {
-                module_sp = (*pos);
-                break;
-            }
-        }
-    }
-    return module_sp;
-}
+ModuleSP ModuleList::FindModule(const UUID &uuid) const {
+  ModuleSP module_sp;
 
-size_t
-ModuleList::FindTypes (const SymbolContext& sc, const ConstString &name, bool name_is_fully_qualified, size_t max_matches, llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeList& types) const
-{
+  if (uuid.IsValid()) {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-
-    size_t total_matches = 0;
     collection::const_iterator pos, end = m_modules.end();
-    if (sc.module_sp)
-    {
-        // The symbol context "sc" contains a module so we want to search that
-        // one first if it is in our list...
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            if (sc.module_sp.get() == (*pos).get())
-            {
-                total_matches += (*pos)->FindTypes (sc, name, name_is_fully_qualified, max_matches, searched_symbol_files, types);
-
-                if (total_matches >= max_matches)
-                    break;
-            }
-        }
-    }
-    
-    if (total_matches < max_matches)
-    {
-        SymbolContext world_sc;
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            // Search the module if the module is not equal to the one in the symbol
-            // context "sc". If "sc" contains a empty module shared pointer, then
-            // the comparison will always be true (valid_module_ptr != nullptr).
-            if (sc.module_sp.get() != (*pos).get())
-                total_matches += (*pos)->FindTypes (world_sc, name, name_is_fully_qualified, max_matches, searched_symbol_files, types);
-            
-            if (total_matches >= max_matches)
-                break;
-        }
-    }
-    
-    return total_matches;
-}
 
-bool
-ModuleList::FindSourceFile (const FileSpec &orig_spec, FileSpec &new_spec) const
-{
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        if ((*pos)->FindSourceFile (orig_spec, new_spec))
-            return true;
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      if ((*pos)->GetUUID() == uuid) {
+        module_sp = (*pos);
+        break;
+      }
     }
-    return false;
-}
-
-void
-ModuleList::FindAddressesForLine (const lldb::TargetSP target_sp,
-                                  const FileSpec &file, uint32_t line,
-                                  Function *function,
-                                  std::vector<Address> &output_local, std::vector<Address> &output_extern)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        (*pos)->FindAddressesForLine(target_sp, file, line, function, output_local, output_extern);
-    }
-}
-
-ModuleSP
-ModuleList::FindFirstModule (const ModuleSpec &module_spec) const
-{
-    ModuleSP module_sp;
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        ModuleSP module_sp(*pos);
-        if (module_sp->MatchesModuleSpec (module_spec))
-            return module_sp;
-    }
-    return module_sp;
-
+  }
+  return module_sp;
 }
 
 size_t
-ModuleList::GetSize() const
-{
-    size_t size = 0;
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        size = m_modules.size();
-    }
-    return size;
+ModuleList::FindTypes(const SymbolContext &sc, const ConstString &name,
+                      bool name_is_fully_qualified, size_t max_matches,
+                      llvm::DenseSet<SymbolFile *> &searched_symbol_files,
+                      TypeList &types) const {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+
+  size_t total_matches = 0;
+  collection::const_iterator pos, end = m_modules.end();
+  if (sc.module_sp) {
+    // The symbol context "sc" contains a module so we want to search that
+    // one first if it is in our list...
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      if (sc.module_sp.get() == (*pos).get()) {
+        total_matches +=
+            (*pos)->FindTypes(sc, name, name_is_fully_qualified, max_matches,
+                              searched_symbol_files, types);
+
+        if (total_matches >= max_matches)
+          break;
+      }
+    }
+  }
+
+  if (total_matches < max_matches) {
+    SymbolContext world_sc;
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      // Search the module if the module is not equal to the one in the symbol
+      // context "sc". If "sc" contains a empty module shared pointer, then
+      // the comparison will always be true (valid_module_ptr != nullptr).
+      if (sc.module_sp.get() != (*pos).get())
+        total_matches +=
+            (*pos)->FindTypes(world_sc, name, name_is_fully_qualified,
+                              max_matches, searched_symbol_files, types);
+
+      if (total_matches >= max_matches)
+        break;
+    }
+  }
+
+  return total_matches;
+}
+
+bool ModuleList::FindSourceFile(const FileSpec &orig_spec,
+                                FileSpec &new_spec) const {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    if ((*pos)->FindSourceFile(orig_spec, new_spec))
+      return true;
+  }
+  return false;
+}
+
+void ModuleList::FindAddressesForLine(const lldb::TargetSP target_sp,
+                                      const FileSpec &file, uint32_t line,
+                                      Function *function,
+                                      std::vector<Address> &output_local,
+                                      std::vector<Address> &output_extern) {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    (*pos)->FindAddressesForLine(target_sp, file, line, function, output_local,
+                                 output_extern);
+  }
+}
+
+ModuleSP ModuleList::FindFirstModule(const ModuleSpec &module_spec) const {
+  ModuleSP module_sp;
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    ModuleSP module_sp(*pos);
+    if (module_sp->MatchesModuleSpec(module_spec))
+      return module_sp;
+  }
+  return module_sp;
 }
 
-void
-ModuleList::Dump(Stream *s) const
-{
-    //  s.Printf("%.*p: ", (int)sizeof(void*) * 2, this);
-    //  s.Indent();
-    //  s << "ModuleList\n";
-
+size_t ModuleList::GetSize() const {
+  size_t size = 0;
+  {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        (*pos)->Dump(s);
-    }
+    size = m_modules.size();
+  }
+  return size;
 }
 
-void
-ModuleList::LogUUIDAndPaths (Log *log, const char *prefix_cstr)
-{
-    if (log != nullptr)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::const_iterator pos, begin = m_modules.begin(), end = m_modules.end();
-        for (pos = begin; pos != end; ++pos)
-        {
-            Module *module = pos->get();
-            const FileSpec &module_file_spec = module->GetFileSpec();
-            log->Printf ("%s[%u] %s (%s) \"%s\"",
-                         prefix_cstr ? prefix_cstr : "",
-                         (uint32_t)std::distance (begin, pos),
-                         module->GetUUID().GetAsString().c_str(),
-                         module->GetArchitecture().GetArchitectureName(),
-                         module_file_spec.GetPath().c_str());
-        }
-    }
+void ModuleList::Dump(Stream *s) const {
+  //  s.Printf("%.*p: ", (int)sizeof(void*) * 2, this);
+  //  s.Indent();
+  //  s << "ModuleList\n";
+
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    (*pos)->Dump(s);
+  }
 }
 
-bool
-ModuleList::ResolveFileAddress (lldb::addr_t vm_addr, Address& so_addr) const
-{
+void ModuleList::LogUUIDAndPaths(Log *log, const char *prefix_cstr) {
+  if (log != nullptr) {
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+    collection::const_iterator pos, begin = m_modules.begin(),
+                                    end = m_modules.end();
+    for (pos = begin; pos != end; ++pos) {
+      Module *module = pos->get();
+      const FileSpec &module_file_spec = module->GetFileSpec();
+      log->Printf("%s[%u] %s (%s) \"%s\"", prefix_cstr ? prefix_cstr : "",
+                  (uint32_t)std::distance(begin, pos),
+                  module->GetUUID().GetAsString().c_str(),
+                  module->GetArchitecture().GetArchitectureName(),
+                  module_file_spec.GetPath().c_str());
+    }
+  }
+}
+
+bool ModuleList::ResolveFileAddress(lldb::addr_t vm_addr,
+                                    Address &so_addr) const {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    if ((*pos)->ResolveFileAddress(vm_addr, so_addr))
+      return true;
+  }
+
+  return false;
+}
+
+uint32_t ModuleList::ResolveSymbolContextForAddress(const Address &so_addr,
+                                                    uint32_t resolve_scope,
+                                                    SymbolContext &sc) const {
+  // The address is already section offset so it has a module
+  uint32_t resolved_flags = 0;
+  ModuleSP module_sp(so_addr.GetModule());
+  if (module_sp) {
+    resolved_flags =
+        module_sp->ResolveSymbolContextForAddress(so_addr, resolve_scope, sc);
+  } else {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        if ((*pos)->ResolveFileAddress (vm_addr, so_addr))
-            return true;
-    }
-
-    return false;
-}
-
-uint32_t
-ModuleList::ResolveSymbolContextForAddress (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) const
-{
-    // The address is already section offset so it has a module
-    uint32_t resolved_flags = 0;
-    ModuleSP module_sp (so_addr.GetModule());
-    if (module_sp)
-    {
-        resolved_flags = module_sp->ResolveSymbolContextForAddress (so_addr,
-                                                                    resolve_scope,
-                                                                    sc);
-    }
-    else
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::const_iterator pos, end = m_modules.end();
-        for (pos = m_modules.begin(); pos != end; ++pos)
-        {
-            resolved_flags = (*pos)->ResolveSymbolContextForAddress (so_addr,
-                                                                     resolve_scope,
-                                                                     sc);
-            if (resolved_flags != 0)
-                break;
-        }
+    for (pos = m_modules.begin(); pos != end; ++pos) {
+      resolved_flags =
+          (*pos)->ResolveSymbolContextForAddress(so_addr, resolve_scope, sc);
+      if (resolved_flags != 0)
+        break;
     }
+  }
 
-    return resolved_flags;
+  return resolved_flags;
 }
 
-uint32_t
-ModuleList::ResolveSymbolContextForFilePath(const char *file_path,
-                                            uint32_t line,
-                                            bool check_inlines,
-                                            uint32_t resolve_scope,
-                                            SymbolContextList& sc_list) const
-{
-    FileSpec file_spec(file_path, false);
-    return ResolveSymbolContextsForFileSpec (file_spec, line, check_inlines, resolve_scope, sc_list);
+uint32_t ModuleList::ResolveSymbolContextForFilePath(
+    const char *file_path, uint32_t line, bool check_inlines,
+    uint32_t resolve_scope, SymbolContextList &sc_list) const {
+  FileSpec file_spec(file_path, false);
+  return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
+                                          resolve_scope, sc_list);
 }
 
-uint32_t
-ModuleList::ResolveSymbolContextsForFileSpec (const FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list) const
-{
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    collection::const_iterator pos, end = m_modules.end();
-    for (pos = m_modules.begin(); pos != end; ++pos)
-    {
-        (*pos)->ResolveSymbolContextsForFileSpec (file_spec, line, check_inlines, resolve_scope, sc_list);
-    }
+uint32_t ModuleList::ResolveSymbolContextsForFileSpec(
+    const FileSpec &file_spec, uint32_t line, bool check_inlines,
+    uint32_t resolve_scope, SymbolContextList &sc_list) const {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  collection::const_iterator pos, end = m_modules.end();
+  for (pos = m_modules.begin(); pos != end; ++pos) {
+    (*pos)->ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
+                                             resolve_scope, sc_list);
+  }
 
-    return sc_list.GetSize();
+  return sc_list.GetSize();
 }
 
-size_t
-ModuleList::GetIndexForModule (const Module *module) const
-{
-    if (module)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-        collection::const_iterator pos;
-        collection::const_iterator begin = m_modules.begin();
-        collection::const_iterator end = m_modules.end();
-        for (pos = begin; pos != end; ++pos)
-        {
-            if ((*pos).get() == module)
-                return std::distance (begin, pos);
+size_t ModuleList::GetIndexForModule(const Module *module) const {
+  if (module) {
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+    collection::const_iterator pos;
+    collection::const_iterator begin = m_modules.begin();
+    collection::const_iterator end = m_modules.end();
+    for (pos = begin; pos != end; ++pos) {
+      if ((*pos).get() == module)
+        return std::distance(begin, pos);
+    }
+  }
+  return LLDB_INVALID_INDEX32;
+}
+
+static ModuleList &GetSharedModuleList() {
+  static ModuleList *g_shared_module_list = nullptr;
+  static std::once_flag g_once_flag;
+  std::call_once(g_once_flag, []() {
+    // NOTE: Intentionally leak the module list so a program doesn't have to
+    // cleanup all modules and object files as it exits. This just wastes time
+    // doing a bunch of cleanup that isn't required.
+    if (g_shared_module_list == nullptr)
+      g_shared_module_list = new ModuleList(); // <--- Intentional leak!!!
+  });
+  return *g_shared_module_list;
+}
+
+bool ModuleList::ModuleIsInCache(const Module *module_ptr) {
+  if (module_ptr) {
+    ModuleList &shared_module_list = GetSharedModuleList();
+    return shared_module_list.FindModule(module_ptr).get() != nullptr;
+  }
+  return false;
+}
+
+size_t ModuleList::FindSharedModules(const ModuleSpec &module_spec,
+                                     ModuleList &matching_module_list) {
+  return GetSharedModuleList().FindModules(module_spec, matching_module_list);
+}
+
+size_t ModuleList::RemoveOrphanSharedModules(bool mandatory) {
+  return GetSharedModuleList().RemoveOrphans(mandatory);
+}
+
+Error ModuleList::GetSharedModule(const ModuleSpec &module_spec,
+                                  ModuleSP &module_sp,
+                                  const FileSpecList *module_search_paths_ptr,
+                                  ModuleSP *old_module_sp_ptr,
+                                  bool *did_create_ptr, bool always_create) {
+  ModuleList &shared_module_list = GetSharedModuleList();
+  std::lock_guard<std::recursive_mutex> guard(
+      shared_module_list.m_modules_mutex);
+  char path[PATH_MAX];
+
+  Error error;
+
+  module_sp.reset();
+
+  if (did_create_ptr)
+    *did_create_ptr = false;
+  if (old_module_sp_ptr)
+    old_module_sp_ptr->reset();
+
+  const UUID *uuid_ptr = module_spec.GetUUIDPtr();
+  const FileSpec &module_file_spec = module_spec.GetFileSpec();
+  const ArchSpec &arch = module_spec.GetArchitecture();
+
+  // Make sure no one else can try and get or create a module while this
+  // function is actively working on it by doing an extra lock on the
+  // global mutex list.
+  if (!always_create) {
+    ModuleList matching_module_list;
+    const size_t num_matching_modules =
+        shared_module_list.FindModules(module_spec, matching_module_list);
+    if (num_matching_modules > 0) {
+      for (size_t module_idx = 0; module_idx < num_matching_modules;
+           ++module_idx) {
+        module_sp = matching_module_list.GetModuleAtIndex(module_idx);
+
+        // Make sure the file for the module hasn't been modified
+        if (module_sp->FileHasChanged()) {
+          if (old_module_sp_ptr && !*old_module_sp_ptr)
+            *old_module_sp_ptr = module_sp;
+
+          Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_MODULES));
+          if (log != nullptr)
+            log->Printf("module changed: %p, removing from global module list",
+                        static_cast<void *>(module_sp.get()));
+
+          shared_module_list.Remove(module_sp);
+          module_sp.reset();
+        } else {
+          // The module matches and the module was not modified from
+          // when it was last loaded.
+          return error;
         }
+      }
     }
-    return LLDB_INVALID_INDEX32;
-}
+  }
 
-static ModuleList &
-GetSharedModuleList ()
-{
-    static ModuleList *g_shared_module_list = nullptr;
-    static std::once_flag g_once_flag;
-    std::call_once(g_once_flag, [](){
-        // NOTE: Intentionally leak the module list so a program doesn't have to
-        // cleanup all modules and object files as it exits. This just wastes time
-        // doing a bunch of cleanup that isn't required.
-        if (g_shared_module_list == nullptr)
-            g_shared_module_list = new ModuleList(); // <--- Intentional leak!!!
-    });
-    return *g_shared_module_list;
-}
-
-bool
-ModuleList::ModuleIsInCache (const Module *module_ptr)
-{
-    if (module_ptr)
-    {
-        ModuleList &shared_module_list = GetSharedModuleList ();
-        return shared_module_list.FindModule(module_ptr).get() != nullptr;
-    }
-    return false;
-}
-
-size_t
-ModuleList::FindSharedModules (const ModuleSpec &module_spec, ModuleList &matching_module_list)
-{
-    return GetSharedModuleList ().FindModules (module_spec, matching_module_list);
-}
-
-size_t
-ModuleList::RemoveOrphanSharedModules (bool mandatory)
-{
-    return GetSharedModuleList ().RemoveOrphans(mandatory);
-}
-
-Error
-ModuleList::GetSharedModule(const ModuleSpec &module_spec,
-                            ModuleSP &module_sp,
-                            const FileSpecList *module_search_paths_ptr,
-                            ModuleSP *old_module_sp_ptr,
-                            bool *did_create_ptr,
-                            bool always_create)
-{
-    ModuleList &shared_module_list = GetSharedModuleList ();
-    std::lock_guard<std::recursive_mutex> guard(shared_module_list.m_modules_mutex);
-    char path[PATH_MAX];
-
-    Error error;
-
-    module_sp.reset();
-
-    if (did_create_ptr)
-        *did_create_ptr = false;
-    if (old_module_sp_ptr)
-        old_module_sp_ptr->reset();
-
-    const UUID *uuid_ptr = module_spec.GetUUIDPtr();
-    const FileSpec &module_file_spec = module_spec.GetFileSpec();
-    const ArchSpec &arch = module_spec.GetArchitecture();
+  if (module_sp)
+    return error;
 
-    // Make sure no one else can try and get or create a module while this
-    // function is actively working on it by doing an extra lock on the
-    // global mutex list.
-    if (!always_create)
-    {
-        ModuleList matching_module_list;
-        const size_t num_matching_modules = shared_module_list.FindModules (module_spec, matching_module_list);
-        if (num_matching_modules > 0)
-        {
-            for (size_t module_idx = 0; module_idx < num_matching_modules; ++module_idx)
-            {
-                module_sp = matching_module_list.GetModuleAtIndex(module_idx);
-
-                // Make sure the file for the module hasn't been modified
-                if (module_sp->FileHasChanged())
-                {
-                    if (old_module_sp_ptr && !*old_module_sp_ptr)
-                        *old_module_sp_ptr = module_sp;
-
-                    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_MODULES));
-                    if (log != nullptr)
-                        log->Printf("module changed: %p, removing from global module list",
-                                    static_cast<void*>(module_sp.get()));
-
-                    shared_module_list.Remove (module_sp);
-                    module_sp.reset();
-                }
-                else
-                {
-                    // The module matches and the module was not modified from
-                    // when it was last loaded.
-                    return error;
-                }
-            }
+  module_sp.reset(new Module(module_spec));
+  // Make sure there are a module and an object file since we can specify
+  // a valid file path with an architecture that might not be in that file.
+  // By getting the object file we can guarantee that the architecture matches
+  if (module_sp->GetObjectFile()) {
+    // If we get in here we got the correct arch, now we just need
+    // to verify the UUID if one was given
+    if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
+      module_sp.reset();
+    } else {
+      if (module_sp->GetObjectFile() &&
+          module_sp->GetObjectFile()->GetType() ==
+              ObjectFile::eTypeStubLibrary) {
+        module_sp.reset();
+      } else {
+        if (did_create_ptr) {
+          *did_create_ptr = true;
         }
-    }
 
-    if (module_sp)
+        shared_module_list.ReplaceEquivalent(module_sp);
         return error;
-
-    module_sp.reset (new Module (module_spec));
-    // Make sure there are a module and an object file since we can specify
-    // a valid file path with an architecture that might not be in that file.
-    // By getting the object file we can guarantee that the architecture matches
-    if (module_sp->GetObjectFile())
-    {
+      }
+    }
+  } else {
+    module_sp.reset();
+  }
+
+  if (module_search_paths_ptr) {
+    const auto num_directories = module_search_paths_ptr->GetSize();
+    for (size_t idx = 0; idx < num_directories; ++idx) {
+      auto search_path_spec = module_search_paths_ptr->GetFileSpecAtIndex(idx);
+      if (!search_path_spec.ResolvePath())
+        continue;
+      if (!search_path_spec.Exists() || !search_path_spec.IsDirectory())
+        continue;
+      search_path_spec.AppendPathComponent(
+          module_spec.GetFileSpec().GetFilename().AsCString());
+      if (!search_path_spec.Exists())
+        continue;
+
+      auto resolved_module_spec(module_spec);
+      resolved_module_spec.GetFileSpec() = search_path_spec;
+      module_sp.reset(new Module(resolved_module_spec));
+      if (module_sp->GetObjectFile()) {
         // If we get in here we got the correct arch, now we just need
         // to verify the UUID if one was given
-        if (uuid_ptr && *uuid_ptr != module_sp->GetUUID())
-        {
+        if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
+          module_sp.reset();
+        } else {
+          if (module_sp->GetObjectFile()->GetType() ==
+              ObjectFile::eTypeStubLibrary) {
             module_sp.reset();
+          } else {
+            if (did_create_ptr)
+              *did_create_ptr = true;
+
+            shared_module_list.ReplaceEquivalent(module_sp);
+            return Error();
+          }
         }
-        else
-        {
-            if (module_sp->GetObjectFile() && module_sp->GetObjectFile()->GetType() == ObjectFile::eTypeStubLibrary)
-            {
-                module_sp.reset();
-            }
-            else
-            {
-                if (did_create_ptr)
-                {
-                    *did_create_ptr = true;
-                }
-
-                shared_module_list.ReplaceEquivalent(module_sp);
-                return error;
-            }
-        }
-    }
-    else
-    {
+      } else {
         module_sp.reset();
-    }
-
-    if (module_search_paths_ptr)
-    {
-        const auto num_directories = module_search_paths_ptr->GetSize();
-        for (size_t idx = 0; idx < num_directories; ++idx)
-        {
-            auto search_path_spec = module_search_paths_ptr->GetFileSpecAtIndex(idx);
-            if (!search_path_spec.ResolvePath())
-                continue;
-            if (!search_path_spec.Exists() || !search_path_spec.IsDirectory())
-                continue;
-            search_path_spec.AppendPathComponent(module_spec.GetFileSpec().GetFilename().AsCString());
-            if (!search_path_spec.Exists())
-                continue;
-
-            auto resolved_module_spec(module_spec);
-            resolved_module_spec.GetFileSpec() = search_path_spec;
-            module_sp.reset (new Module (resolved_module_spec));
-            if (module_sp->GetObjectFile())
-            {
-                // If we get in here we got the correct arch, now we just need
-                // to verify the UUID if one was given
-                if (uuid_ptr && *uuid_ptr != module_sp->GetUUID())
-                {
-                    module_sp.reset();
-                }
-                else
-                {
-                    if (module_sp->GetObjectFile()->GetType() == ObjectFile::eTypeStubLibrary)
-                    {
-                        module_sp.reset();
-                    }
-                    else
-                    {
-                        if (did_create_ptr)
-                            *did_create_ptr = true;
-    
-                        shared_module_list.ReplaceEquivalent(module_sp);
-                        return Error();
-                    }
-                }
-            }
-            else
-            {
-                module_sp.reset();
-            }
+      }
+    }
+  }
+
+  // Either the file didn't exist where at the path, or no path was given, so
+  // we now have to use more extreme measures to try and find the appropriate
+  // module.
+
+  // Fixup the incoming path in case the path points to a valid file, yet
+  // the arch or UUID (if one was passed in) don't match.
+  ModuleSpec located_binary_modulespec =
+      Symbols::LocateExecutableObjectFile(module_spec);
+
+  // Don't look for the file if it appears to be the same one we already
+  // checked for above...
+  if (located_binary_modulespec.GetFileSpec() != module_file_spec) {
+    if (!located_binary_modulespec.GetFileSpec().Exists()) {
+      located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path));
+      if (path[0] == '\0')
+        module_file_spec.GetPath(path, sizeof(path));
+      // How can this check ever be true? This branch it is false, and we
+      // haven't modified file_spec.
+      if (located_binary_modulespec.GetFileSpec().Exists()) {
+        std::string uuid_str;
+        if (uuid_ptr && uuid_ptr->IsValid())
+          uuid_str = uuid_ptr->GetAsString();
+
+        if (arch.IsValid()) {
+          if (!uuid_str.empty())
+            error.SetErrorStringWithFormat(
+                "'%s' does not contain the %s architecture and UUID %s", path,
+                arch.GetArchitectureName(), uuid_str.c_str());
+          else
+            error.SetErrorStringWithFormat(
+                "'%s' does not contain the %s architecture.", path,
+                arch.GetArchitectureName());
         }
+      } else {
+        error.SetErrorStringWithFormat("'%s' does not exist", path);
+      }
+      if (error.Fail())
+        module_sp.reset();
+      return error;
     }
 
-    // Either the file didn't exist where at the path, or no path was given, so
-    // we now have to use more extreme measures to try and find the appropriate
-    // module.
-
-    // Fixup the incoming path in case the path points to a valid file, yet
-    // the arch or UUID (if one was passed in) don't match.
-    ModuleSpec located_binary_modulespec = Symbols::LocateExecutableObjectFile (module_spec);
-
-    // Don't look for the file if it appears to be the same one we already
-    // checked for above...
-    if (located_binary_modulespec.GetFileSpec() != module_file_spec)
-    {
-        if (!located_binary_modulespec.GetFileSpec().Exists())
-        {
-            located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path));
-            if (path[0] == '\0')
-                module_file_spec.GetPath(path, sizeof(path));
-            // How can this check ever be true? This branch it is false, and we haven't modified file_spec.
-            if (located_binary_modulespec.GetFileSpec().Exists())
-            {
-                std::string uuid_str;
-                if (uuid_ptr && uuid_ptr->IsValid())
-                    uuid_str = uuid_ptr->GetAsString();
-
-                if (arch.IsValid())
-                {
-                    if (!uuid_str.empty())
-                        error.SetErrorStringWithFormat("'%s' does not contain the %s architecture and UUID %s", path, arch.GetArchitectureName(), uuid_str.c_str());
-                    else
-                        error.SetErrorStringWithFormat("'%s' does not contain the %s architecture.", path, arch.GetArchitectureName());
-                }
-            }
-            else
-            {
-                error.SetErrorStringWithFormat("'%s' does not exist", path);
-            }
-            if (error.Fail())
-                module_sp.reset();
-            return error;
+    // Make sure no one else can try and get or create a module while this
+    // function is actively working on it by doing an extra lock on the
+    // global mutex list.
+    ModuleSpec platform_module_spec(module_spec);
+    platform_module_spec.GetFileSpec() =
+        located_binary_modulespec.GetFileSpec();
+    platform_module_spec.GetPlatformFileSpec() =
+        located_binary_modulespec.GetFileSpec();
+    platform_module_spec.GetSymbolFileSpec() =
+        located_binary_modulespec.GetSymbolFileSpec();
+    ModuleList matching_module_list;
+    if (shared_module_list.FindModules(platform_module_spec,
+                                       matching_module_list) > 0) {
+      module_sp = matching_module_list.GetModuleAtIndex(0);
+
+      // If we didn't have a UUID in mind when looking for the object file,
+      // then we should make sure the modification time hasn't changed!
+      if (platform_module_spec.GetUUIDPtr() == nullptr) {
+        TimeValue file_spec_mod_time(
+            located_binary_modulespec.GetFileSpec().GetModificationTime());
+        if (file_spec_mod_time.IsValid()) {
+          if (file_spec_mod_time != module_sp->GetModificationTime()) {
+            if (old_module_sp_ptr)
+              *old_module_sp_ptr = module_sp;
+            shared_module_list.Remove(module_sp);
+            module_sp.reset();
+          }
         }
-
-        // Make sure no one else can try and get or create a module while this
-        // function is actively working on it by doing an extra lock on the
-        // global mutex list.
-        ModuleSpec platform_module_spec(module_spec);
-        platform_module_spec.GetFileSpec() = located_binary_modulespec.GetFileSpec();
-        platform_module_spec.GetPlatformFileSpec() = located_binary_modulespec.GetFileSpec();
-        platform_module_spec.GetSymbolFileSpec() = located_binary_modulespec.GetSymbolFileSpec();
-        ModuleList matching_module_list;
-        if (shared_module_list.FindModules (platform_module_spec, matching_module_list) > 0)
-        {
-            module_sp = matching_module_list.GetModuleAtIndex(0);
-
-            // If we didn't have a UUID in mind when looking for the object file,
-            // then we should make sure the modification time hasn't changed!
-            if (platform_module_spec.GetUUIDPtr() == nullptr)
-            {
-                TimeValue file_spec_mod_time(located_binary_modulespec.GetFileSpec().GetModificationTime());
-                if (file_spec_mod_time.IsValid())
-                {
-                    if (file_spec_mod_time != module_sp->GetModificationTime())
-                    {
-                        if (old_module_sp_ptr)
-                            *old_module_sp_ptr = module_sp;
-                        shared_module_list.Remove (module_sp);
-                        module_sp.reset();
-                    }
-                }
-            }
+      }
+    }
+
+    if (!module_sp) {
+      module_sp.reset(new Module(platform_module_spec));
+      // Make sure there are a module and an object file since we can specify
+      // a valid file path with an architecture that might not be in that file.
+      // By getting the object file we can guarantee that the architecture
+      // matches
+      if (module_sp && module_sp->GetObjectFile()) {
+        if (module_sp->GetObjectFile()->GetType() ==
+            ObjectFile::eTypeStubLibrary) {
+          module_sp.reset();
+        } else {
+          if (did_create_ptr)
+            *did_create_ptr = true;
+
+          shared_module_list.ReplaceEquivalent(module_sp);
         }
-
-        if (!module_sp)
-        {
-            module_sp.reset (new Module (platform_module_spec));
-            // Make sure there are a module and an object file since we can specify
-            // a valid file path with an architecture that might not be in that file.
-            // By getting the object file we can guarantee that the architecture matches
-            if (module_sp && module_sp->GetObjectFile())
-            {
-                if (module_sp->GetObjectFile()->GetType() == ObjectFile::eTypeStubLibrary)
-                {
-                    module_sp.reset();
-                }
-                else
-                {
-                    if (did_create_ptr)
-                        *did_create_ptr = true;
-
-                    shared_module_list.ReplaceEquivalent(module_sp);
-                }
-            }
-            else
-            {
-                located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path));
-
-                if (located_binary_modulespec.GetFileSpec())
-                {
-                    if (arch.IsValid())
-                        error.SetErrorStringWithFormat("unable to open %s architecture in '%s'", arch.GetArchitectureName(), path);
-                    else
-                        error.SetErrorStringWithFormat("unable to open '%s'", path);
-                }
-                else
-                {
-                    std::string uuid_str;
-                    if (uuid_ptr && uuid_ptr->IsValid())
-                        uuid_str = uuid_ptr->GetAsString();
-
-                    if (!uuid_str.empty())
-                        error.SetErrorStringWithFormat("cannot locate a module for UUID '%s'", uuid_str.c_str());
-                    else
-                        error.SetErrorStringWithFormat("cannot locate a module");
-                }
-            }
+      } else {
+        located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path));
+
+        if (located_binary_modulespec.GetFileSpec()) {
+          if (arch.IsValid())
+            error.SetErrorStringWithFormat(
+                "unable to open %s architecture in '%s'",
+                arch.GetArchitectureName(), path);
+          else
+            error.SetErrorStringWithFormat("unable to open '%s'", path);
+        } else {
+          std::string uuid_str;
+          if (uuid_ptr && uuid_ptr->IsValid())
+            uuid_str = uuid_ptr->GetAsString();
+
+          if (!uuid_str.empty())
+            error.SetErrorStringWithFormat(
+                "cannot locate a module for UUID '%s'", uuid_str.c_str());
+          else
+            error.SetErrorStringWithFormat("cannot locate a module");
         }
+      }
     }
+  }
 
-    return error;
+  return error;
 }
 
-bool
-ModuleList::RemoveSharedModule (lldb::ModuleSP &module_sp)
-{
-    return GetSharedModuleList ().Remove (module_sp);
+bool ModuleList::RemoveSharedModule(lldb::ModuleSP &module_sp) {
+  return GetSharedModuleList().Remove(module_sp);
 }
 
-bool
-ModuleList::RemoveSharedModuleIfOrphaned (const Module *module_ptr)
-{
-    return GetSharedModuleList ().RemoveIfOrphaned (module_ptr);
+bool ModuleList::RemoveSharedModuleIfOrphaned(const Module *module_ptr) {
+  return GetSharedModuleList().RemoveIfOrphaned(module_ptr);
 }
 
-bool
-ModuleList::LoadScriptingResourcesInTarget (Target *target,
-                                            std::list<Error>& errors,
-                                            Stream *feedback_stream,
-                                            bool continue_on_error)
-{
-    if (!target)
-        return false;
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    for (auto module : m_modules)
-    {
-        Error error;
-        if (module)
-        {
-            if (!module->LoadScriptingResourceInTarget(target, error, feedback_stream))
-            {
-                if (error.Fail() && error.AsCString())
-                {
-                    error.SetErrorStringWithFormat("unable to load scripting data for module %s - error reported was %s",
-                                                   module->GetFileSpec().GetFileNameStrippingExtension().GetCString(),
-                                                   error.AsCString());
-                    errors.push_back(error);
-
-                    if (!continue_on_error)
-                        return false;
-                }
-            }
+bool ModuleList::LoadScriptingResourcesInTarget(Target *target,
+                                                std::list<Error> &errors,
+                                                Stream *feedback_stream,
+                                                bool continue_on_error) {
+  if (!target)
+    return false;
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  for (auto module : m_modules) {
+    Error error;
+    if (module) {
+      if (!module->LoadScriptingResourceInTarget(target, error,
+                                                 feedback_stream)) {
+        if (error.Fail() && error.AsCString()) {
+          error.SetErrorStringWithFormat("unable to load scripting data for "
+                                         "module %s - error reported was %s",
+                                         module->GetFileSpec()
+                                             .GetFileNameStrippingExtension()
+                                             .GetCString(),
+                                         error.AsCString());
+          errors.push_back(error);
+
+          if (!continue_on_error)
+            return false;
         }
+      }
     }
-    return errors.empty();
+  }
+  return errors.empty();
 }
 
-void
-ModuleList::ForEach (std::function <bool (const ModuleSP &module_sp)> const &callback) const
-{
-    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-    for (const auto &module : m_modules)
-    {
-        // If the callback returns false, then stop iterating and break out
-        if (!callback (module))
-            break;
-    }
+void ModuleList::ForEach(
+    std::function<bool(const ModuleSP &module_sp)> const &callback) const {
+  std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
+  for (const auto &module : m_modules) {
+    // If the callback returns false, then stop iterating and break out
+    if (!callback(module))
+      break;
+  }
 }