1 files changed, 85 insertions, 89 deletions

diff --git a/source/Symbol/SymbolVendor.cpp b/source/Symbol/SymbolVendor.cpp
index a9badc15a5d6..b9f3a5fe3926 100644
--- a/source/Symbol/SymbolVendor.cpp
+++ b/source/Symbol/SymbolVendor.cpp
@@ -1,9 +1,8 @@
 //===-- SymbolVendor.cpp ----------------------------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
@@ -19,61 +18,60 @@
 using namespace lldb;
 using namespace lldb_private;
 
-//----------------------------------------------------------------------
 // FindPlugin
 //
 // Platforms can register a callback to use when creating symbol 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;
+  std::unique_ptr<SymbolVendor> instance_up;
   SymbolVendorCreateInstance create_callback;
 
   for (size_t idx = 0;
        (create_callback = PluginManager::GetSymbolVendorCreateCallbackAtIndex(
             idx)) != nullptr;
        ++idx) {
-    instance_ap.reset(create_callback(module_sp, feedback_strm));
+    instance_up.reset(create_callback(module_sp, feedback_strm));
 
-    if (instance_ap.get()) {
-      return instance_ap.release();
+    if (instance_up) {
+      return instance_up.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());
+  ObjectFileSP sym_objfile_sp;
+  FileSpec sym_spec = module_sp->GetSymbolFileFileSpec();
+  if (sym_spec && sym_spec != module_sp->GetObjectFile()->GetFileSpec()) {
+    DataBufferSP data_sp;
+    offset_t data_offset = 0;
+    sym_objfile_sp = ObjectFile::FindPlugin(
+        module_sp, &sym_spec, 0, FileSystem::Instance().GetByteSize(sym_spec),
+        data_sp, data_offset);
   }
-  return instance_ap.release();
+  if (!sym_objfile_sp)
+    sym_objfile_sp = module_sp->GetObjectFile()->shared_from_this();
+  instance_up.reset(new SymbolVendor(module_sp));
+  instance_up->AddSymbolFileRepresentation(sym_objfile_sp);
+  return instance_up.release();
 }
 
-//----------------------------------------------------------------------
 // SymbolVendor constructor
-//----------------------------------------------------------------------
 SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp)
-    : ModuleChild(module_sp), m_type_list(), m_compile_units(),
-      m_sym_file_ap(), m_symtab() {}
+    : ModuleChild(module_sp), m_type_list(), m_compile_units(), m_sym_file_up(),
+      m_symtab() {}
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 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()));
+      m_sym_file_up.reset(SymbolFile::FindPlugin(objfile_sp.get()));
     }
   }
 }
@@ -106,12 +104,12 @@ size_t SymbolVendor::GetNumCompileUnits() {
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_compile_units.empty()) {
-      if (m_sym_file_ap.get()) {
+      if (m_sym_file_up) {
         // 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());
+        m_compile_units.resize(m_sym_file_up->GetNumCompileUnits());
       }
     }
   }
@@ -122,8 +120,8 @@ lldb::LanguageType SymbolVendor::ParseLanguage(CompileUnit &comp_unit) {
   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->ParseLanguage(comp_unit);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseLanguage(comp_unit);
   }
   return eLanguageTypeUnknown;
 }
@@ -132,8 +130,8 @@ size_t SymbolVendor::ParseFunctions(CompileUnit &comp_unit) {
   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->ParseFunctions(comp_unit);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseFunctions(comp_unit);
   }
   return 0;
 }
@@ -142,8 +140,8 @@ bool SymbolVendor::ParseLineTable(CompileUnit &comp_unit) {
   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->ParseLineTable(comp_unit);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseLineTable(comp_unit);
   }
   return false;
 }
@@ -152,8 +150,8 @@ bool SymbolVendor::ParseDebugMacros(CompileUnit &comp_unit) {
   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->ParseDebugMacros(comp_unit);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseDebugMacros(comp_unit);
   }
   return false;
 }
@@ -162,8 +160,8 @@ bool SymbolVendor::ParseSupportFiles(CompileUnit &comp_unit,
   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->ParseSupportFiles(comp_unit, support_files);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseSupportFiles(comp_unit, support_files);
   }
   return false;
 }
@@ -172,19 +170,19 @@ bool SymbolVendor::ParseIsOptimized(CompileUnit &comp_unit) {
   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->ParseIsOptimized(comp_unit);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseIsOptimized(comp_unit);
   }
   return false;
 }
 
 bool SymbolVendor::ParseImportedModules(
-    const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
+    const SymbolContext &sc, std::vector<SourceModule> &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);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseImportedModules(sc, imported_modules);
   }
   return false;
 }
@@ -193,8 +191,8 @@ size_t SymbolVendor::ParseBlocksRecursive(Function &func) {
   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->ParseBlocksRecursive(func);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseBlocksRecursive(func);
   }
   return 0;
 }
@@ -203,8 +201,8 @@ size_t SymbolVendor::ParseTypes(CompileUnit &comp_unit) {
   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(comp_unit);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseTypes(comp_unit);
   }
   return 0;
 }
@@ -213,8 +211,8 @@ 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);
+    if (m_sym_file_up)
+      return m_sym_file_up->ParseVariablesForContext(sc);
   }
   return 0;
 }
@@ -223,8 +221,8 @@ 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);
+    if (m_sym_file_up)
+      return m_sym_file_up->ResolveTypeUID(type_uid);
   }
   return nullptr;
 }
@@ -235,8 +233,8 @@ uint32_t SymbolVendor::ResolveSymbolContext(const Address &so_addr,
   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);
+    if (m_sym_file_up)
+      return m_sym_file_up->ResolveSymbolContext(so_addr, resolve_scope, sc);
   }
   return 0;
 }
@@ -248,22 +246,22 @@ uint32_t SymbolVendor::ResolveSymbolContext(const FileSpec &file_spec,
   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,
+    if (m_sym_file_up)
+      return m_sym_file_up->ResolveSymbolContext(file_spec, line, check_inlines,
                                                  resolve_scope, sc_list);
   }
   return 0;
 }
 
 size_t
-SymbolVendor::FindGlobalVariables(const ConstString &name,
+SymbolVendor::FindGlobalVariables(ConstString name,
                                   const CompilerDeclContext *parent_decl_ctx,
                                   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,
+    if (m_sym_file_up)
+      return m_sym_file_up->FindGlobalVariables(name, parent_decl_ctx,
                                                 max_matches, variables);
   }
   return 0;
@@ -275,13 +273,13 @@ size_t SymbolVendor::FindGlobalVariables(const RegularExpression &regex,
   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, max_matches, variables);
+    if (m_sym_file_up)
+      return m_sym_file_up->FindGlobalVariables(regex, max_matches, variables);
   }
   return 0;
 }
 
-size_t SymbolVendor::FindFunctions(const ConstString &name,
+size_t SymbolVendor::FindFunctions(ConstString name,
                                    const CompilerDeclContext *parent_decl_ctx,
                                    FunctionNameType name_type_mask,
                                    bool include_inlines, bool append,
@@ -289,8 +287,8 @@ size_t SymbolVendor::FindFunctions(const ConstString &name,
   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,
+    if (m_sym_file_up)
+      return m_sym_file_up->FindFunctions(name, parent_decl_ctx, name_type_mask,
                                           include_inlines, append, sc_list);
   }
   return 0;
@@ -302,23 +300,23 @@ size_t SymbolVendor::FindFunctions(const RegularExpression &regex,
   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,
+    if (m_sym_file_up)
+      return m_sym_file_up->FindFunctions(regex, include_inlines, append,
                                           sc_list);
   }
   return 0;
 }
 
 size_t SymbolVendor::FindTypes(
-    const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+    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(name, parent_decl_ctx, append,
+    if (m_sym_file_up)
+      return m_sym_file_up->FindTypes(name, parent_decl_ctx, append,
                                       max_matches, searched_symbol_files,
                                       types);
   }
@@ -332,8 +330,8 @@ size_t SymbolVendor::FindTypes(const std::vector<CompilerContext> &context,
   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 (m_sym_file_up)
+      return m_sym_file_up->FindTypes(context, append, types);
   }
   if (!append)
     types.Clear();
@@ -345,21 +343,21 @@ size_t SymbolVendor::GetTypes(SymbolContextScope *sc_scope, TypeClass type_mask,
   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);
+    if (m_sym_file_up)
+      return m_sym_file_up->GetTypes(sc_scope, type_mask, type_list);
   }
   return 0;
 }
 
 CompilerDeclContext
-SymbolVendor::FindNamespace(const ConstString &name,
+SymbolVendor::FindNamespace(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(name, parent_decl_ctx);
+    if (m_sym_file_up)
+      namespace_decl_ctx = m_sym_file_up->FindNamespace(name, parent_decl_ctx);
   }
   return namespace_decl_ctx;
 }
@@ -374,9 +372,9 @@ void SymbolVendor::Dump(Stream *s) {
     s->Printf("%p: ", static_cast<void *>(this));
     s->Indent();
     s->PutCString("SymbolVendor");
-    if (m_sym_file_ap.get()) {
-      *s << " " << m_sym_file_ap->GetPluginName();
-      ObjectFile *objfile = m_sym_file_ap->GetObjectFile();
+    if (m_sym_file_up) {
+      *s << " " << m_sym_file_up->GetPluginName();
+      ObjectFile *objfile = m_sym_file_up->GetObjectFile();
       if (objfile) {
         const FileSpec &objfile_file_spec = objfile->GetFileSpec();
         if (objfile_file_spec) {
@@ -387,8 +385,8 @@ void SymbolVendor::Dump(Stream *s) {
       }
     }
     s->EOL();
-    if (m_sym_file_ap)
-      m_sym_file_ap->Dump(*s);
+    if (m_sym_file_up)
+      m_sym_file_up->Dump(*s);
     s->IndentMore();
     m_type_list.Dump(s, show_context);
 
@@ -396,7 +394,7 @@ void SymbolVendor::Dump(Stream *s) {
     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())
+      if (*cu_pos)
         (*cu_pos)->Dump(s, show_context);
     }
 
@@ -416,7 +414,7 @@ CompUnitSP SymbolVendor::GetCompileUnitAtIndex(size_t idx) {
     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);
+        m_compile_units[idx] = m_sym_file_up->ParseCompileUnitAtIndex(idx);
         cu_sp = m_compile_units[idx];
       }
     }
@@ -425,8 +423,8 @@ CompUnitSP SymbolVendor::GetCompileUnitAtIndex(size_t idx) {
 }
 
 FileSpec SymbolVendor::GetMainFileSpec() const {
-  if (m_sym_file_ap.get()) {
-    const ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile();
+  if (m_sym_file_up) {
+    const ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile();
     if (symfile_objfile)
       return symfile_objfile->GetFileSpec();
   }
@@ -449,8 +447,8 @@ Symtab *SymbolVendor::GetSymtab() {
     return nullptr;
 
   m_symtab = objfile->GetSymtab();
-  if (m_symtab && m_sym_file_ap)
-    m_sym_file_ap->AddSymbols(*m_symtab);
+  if (m_symtab && m_sym_file_up)
+    m_sym_file_up->AddSymbols(*m_symtab);
 
   return m_symtab;
 }
@@ -470,8 +468,8 @@ 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 (m_sym_file_up) {
+      ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile();
       if (symfile_objfile != module_objfile)
         symfile_objfile->SectionFileAddressesChanged();
     }
@@ -482,9 +480,7 @@ void SymbolVendor::SectionFileAddressesChanged() {
   }
 }
 
-//------------------------------------------------------------------
 // PluginInterface protocol
-//------------------------------------------------------------------
 lldb_private::ConstString SymbolVendor::GetPluginName() {
   static ConstString g_name("vendor-default");
   return g_name;