*** 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, 400 insertions, 493 deletions

diff --git a/lldb/source/Symbol/SymbolVendor.cpp b/lldb/source/Symbol/SymbolVendor.cpp
index c569943..f47bfd0 100644
--- a/lldb/source/Symbol/SymbolVendor.cpp
+++ b/lldb/source/Symbol/SymbolVendor.cpp
@@ -23,7 +23,6 @@
 using namespace lldb;
 using namespace lldb_private;
 
-
 //----------------------------------------------------------------------
 // FindPlugin
 //
@@ -31,547 +30,455 @@ using namespace lldb_private;
 // vendors to allow for complex debug information file setups, and to
 // also allow for finding separate debug information files.
 //----------------------------------------------------------------------
-SymbolVendor*
-SymbolVendor::FindPlugin (const lldb::ModuleSP &module_sp, lldb_private::Stream *feedback_strm)
-{
-    std::unique_ptr<SymbolVendor> instance_ap;
-    SymbolVendorCreateInstance create_callback;
-
-    for (size_t idx = 0; (create_callback = PluginManager::GetSymbolVendorCreateCallbackAtIndex(idx)) != nullptr; ++idx)
-    {
-        instance_ap.reset(create_callback(module_sp, feedback_strm));
-
-        if (instance_ap.get())
-        {
-            return instance_ap.release();
-        }
-    }
-    // The default implementation just tries to create debug information using the
-    // file representation for the module.
-    instance_ap.reset(new SymbolVendor(module_sp));
-    if (instance_ap.get())
-    {
-        ObjectFile *objfile = module_sp->GetObjectFile();
-        if (objfile)
-            instance_ap->AddSymbolFileRepresentation(objfile->shared_from_this());
-    }
-    return instance_ap.release();
+SymbolVendor *SymbolVendor::FindPlugin(const lldb::ModuleSP &module_sp,
+                                       lldb_private::Stream *feedback_strm) {
+  std::unique_ptr<SymbolVendor> instance_ap;
+  SymbolVendorCreateInstance create_callback;
+
+  for (size_t idx = 0;
+       (create_callback = PluginManager::GetSymbolVendorCreateCallbackAtIndex(
+            idx)) != nullptr;
+       ++idx) {
+    instance_ap.reset(create_callback(module_sp, feedback_strm));
+
+    if (instance_ap.get()) {
+      return instance_ap.release();
+    }
+  }
+  // The default implementation just tries to create debug information using the
+  // file representation for the module.
+  instance_ap.reset(new SymbolVendor(module_sp));
+  if (instance_ap.get()) {
+    ObjectFile *objfile = module_sp->GetObjectFile();
+    if (objfile)
+      instance_ap->AddSymbolFileRepresentation(objfile->shared_from_this());
+  }
+  return instance_ap.release();
 }
 
 //----------------------------------------------------------------------
 // SymbolVendor constructor
 //----------------------------------------------------------------------
-SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp) :
-    ModuleChild (module_sp),
-    m_type_list(),
-    m_compile_units(),
-    m_sym_file_ap()
-{
-}
+SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp)
+    : ModuleChild(module_sp), m_type_list(), m_compile_units(),
+      m_sym_file_ap() {}
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
-SymbolVendor::~SymbolVendor()
-{
-}
+SymbolVendor::~SymbolVendor() {}
 
 //----------------------------------------------------------------------
 // Add a representation given an object file.
 //----------------------------------------------------------------------
-void
-SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (objfile_sp)
-        {
-            m_objfile_sp = objfile_sp;
-            m_sym_file_ap.reset(SymbolFile::FindPlugin(objfile_sp.get()));
-        }
-    }
+void SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (objfile_sp) {
+      m_objfile_sp = objfile_sp;
+      m_sym_file_ap.reset(SymbolFile::FindPlugin(objfile_sp.get()));
+    }
+  }
+}
+
+bool SymbolVendor::SetCompileUnitAtIndex(size_t idx, const CompUnitSP &cu_sp) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    const size_t num_compile_units = GetNumCompileUnits();
+    if (idx < num_compile_units) {
+      // Fire off an assertion if this compile unit already exists for now.
+      // The partial parsing should take care of only setting the compile
+      // unit once, so if this assertion fails, we need to make sure that
+      // we don't have a race condition, or have a second parse of the same
+      // compile unit.
+      assert(m_compile_units[idx].get() == nullptr);
+      m_compile_units[idx] = cu_sp;
+      return true;
+    } else {
+      // This should NOT happen, and if it does, we want to crash and know
+      // about it
+      assert(idx < num_compile_units);
+    }
+  }
+  return false;
+}
+
+size_t SymbolVendor::GetNumCompileUnits() {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_compile_units.empty()) {
+      if (m_sym_file_ap.get()) {
+        // Resize our array of compile unit shared pointers -- which will
+        // each remain NULL until someone asks for the actual compile unit
+        // information. When this happens, the symbol file will be asked
+        // to parse this compile unit information.
+        m_compile_units.resize(m_sym_file_ap->GetNumCompileUnits());
+      }
+    }
+  }
+  return m_compile_units.size();
 }
 
-bool
-SymbolVendor::SetCompileUnitAtIndex (size_t idx, const CompUnitSP &cu_sp)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        const size_t num_compile_units = GetNumCompileUnits();
-        if (idx < num_compile_units)
-        {
-            // Fire off an assertion if this compile unit already exists for now.
-            // The partial parsing should take care of only setting the compile
-            // unit once, so if this assertion fails, we need to make sure that
-            // we don't have a race condition, or have a second parse of the same
-            // compile unit.
-            assert(m_compile_units[idx].get() == nullptr);
-            m_compile_units[idx] = cu_sp;
-            return true;
-        }
-        else
-        {
-            // This should NOT happen, and if it does, we want to crash and know
-            // about it
-            assert (idx < num_compile_units);
-        }
-    }
-    return false;
-}
-
-size_t
-SymbolVendor::GetNumCompileUnits()
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_compile_units.empty())
-        {
-            if (m_sym_file_ap.get())
-            {
-                // Resize our array of compile unit shared pointers -- which will
-                // each remain NULL until someone asks for the actual compile unit
-                // information. When this happens, the symbol file will be asked
-                // to parse this compile unit information.
-                m_compile_units.resize(m_sym_file_ap->GetNumCompileUnits());
-            }
-        }
-    }
-    return m_compile_units.size();
+lldb::LanguageType
+SymbolVendor::ParseCompileUnitLanguage(const SymbolContext &sc) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseCompileUnitLanguage(sc);
+  }
+  return eLanguageTypeUnknown;
 }
 
-lldb::LanguageType
-SymbolVendor::ParseCompileUnitLanguage (const SymbolContext& sc)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseCompileUnitLanguage(sc);
-    }
-    return eLanguageTypeUnknown;
+size_t SymbolVendor::ParseCompileUnitFunctions(const SymbolContext &sc) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseCompileUnitFunctions(sc);
+  }
+  return 0;
 }
 
+bool SymbolVendor::ParseCompileUnitLineTable(const SymbolContext &sc) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseCompileUnitLineTable(sc);
+  }
+  return false;
+}
 
-size_t
-SymbolVendor::ParseCompileUnitFunctions (const SymbolContext &sc)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseCompileUnitFunctions(sc);
-    }
-    return 0;
-}
-
-bool
-SymbolVendor::ParseCompileUnitLineTable (const SymbolContext &sc)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseCompileUnitLineTable(sc);
-    }
-    return false;
-}
-
-bool
-SymbolVendor::ParseCompileUnitDebugMacros (const SymbolContext &sc)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseCompileUnitDebugMacros(sc);
-    }
-    return false;
-}
-bool
-SymbolVendor::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseCompileUnitSupportFiles(sc, support_files);
-    }
-    return false;
-}
-
-bool
-SymbolVendor::ParseCompileUnitIsOptimized(const SymbolContext &sc)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseCompileUnitIsOptimized(sc);
-    }
-    return false;
-}
-
-bool
-SymbolVendor::ParseImportedModules(const SymbolContext &sc, std::vector<ConstString> &imported_modules)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseImportedModules(sc, imported_modules);
-    }
-    return false;
-    
-}
-
-size_t
-SymbolVendor::ParseFunctionBlocks (const SymbolContext &sc)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseFunctionBlocks(sc);
-    }
-    return 0;
-}
-
-size_t
-SymbolVendor::ParseTypes (const SymbolContext &sc)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseTypes(sc);
-    }
-    return 0;
-}
-
-size_t
-SymbolVendor::ParseVariablesForContext (const SymbolContext& sc)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ParseVariablesForContext(sc);
-    }
-    return 0;
-}
-
-Type*
-SymbolVendor::ResolveTypeUID(lldb::user_id_t type_uid)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ResolveTypeUID(type_uid);
-    }
-    return nullptr;
+bool SymbolVendor::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseCompileUnitDebugMacros(sc);
+  }
+  return false;
+}
+bool SymbolVendor::ParseCompileUnitSupportFiles(const SymbolContext &sc,
+                                                FileSpecList &support_files) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseCompileUnitSupportFiles(sc, support_files);
+  }
+  return false;
 }
 
+bool SymbolVendor::ParseCompileUnitIsOptimized(const SymbolContext &sc) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseCompileUnitIsOptimized(sc);
+  }
+  return false;
+}
 
-uint32_t
-SymbolVendor::ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ResolveSymbolContext(so_addr, resolve_scope, sc);
-    }
-    return 0;
-}
-
-uint32_t
-SymbolVendor::ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, sc_list);
-    }
-    return 0;
-}
-
-size_t
-SymbolVendor::FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches, VariableList& variables)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->FindGlobalVariables(name, parent_decl_ctx, append, max_matches, variables);
-    }
-    return 0;
-}
-
-size_t
-SymbolVendor::FindGlobalVariables (const RegularExpression& regex, bool append, size_t max_matches, VariableList& variables)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->FindGlobalVariables(regex, append, max_matches, variables);
-    }
-    return 0;
-}
-
-size_t
-SymbolVendor::FindFunctions(const ConstString &name, const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->FindFunctions(name, parent_decl_ctx, name_type_mask, include_inlines, append, sc_list);
-    }
-    return 0;
-}
-
-size_t
-SymbolVendor::FindFunctions(const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->FindFunctions(regex, include_inlines, append, sc_list);
-    }
-    return 0;
+bool SymbolVendor::ParseImportedModules(
+    const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseImportedModules(sc, imported_modules);
+  }
+  return false;
 }
 
+size_t SymbolVendor::ParseFunctionBlocks(const SymbolContext &sc) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseFunctionBlocks(sc);
+  }
+  return 0;
+}
 
-size_t
-SymbolVendor::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, TypeMap& types)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->FindTypes(sc, name, parent_decl_ctx, append, max_matches, searched_symbol_files, types);
-    }
-    if (!append)
-        types.Clear();
-    return 0;
-}
-
-size_t
-SymbolVendor::FindTypes (const std::vector<CompilerContext> &context, bool append, TypeMap& types)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->FindTypes(context, append, types);
-    }
-    if (!append)
-        types.Clear();
-    return 0;
-}
-
-size_t
-SymbolVendor::GetTypes (SymbolContextScope *sc_scope,
-                        uint32_t type_mask,
-                        lldb_private::TypeList &type_list)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            return m_sym_file_ap->GetTypes (sc_scope, type_mask, type_list);
-    }
-    return 0;
+size_t SymbolVendor::ParseTypes(const SymbolContext &sc) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseTypes(sc);
+  }
+  return 0;
+}
+
+size_t SymbolVendor::ParseVariablesForContext(const SymbolContext &sc) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ParseVariablesForContext(sc);
+  }
+  return 0;
+}
+
+Type *SymbolVendor::ResolveTypeUID(lldb::user_id_t type_uid) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ResolveTypeUID(type_uid);
+  }
+  return nullptr;
+}
+
+uint32_t SymbolVendor::ResolveSymbolContext(const Address &so_addr,
+                                            uint32_t resolve_scope,
+                                            SymbolContext &sc) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ResolveSymbolContext(so_addr, resolve_scope, sc);
+  }
+  return 0;
+}
+
+uint32_t SymbolVendor::ResolveSymbolContext(const FileSpec &file_spec,
+                                            uint32_t line, bool check_inlines,
+                                            uint32_t resolve_scope,
+                                            SymbolContextList &sc_list) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->ResolveSymbolContext(file_spec, line, check_inlines,
+                                                 resolve_scope, sc_list);
+  }
+  return 0;
+}
+
+size_t SymbolVendor::FindGlobalVariables(
+    const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+    bool append, size_t max_matches, VariableList &variables) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->FindGlobalVariables(name, parent_decl_ctx, append,
+                                                max_matches, variables);
+  }
+  return 0;
+}
+
+size_t SymbolVendor::FindGlobalVariables(const RegularExpression &regex,
+                                         bool append, size_t max_matches,
+                                         VariableList &variables) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->FindGlobalVariables(regex, append, max_matches,
+                                                variables);
+  }
+  return 0;
+}
+
+size_t SymbolVendor::FindFunctions(const ConstString &name,
+                                   const CompilerDeclContext *parent_decl_ctx,
+                                   uint32_t name_type_mask,
+                                   bool include_inlines, bool append,
+                                   SymbolContextList &sc_list) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->FindFunctions(name, parent_decl_ctx, name_type_mask,
+                                          include_inlines, append, sc_list);
+  }
+  return 0;
+}
+
+size_t SymbolVendor::FindFunctions(const RegularExpression &regex,
+                                   bool include_inlines, bool append,
+                                   SymbolContextList &sc_list) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->FindFunctions(regex, include_inlines, append,
+                                          sc_list);
+  }
+  return 0;
+}
+
+size_t SymbolVendor::FindTypes(
+    const SymbolContext &sc, const ConstString &name,
+    const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches,
+    llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
+    TypeMap &types) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->FindTypes(sc, name, parent_decl_ctx, append,
+                                      max_matches, searched_symbol_files,
+                                      types);
+  }
+  if (!append)
+    types.Clear();
+  return 0;
+}
+
+size_t SymbolVendor::FindTypes(const std::vector<CompilerContext> &context,
+                               bool append, TypeMap &types) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->FindTypes(context, append, types);
+  }
+  if (!append)
+    types.Clear();
+  return 0;
+}
+
+size_t SymbolVendor::GetTypes(SymbolContextScope *sc_scope, uint32_t type_mask,
+                              lldb_private::TypeList &type_list) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      return m_sym_file_ap->GetTypes(sc_scope, type_mask, type_list);
+  }
+  return 0;
 }
 
 CompilerDeclContext
-SymbolVendor::FindNamespace(const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx)
-{
-    CompilerDeclContext namespace_decl_ctx;
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        if (m_sym_file_ap.get())
-            namespace_decl_ctx = m_sym_file_ap->FindNamespace (sc, name, parent_decl_ctx);
-    }
-    return namespace_decl_ctx;
-}
-
-void
-SymbolVendor::Dump(Stream *s)
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-
-        bool show_context = false;
-
-        s->Printf("%p: ", static_cast<void*>(this));
-        s->Indent();
-        s->PutCString("SymbolVendor");
-        if (m_sym_file_ap.get())
-        {
-            ObjectFile *objfile = m_sym_file_ap->GetObjectFile();
-            if (objfile)
-            {
-                const FileSpec &objfile_file_spec = objfile->GetFileSpec();
-                if (objfile_file_spec)
-                {
-                    s->PutCString(" (");
-                    objfile_file_spec.Dump(s);
-                    s->PutChar(')');
-                }
-            }
-        }
-        s->EOL();
-        s->IndentMore();
-        m_type_list.Dump(s, show_context);
-
-        CompileUnitConstIter cu_pos, cu_end;
-        cu_end = m_compile_units.end();
-        for (cu_pos = m_compile_units.begin(); cu_pos != cu_end; ++cu_pos)
-        {
-            // We currently only dump the compile units that have been parsed
-            if (cu_pos->get())
-                (*cu_pos)->Dump(s, show_context);
+SymbolVendor::FindNamespace(const SymbolContext &sc, const ConstString &name,
+                            const CompilerDeclContext *parent_decl_ctx) {
+  CompilerDeclContext namespace_decl_ctx;
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    if (m_sym_file_ap.get())
+      namespace_decl_ctx =
+          m_sym_file_ap->FindNamespace(sc, name, parent_decl_ctx);
+  }
+  return namespace_decl_ctx;
+}
+
+void SymbolVendor::Dump(Stream *s) {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+
+    bool show_context = false;
+
+    s->Printf("%p: ", static_cast<void *>(this));
+    s->Indent();
+    s->PutCString("SymbolVendor");
+    if (m_sym_file_ap.get()) {
+      ObjectFile *objfile = m_sym_file_ap->GetObjectFile();
+      if (objfile) {
+        const FileSpec &objfile_file_spec = objfile->GetFileSpec();
+        if (objfile_file_spec) {
+          s->PutCString(" (");
+          objfile_file_spec.Dump(s);
+          s->PutChar(')');
         }
+      }
+    }
+    s->EOL();
+    s->IndentMore();
+    m_type_list.Dump(s, show_context);
 
-        s->IndentLess();
+    CompileUnitConstIter cu_pos, cu_end;
+    cu_end = m_compile_units.end();
+    for (cu_pos = m_compile_units.begin(); cu_pos != cu_end; ++cu_pos) {
+      // We currently only dump the compile units that have been parsed
+      if (cu_pos->get())
+        (*cu_pos)->Dump(s, show_context);
     }
+
+    s->IndentLess();
+  }
 }
 
-CompUnitSP
-SymbolVendor::GetCompileUnitAtIndex(size_t idx)
-{
-    CompUnitSP cu_sp;
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        const size_t num_compile_units = GetNumCompileUnits();
-        if (idx < num_compile_units)
-        {
-            cu_sp = m_compile_units[idx];
-            if (cu_sp.get() == nullptr)
-            {
-                m_compile_units[idx] = m_sym_file_ap->ParseCompileUnitAtIndex(idx);
-                cu_sp = m_compile_units[idx];
-            }
-        }
+CompUnitSP SymbolVendor::GetCompileUnitAtIndex(size_t idx) {
+  CompUnitSP cu_sp;
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+    const size_t num_compile_units = GetNumCompileUnits();
+    if (idx < num_compile_units) {
+      cu_sp = m_compile_units[idx];
+      if (cu_sp.get() == nullptr) {
+        m_compile_units[idx] = m_sym_file_ap->ParseCompileUnitAtIndex(idx);
+        cu_sp = m_compile_units[idx];
+      }
     }
-    return cu_sp;
+  }
+  return cu_sp;
 }
 
-FileSpec
-SymbolVendor::GetMainFileSpec() const
-{
-    if (m_sym_file_ap.get())
-    {
-        const ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile();
-        if (symfile_objfile)
-            return symfile_objfile->GetFileSpec();
-    }
+FileSpec SymbolVendor::GetMainFileSpec() const {
+  if (m_sym_file_ap.get()) {
+    const ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile();
+    if (symfile_objfile)
+      return symfile_objfile->GetFileSpec();
+  }
 
-    return FileSpec();
+  return FileSpec();
 }
 
-Symtab *
-SymbolVendor::GetSymtab ()
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        ObjectFile *objfile = module_sp->GetObjectFile();
-        if (objfile)
-        {
-            // Get symbol table from unified section list.
-            return objfile->GetSymtab ();
-        }
+Symtab *SymbolVendor::GetSymtab() {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    ObjectFile *objfile = module_sp->GetObjectFile();
+    if (objfile) {
+      // Get symbol table from unified section list.
+      return objfile->GetSymtab();
     }
-    return nullptr;
-}
-
-void
-SymbolVendor::ClearSymtab()
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        ObjectFile *objfile = module_sp->GetObjectFile();
-        if (objfile)
-        {
-            // Clear symbol table from unified section list.
-            objfile->ClearSymtab ();
-        }
+  }
+  return nullptr;
+}
+
+void SymbolVendor::ClearSymtab() {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    ObjectFile *objfile = module_sp->GetObjectFile();
+    if (objfile) {
+      // Clear symbol table from unified section list.
+      objfile->ClearSymtab();
     }
+  }
 }
 
-void
-SymbolVendor::SectionFileAddressesChanged ()
-{
-    ModuleSP module_sp(GetModule());
-    if (module_sp)
-    {
-        ObjectFile *module_objfile = module_sp->GetObjectFile ();
-        if (m_sym_file_ap.get())
-        {
-            ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile ();
-            if (symfile_objfile != module_objfile)
-                symfile_objfile->SectionFileAddressesChanged ();
-        }
-        Symtab *symtab = GetSymtab ();
-        if (symtab)
-        {
-            symtab->SectionFileAddressesChanged ();
-        }
+void SymbolVendor::SectionFileAddressesChanged() {
+  ModuleSP module_sp(GetModule());
+  if (module_sp) {
+    ObjectFile *module_objfile = module_sp->GetObjectFile();
+    if (m_sym_file_ap.get()) {
+      ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile();
+      if (symfile_objfile != module_objfile)
+        symfile_objfile->SectionFileAddressesChanged();
+    }
+    Symtab *symtab = GetSymtab();
+    if (symtab) {
+      symtab->SectionFileAddressesChanged();
     }
+  }
 }
 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
-lldb_private::ConstString
-SymbolVendor::GetPluginName()
-{
-    static ConstString g_name("vendor-default");
-    return g_name;
-}
-
-uint32_t
-SymbolVendor::GetPluginVersion()
-{
-    return 1;
+lldb_private::ConstString SymbolVendor::GetPluginName() {
+  static ConstString g_name("vendor-default");
+  return g_name;
 }
 
+uint32_t SymbolVendor::GetPluginVersion() { return 1; }