Correctly resolve symbol names containing linker annotations

[labath]

Summary

Symbols in ELF files can be versioned, but LLDB currently does not understand these. This problem
becomes apparent once one loads glibc with debug info. Here (in the .symtab section) the versions
are embedded in the name (name@VERSION), which causes issues when evaluating expressions
referencing memcpy for example (current glibc contains memcpy@@GLIBC_2.14 and
memcpy@GLIBC_2.2.5).

This problem was not evident without debug symbols as the .dynsym section
stores the bare names and the actual versions are present in a separate section (.gnu.version_d),
which LLDB ignores. This resulted in two definitions of memcpy in the symbol table.

This patch adds support for storing annotated names to the Symbol class. If
Symbol.m_contains_linker_annotations is true then this symbol is annotated. Unannotated name can
be obtained by calling StripLinkerAnnotations on the corresponding ObjectFile. ObjectFileELF
implements this to strip @VERSION suffixes when requested. Symtab uses this function to add the
bare name as well as the annotated name to the name lookup table.

To preserve the size of the Symbol class, I had to steal one bit from the m_type field.

[clayborg]

Looks good. Stealing a bit from m_type is fine as long as all eSymbolType* enums can still fit.

lldb/trunk/include/lldb/Symbol/ObjectFile.h

public:
     MemoryMapSectionData (const Section *section, 
                           DataExtractor& section_data) const;
     
     bool
     IsInMemory () const
     {
         return m_memory_addr != LLDB_INVALID_ADDRESS;
     }
-    
+    // Strip linker annotations (such as @@VERSION) from symbol names.
+    virtual std::string
+    StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const
+    {
+        return symbol_name.str();
+    }
+    
 protected:
     //------------------------------------------------------------------
     // Member variables.
     //------------------------------------------------------------------
     FileSpec m_file;
     Type m_type;
     Strata m_strata;
     lldb::addr_t m_file_offset; ///< The offset in bytes into the file, or the address in memory

lldb/trunk/include/lldb/Symbol/Symbol.h

Symbol (uint32_t symID,
             bool external,
             bool is_debug,
             bool is_trampoline,
             bool is_artificial,
             const lldb::SectionSP &section_sp,
             lldb::addr_t value,
             lldb::addr_t size,
             bool size_is_valid,
+            bool contains_linker_annotations,
             uint32_t flags);
 
     Symbol (uint32_t symID,
-            const char *name,
-            bool name_is_mangled,
+            const Mangled &mangled,
             lldb::SymbolType type,
             bool external,
             bool is_debug,
             bool is_trampoline,
             bool is_artificial,
             const AddressRange &range,
             bool size_is_valid,
+            bool contains_linker_annotations,
             uint32_t flags);
 
     Symbol (const Symbol& rhs);
 
     const Symbol&
     operator= (const Symbol& rhs);
 
     void
GetDemangledNameIsSynthesized() const
         return m_demangled_is_synthesized;
     }
     void
     SetDemangledNameIsSynthesized(bool b)
     {
         m_demangled_is_synthesized = b;
     }
 
+    bool
+    ContainsLinkerAnnotations() const
+    {
+        return m_contains_linker_annotations;
+    }
+    void
+    SetContainsLinkerAnnotations(bool b)
+    {
+        m_contains_linker_annotations = b;
+    }
     //------------------------------------------------------------------
     /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
     ///
     /// @see SymbolContextScope
     //------------------------------------------------------------------
     virtual void
     CalculateSymbolContext (SymbolContext *sc);
 
protected:
     uint16_t        m_type_data_resolved:1, // True if the data in m_type_data has already been calculated
                     m_is_synthetic:1,       // non-zero if this symbol is not actually in the symbol table, but synthesized from other info in the object file.
                     m_is_debug:1,           // non-zero if this symbol is debug information in a symbol
                     m_is_external:1,        // non-zero if this symbol is globally visible
                     m_size_is_sibling:1,    // m_size contains the index of this symbol's sibling
                     m_size_is_synthesized:1,// non-zero if this symbol's size was calculated using a delta between this symbol and the next
                     m_size_is_valid:1,
                     m_demangled_is_synthesized:1, // The demangled name was created should not be used for expressions or other lookups
-                    m_type:8;
+                    m_contains_linker_annotations:1, // The symbol name contains linker annotations, which are optional when doing name lookups
+                    m_type:7;
     Mangled         m_mangled;              // uniqued symbol name/mangled name pair
     AddressRange    m_addr_range;           // Contains the value, or the section offset address when the value is an address in a section, and the size (if any)
     uint32_t        m_flags;                // A copy of the flags from the original symbol table, the ObjectFile plug-in can interpret these
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_Symbol_h_

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

public:
     // Returns the program header with the given index.
     const elf::ELFProgramHeader *
     GetProgramHeaderByIndex(lldb::user_id_t id);
 
     // Returns segment data for the given index.
     lldb_private::DataExtractor
     GetSegmentDataByIndex(lldb::user_id_t id);
 
+    std::string
+    StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const override;
+
 private:
     ObjectFileELF(const lldb::ModuleSP &module_sp,
                   lldb::DataBufferSP& data_sp,
                   lldb::offset_t data_offset,
                   const lldb_private::FileSpec* file,
                   lldb::offset_t offset,
                   lldb::offset_t length);
 

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

 ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id)
 {
     const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id);
     if (segment_header == NULL)
         return DataExtractor();
     return DataExtractor(m_data, segment_header->p_offset, segment_header->p_filesz);
 }
 
+std::string
+ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const
+{
+    size_t pos = symbol_name.find("@");
+    return symbol_name.substr(0, pos).str();
+}
+
 //----------------------------------------------------------------------
 // ParseSectionHeaders
 //----------------------------------------------------------------------
 size_t
 ObjectFileELF::ParseSectionHeaders()
 {
     return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec);
 }
for (i = 0; i < num_symbols; ++i)
         // 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('@');
+        bool has_suffix = version_pos != llvm::StringRef::npos;
+        llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
+        Mangled mangled(ConstString(symbol_bare), is_mangled);
+
+        // Now append the suffix back to mangled and unmangled names. Only do it if the
+        // demangling was sucessful (string is not empty).
+        if (has_suffix)
+        {
+            llvm::StringRef suffix = symbol_ref.substr(version_pos);
+
+            llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef();
+            if (! mangled_name.empty())
+                mangled.SetMangledName( ConstString((mangled_name + suffix).str()) );
+
+            llvm::StringRef demangled_name = mangled.GetDemangledName().GetStringRef();
+            if (! demangled_name.empty())
+                mangled.SetDemangledName( ConstString((demangled_name + suffix).str()) );
+        }
+
         Symbol dc_symbol(
             i + start_id,       // ID is the original symbol table index.
-            symbol_name,        // Symbol name.
-            is_mangled,         // Is the symbol name mangled?
+            mangled,
             symbol_type,        // Type of this symbol
             is_global,          // Is this globally visible?
             false,              // Is this symbol debug info?
             false,              // Is this symbol a trampoline?
             false,              // Is this symbol artificial?
+            AddressRange(
                 symbol_section_sp,  // Section in which this symbol is defined or null.
                 symbol_value,       // Offset in section or symbol value.
-            symbol.st_size,     // Size in bytes of this symbol.
+                symbol.st_size),    // Size in bytes of this symbol.
             true,               // Size is valid
+            has_suffix,         // Contains linker annotations?
             flags);             // Symbol flags.
         symtab->AddSymbol(dc_symbol);
     }
-
     return i;
 }
 
 unsigned
 ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, user_id_t start_id, lldb_private::Section *symtab)
 {
     if (symtab->GetObjectFile() != this)
     {
for (i = 0; i < num_relocations; ++i)
             false,           // Is this globally visible?
             false,           // Is this symbol debug info?
             true,            // Is this symbol a trampoline?
             true,            // Is this symbol artificial?
             plt_section_sp,  // Section in which this symbol is defined or null.
             plt_index,       // Offset in section or symbol value.
             plt_entsize,     // Size in bytes of this symbol.
             true,            // Size is valid
+            false,           // Contains linker annotations?
             0);              // Symbol flags.
 
         symbol_table->AddSymbol(jump_symbol);
     }
 
     return i;
 }
 
if (DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo())
                         true,                 // Is this globally visible?
                         false,                // Is this symbol debug info?
                         false,                // Is this symbol a trampoline?
                         true,                 // Is this symbol artificial?
                         eh_sym_section_sp,    // Section in which this symbol is defined or null.
                         offset,               // Offset in section or symbol value.
                         range.GetByteSize(),  // Size in bytes of this symbol.
                         true,                 // Size is valid.
+                        false,                // Contains linker annotations?
                         0);                   // Symbol flags.
                 if (symbol_id == m_symtab_ap->AddSymbol(eh_symbol))
                     return m_symtab_ap->SymbolAtIndex(symbol_id);
             }
         }
     }
     return nullptr;
 }

lldb/trunk/source/Symbol/Symbol.cpp

Symbol::Symbol() :
     m_type_data_resolved (false),
     m_is_synthetic (false),
     m_is_debug (false),
     m_is_external (false),
     m_size_is_sibling (false),
     m_size_is_synthesized (false),
     m_size_is_valid (false),
     m_demangled_is_synthesized (false),
+    m_contains_linker_annotations (false),
     m_type (eSymbolTypeInvalid),
     m_mangled (),
     m_addr_range (),
     m_flags ()
 {
 }
 
 Symbol::Symbol
 (
     uint32_t symID,
     const char *name,
     bool name_is_mangled,
     SymbolType type,
     bool external,
     bool is_debug,
     bool is_trampoline,
     bool is_artificial,
     const lldb::SectionSP &section_sp,
     addr_t offset,
     addr_t size,
     bool size_is_valid,
+    bool contains_linker_annotations,
     uint32_t flags
 ) :
     SymbolContextScope (),
     m_uid (symID),
     m_type_data (0),
     m_type_data_resolved (false),
     m_is_synthetic (is_artificial),
     m_is_debug (is_debug),
     m_is_external (external),
     m_size_is_sibling (false),
     m_size_is_synthesized (false),
     m_size_is_valid (size_is_valid || size > 0),
     m_demangled_is_synthesized (false),
+    m_contains_linker_annotations (contains_linker_annotations),
     m_type (type),
     m_mangled (ConstString(name), name_is_mangled),
     m_addr_range (section_sp, offset, size),
     m_flags (flags)
 {
 }
 
 Symbol::Symbol
 (
     uint32_t symID,
-    const char *name,
-    bool name_is_mangled,
+    const Mangled &mangled,
     SymbolType type,
     bool external,
     bool is_debug,
     bool is_trampoline,
     bool is_artificial,
     const AddressRange &range,
     bool size_is_valid,
+    bool contains_linker_annotations,
     uint32_t flags
 ) :
     SymbolContextScope (),
     m_uid (symID),
     m_type_data (0),
     m_type_data_resolved (false),
     m_is_synthetic (is_artificial),
     m_is_debug (is_debug),
     m_is_external (external),
     m_size_is_sibling (false),
     m_size_is_synthesized (false),
     m_size_is_valid (size_is_valid || range.GetByteSize() > 0),
     m_demangled_is_synthesized (false),
+    m_contains_linker_annotations (contains_linker_annotations),
     m_type (type),
-    m_mangled (ConstString(name), name_is_mangled),
+    m_mangled (mangled),
     m_addr_range (range),
     m_flags (flags)
 {
 }
 
 Symbol::Symbol(const Symbol& rhs):
     SymbolContextScope (rhs),
     m_uid (rhs.m_uid),
     m_type_data (rhs.m_type_data),
     m_type_data_resolved (rhs.m_type_data_resolved),
     m_is_synthetic (rhs.m_is_synthetic),
     m_is_debug (rhs.m_is_debug),
     m_is_external (rhs.m_is_external),
     m_size_is_sibling (rhs.m_size_is_sibling),
     m_size_is_synthesized (false),
     m_size_is_valid (rhs.m_size_is_valid),
     m_demangled_is_synthesized (rhs.m_demangled_is_synthesized),
+    m_contains_linker_annotations (rhs.m_contains_linker_annotations),
     m_type (rhs.m_type),
     m_mangled (rhs.m_mangled),
     m_addr_range (rhs.m_addr_range),
     m_flags (rhs.m_flags)
 {
 }
 
 const Symbol&
 Symbol::operator= (const Symbol& rhs)
 {
     if (this != &rhs)
     {
         SymbolContextScope::operator= (rhs);
         m_uid = rhs.m_uid;
         m_type_data = rhs.m_type_data;
         m_type_data_resolved = rhs.m_type_data_resolved;
         m_is_synthetic = rhs.m_is_synthetic;
         m_is_debug = rhs.m_is_debug;
         m_is_external = rhs.m_is_external;
         m_size_is_sibling = rhs.m_size_is_sibling;
         m_size_is_synthesized = rhs.m_size_is_sibling;
         m_size_is_valid = rhs.m_size_is_valid;
         m_demangled_is_synthesized = rhs.m_demangled_is_synthesized;
+        m_contains_linker_annotations = rhs.m_contains_linker_annotations;
         m_type = rhs.m_type;
         m_mangled = rhs.m_mangled;
         m_addr_range = rhs.m_addr_range;
         m_flags = rhs.m_flags;
     }
     return *this;
 }
 
 void
 Symbol::Clear()
 {
     m_uid = UINT32_MAX;
     m_mangled.Clear();
     m_type_data = 0;
     m_type_data_resolved = false;
     m_is_synthetic = false;
     m_is_debug = false;
     m_is_external = false;
     m_size_is_sibling = false;
     m_size_is_synthesized = false;
     m_size_is_valid = false;
     m_demangled_is_synthesized = false;
+    m_contains_linker_annotations = false;
     m_type = eSymbolTypeInvalid;
     m_flags = 0;
     m_addr_range.Clear();
 }
 
 bool
 Symbol::ValueIsAddress() const
 {

lldb/trunk/source/Symbol/Symtab.cpp

#endif
             if (symbol->IsTrampoline())
                 continue;
 
             const Mangled &mangled = symbol->GetMangled();
             entry.cstring = mangled.GetMangledName().GetCString();
             if (entry.cstring && entry.cstring[0])
             {
                 m_name_to_index.Append (entry);
-                
+                if (symbol->ContainsLinkerAnnotations()) {
+                    // If the symbol has linker annotations, also add the version without the
+                    // annotations.
+                    entry.cstring = ConstString(m_objfile->StripLinkerSymbolAnnotations(entry.cstring)).GetCString();
+                    m_name_to_index.Append (entry);
+                }
+                
                 const SymbolType symbol_type = symbol->GetType();
                 if (symbol_type == eSymbolTypeCode || symbol_type == eSymbolTypeResolver)
                 {
                     if (entry.cstring[0] == '_' && entry.cstring[1] == 'Z' &&
                         (entry.cstring[2] != 'T' && // avoid virtual table, VTT structure, typeinfo structure, and typeinfo name
                          entry.cstring[2] != 'G' && // avoid guard variables
                          entry.cstring[2] != 'Z'))  // named local entities (if we eventually handle eSymbolTypeData, we will want this back)
                     {
#endif
                                 }
                             }
                         }
                     }
                 }
             }
             
             entry.cstring = mangled.GetDemangledName().GetCString();
-            if (entry.cstring && entry.cstring[0])
+            if (entry.cstring && entry.cstring[0]) {
                 m_name_to_index.Append (entry);
-                
+                if (symbol->ContainsLinkerAnnotations()) {
+                    // If the symbol has linker annotations, also add the version without the
+                    // annotations.
+                    entry.cstring = ConstString(m_objfile->StripLinkerSymbolAnnotations(entry.cstring)).GetCString();
+                    m_name_to_index.Append (entry);
+                }
+            }
+                
             // If the demangled name turns out to be an ObjC name, and
             // is a category name, add the version without categories to the index too.
             ObjCLanguageRuntime::MethodName objc_method (entry.cstring, true);
             if (objc_method.IsValid(true))
             {
                 entry.cstring = objc_method.GetSelector().GetCString();
                 m_selector_to_index.Append (entry);