Fix issues with separate symbolfile handling

[tberghammer]

Summary

Fix issues with separate symbol file handling

[clayborg]

Looks fine.

lldb/trunk/source/Core/Module.cpp

if (m_symfile_ap)
             {
                 // Check to make sure we aren't trying to specify the file we already have
                 if (obj_file->GetFileSpec() == file)
                 {
                     // We are being told to add the exact same file that we already have
                     // we don't have to do anything.
                     return;
                 }
                 
+                // Cleare the current symtab as we are going to replace it with a new one
+                obj_file->ClearSymtab();
+
                 // The symbol file might be a directory bundle ("/tmp/a.out.dSYM") instead
                 // of a full path to the symbol file within the bundle
                 // ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to check this
 
                 if (file.IsDirectory())
                 {
                     std::string new_path(file.GetPath());
                     std::string old_path(obj_file->GetFileSpec().GetPath());

lldb/trunk/source/Host/common/Symbols.cpp

LocateExecutableSymbolFileDsym (const ModuleSpec &module_spec)
     const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
     const ArchSpec *arch = module_spec.GetArchitecturePtr();
     const UUID *uuid = module_spec.GetUUIDPtr();
 
     Timer scoped_timer (__PRETTY_FUNCTION__,
                         "LocateExecutableSymbolFileDsym (file = %s, arch = %s, uuid = %p)",
                         exec_fspec ? exec_fspec->GetFilename().AsCString ("<NULL>") : "<NULL>",
                         arch ? arch->GetArchitectureName() : "<NULL>",
-                        (void*)uuid);
+                        (const void*)uuid);
 
     FileSpec symbol_fspec;
     // First try and find the dSYM in the same directory as the executable or in
     // an appropriate parent directory
     if (LocateDSYMInVincinityOfExecutable (module_spec, symbol_fspec) == false)
     {
         // We failed to easily find the dSYM above, so use DebugSymbols
         LocateMacOSXFilesUsingDebugSymbols (module_spec, NULL, &symbol_fspec);
     }
     return symbol_fspec;
 }
 
 FileSpec
 Symbols::LocateExecutableObjectFile (const ModuleSpec &module_spec)
 {
     const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
     const ArchSpec *arch = module_spec.GetArchitecturePtr();
     const UUID *uuid = module_spec.GetUUIDPtr();
     Timer scoped_timer (__PRETTY_FUNCTION__,
                         "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)",
                         exec_fspec ? exec_fspec->GetFilename().AsCString ("<NULL>") : "<NULL>",
                         arch ? arch->GetArchitectureName() : "<NULL>",
-                        (void*)uuid);
+                        (const void*)uuid);
 
     FileSpec objfile_fspec;
     ModuleSpecList module_specs;
     ModuleSpec matched_module_spec;
     if (exec_fspec &&
         ObjectFile::GetModuleSpecifications(*exec_fspec, 0, 0, module_specs) &&
         module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
     {
         objfile_fspec = exec_fspec;
     }
     else
     {
         LocateMacOSXFilesUsingDebugSymbols (module_spec, &objfile_fspec, NULL);
     }
     return objfile_fspec;
 }
 
 FileSpec
 Symbols::LocateExecutableSymbolFile (const ModuleSpec &module_spec)
 {
-    const char *symbol_filename = module_spec.GetSymbolFileSpec().GetFilename().AsCString();
+    FileSpec symbol_file_spec = module_spec.GetSymbolFileSpec();
+    if (symbol_file_spec.IsAbsolute() && symbol_file_spec.Exists())
+        return symbol_file_spec;
+
+    const char *symbol_filename = symbol_file_spec.GetFilename().AsCString();
     if (symbol_filename && symbol_filename[0])
     {
         FileSpecList debug_file_search_paths (Target::GetDefaultDebugFileSearchPaths());
 
         // Add module directory.
         const ConstString &file_dir = module_spec.GetFileSpec().GetDirectory();
         debug_file_search_paths.AppendIfUnique (FileSpec(file_dir.AsCString("."), true));
 

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 }
 
 // Top 16 bits of the `Symbol` flags are available.
 #define ARM_ELF_SYM_IS_THUMB    (1 << 16)
 
 AddressClass
 ObjectFileELF::GetAddressClass (addr_t file_addr)
 {
-    auto res = ObjectFile::GetAddressClass (file_addr);
+    Symtab* symtab = GetSymtab();
+    if (!symtab)
+        return eAddressClassUnknown;
+
+    // The address class is determined based on the symtab. Ask it from the object file what
+    // contains the symtab information.
+    ObjectFile* symtab_objfile = symtab->GetObjectFile();
+    if (symtab_objfile != nullptr && symtab_objfile != this)
+        return symtab_objfile->GetAddressClass(file_addr);
 
+    auto res = ObjectFile::GetAddressClass (file_addr);
     if (res != eAddressClassCode)
         return res;
 
     auto ub = m_address_class_map.upper_bound(file_addr);
     if (ub == m_address_class_map.begin())
     {
         // No entry in the address class map before the address. Return
         // default address class for an address in a code section.
for (i = 0; i < num_symbols; ++i)
                             m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA;
                         }
                         else if (symbol_name_ref == "$d" || symbol_name_ref.startswith("$d."))
                         {
                             // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
                             m_address_class_map[symbol.st_value] = eAddressClassData;
                         }
                     }
-
                     continue;
                 }
             }
             else if (arch.GetMachine() == llvm::Triple::aarch64)
             {
                 if (symbol.getBinding() == STB_LOCAL && symbol_name && symbol_name[0] == '$')
                 {
                     // These are reserved for the specification (e.g.: mapping
for (i = 0; i < num_symbols; ++i)
                     {
                         // This address is ARM
                         m_address_class_map[symbol.st_value] = eAddressClassCode;
                     }
                 }
             }
         }
 
-        // If the symbol section we've found has no data (SHT_NOBITS), then check the module section
-        // list. This can happen if we're parsing the debug file and it has no .text section, for example.
-        if (symbol_section_sp && (symbol_section_sp->GetFileSize() == 0))
+        // symbol_value_offset may contain 0 for ARM symbols or -1 for
+        // THUMB symbols. See above for more details.
+        uint64_t symbol_value = symbol.st_value + symbol_value_offset;
+        if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile)
+            symbol_value -= symbol_section_sp->GetFileAddress();
+
+        if (symbol_section_sp)
         {
             ModuleSP module_sp(GetModule());
             if (module_sp)
             {
                 SectionList *module_section_list = module_sp->GetSectionList();
                 if (module_section_list && module_section_list != section_list)
                 {
                     const ConstString &sect_name = symbol_section_sp->GetName();
                     lldb::SectionSP section_sp (module_section_list->FindSectionByName (sect_name));
                     if (section_sp && section_sp->GetFileSize())
                     {
                         symbol_section_sp = section_sp;
                     }
                 }
             }
         }
 
-        // symbol_value_offset may contain 0 for ARM symbols or -1 for
-        // THUMB symbols. See above for more details.
-        uint64_t symbol_value = symbol.st_value + symbol_value_offset;
-        if (symbol_section_sp && CalculateType() != ObjectFile::Type::eTypeObjectFile)
-            symbol_value -= symbol_section_sp->GetFileAddress();
         bool is_global = symbol.getBinding() == STB_GLOBAL;
         uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags;
         bool is_mangled = symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false;
 
         llvm::StringRef symbol_ref(symbol_name);
 
         // Symbol names may contain @VERSION suffixes. Find those and strip them temporarily.
         size_t version_pos = symbol_ref.find('@');
ObjectFileELF::GetSymtab()
     {
         SectionList *section_list = module_sp->GetSectionList();
         if (!section_list)
             return NULL;
 
         uint64_t symbol_id = 0;
         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
 
-        m_symtab_ap.reset(new Symtab(this));
-
         // Sharable objects and dynamic executables usually have 2 distinct symbol
         // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller
         // version of the symtab that only contains global symbols. The information found
         // in the dynsym is therefore also found in the symtab, while the reverse is not
         // necessarily true.
         Section *symtab = section_list->FindSectionByType (eSectionTypeELFSymbolTable, true).get();
         if (!symtab)
         {
             // The symtab section is non-allocable and can be stripped, so if it doesn't exist
             // then use the dynsym section which should always be there.
             symtab = section_list->FindSectionByType (eSectionTypeELFDynamicSymbols, true).get();
         }
         if (symtab)
+        {
+            m_symtab_ap.reset(new Symtab(symtab->GetObjectFile()));
             symbol_id += ParseSymbolTable (m_symtab_ap.get(), symbol_id, symtab);
+        }
 
         // DT_JMPREL
         //      If present, this entry's d_ptr member holds the address of relocation
         //      entries associated solely with the procedure linkage table. Separating
         //      these relocation entries lets the dynamic linker ignore them during
         //      process initialization, if lazy binding is enabled. If this entry is
         //      present, the related entries of types DT_PLTRELSZ and DT_PLTREL must
         //      also be present.
         const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL);
         if (symbol)
         {
             // Synthesize trampoline symbols to help navigate the PLT.
             addr_t addr = symbol->d_ptr;
             Section *reloc_section = section_list->FindSectionContainingFileAddress(addr).get();
             if (reloc_section) 
             {
                 user_id_t reloc_id = reloc_section->GetID();
                 const ELFSectionHeaderInfo *reloc_header = GetSectionHeaderByIndex(reloc_id);
                 assert(reloc_header);
                 
+                if (m_symtab_ap == nullptr)
+                    m_symtab_ap.reset(new Symtab(reloc_section->GetObjectFile()));
+
                 ParseTrampolineSymbols (m_symtab_ap.get(), symbol_id, reloc_header, reloc_id);
             }
         }
+        
+        // If we still don't have any symtab then create an empty instance to avoid do the section
+        // lookup next time.
+        if (m_symtab_ap == nullptr)
+            m_symtab_ap.reset(new Symtab(this));
+            
         m_symtab_ap->CalculateSymbolSizes();
     }
 
     for (SectionHeaderCollIter I = m_section_headers.begin();
          I != m_section_headers.end(); ++I)
     {
         if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL)
         {

lldb/trunk/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

if (m_obj_file)
             {
                 symtab->SortSymbolIndexesByValue(m_func_indexes, true);
                 abilities |= Functions;
             }
 
             if (symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugNo, Symtab::eVisibilityAny, m_code_indexes))
             {
                 symtab->SortSymbolIndexesByValue(m_code_indexes, true);
+                abilities |= Functions;
             }
 
             if (symtab->AppendSymbolIndexesWithType(eSymbolTypeData, m_data_indexes))
             {
                 symtab->SortSymbolIndexesByValue(m_data_indexes, true);
                 abilities |= GlobalVariables;
             }