[ELF] - Versionscript: support mangled symbols with the same name.

[grimar]

Summary

This is PR30312. Info from bug page:

Both of these symbols demangle to abc::abc():
_ZN3abcC1Ev
_ZN3abcC2Ev
(These would be abc's complete object constructor and base object constructor, respectively.)
however with "abc::abc()" in the version script only one of the two receives the symbol version.

Patch fixes that.
It uses testcase created by Ed Maste (D24306).

[emaste]

Just a heads-up before this gets committed: when I tried applying this locally (from Phabricator "download raw diff") it produced complaints about differing line endings.

Testing with this patch now.

[grimar]

• CRLF->LF

[grimar]

In D24336#537146, @emaste wrote:

Just a heads-up before this gets committed: when I tried applying this locally (from Phabricator "download raw diff") it produced complaints about differing line endings.

That is how patch creation works for me using svn diff. Usually I convert endings manually to unix one before publishing patch to phab, but looks not this time. Reuploaded with fixed endings.

[emaste]

My original issue (found while linking the FreeBSD base system w/ lld) is fixed with this patch.

[ruiu]

ELF/SymbolTable.h

104

It seems you want to use multimap instead of map + vector.

[grimar]

ELF/SymbolTable.h

104

Problably I am missing something, but my question is: for what ?
I see no difference here.

[ruiu]

ELF/SymbolTable.h

104

I meant std::multimap<X, Y> is a more natural choice than std::map<X, std::vector<Y>>.

[grimar]

• Addressed review comments.

[grimar]

ELF/SymbolTable.h

0–1

So I switched to multimap, but please look at the changes I had to do for that. I am not sure I like them. For example I can not return ArrayRef from findDemangled() anymore.
I would probably better go with initial version here.

[ruiu]

Yeah, it doesn't look as good as I hoped, so LGTM on the std::vector version.

ELF/SymbolTable.h

 //===- SymbolTable.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
private:
   std::pair<Symbol *, bool> insert(StringRef &Name);
   std::pair<Symbol *, bool> insert(StringRef &Name, uint8_t Type,
                                    uint8_t Visibility, bool CanOmitFromDynSym,
                                    bool HasUnnamedAddr, InputFile *File);
 
   std::string conflictMsg(SymbolBody *Existing, InputFile *NewFile);
   void reportDuplicate(SymbolBody *Existing, InputFile *NewFile);
 
-  std::map<std::string, SymbolBody *> getDemangledSyms();
+  std::map<std::string, std::vector<SymbolBody *>> getDemangledSyms();
 
   struct SymIndex {
     SymIndex(int Idx, bool Traced) : Idx(Idx), Traced(Traced) {}
     int Idx : 31;
     unsigned Traced : 1;
   };
 
   // The order the global symbols are in is not defined. We can use an arbitrary

ELF/SymbolTable.cpp

static void setVersionId(SymbolBody *Body, StringRef VersionName,
 
   Symbol *Sym = Body->symbol();
   if (Sym->VersionId != Config->DefaultSymbolVersion)
     warning("duplicate symbol " + Name + " in version script");
   Sym->VersionId = Version;
 }
 
 template <class ELFT>
-std::map<std::string, SymbolBody *> SymbolTable<ELFT>::getDemangledSyms() {
-  std::map<std::string, SymbolBody *> Result;
+std::map<std::string, std::vector<SymbolBody *>>
+SymbolTable<ELFT>::getDemangledSyms() {
+  std::map<std::string, std::vector<SymbolBody *>> Result;
   for (Symbol *Sym : SymVector) {
     SymbolBody *B = Sym->body();
-    Result[demangle(B->getName())] = B;
+    Result[demangle(B->getName())].push_back(B);
   }
   return Result;
 }
 
 static bool hasExternCpp() {
   for (VersionDefinition &V : Config->VersionDefinitions)
     for (SymbolVersion Sym : V.Globals)
       if (Sym.IsExternCpp)
         return true;
   return false;
 }
 
-static SymbolBody *findDemangled(const std::map<std::string, SymbolBody *> &D,
-                                 StringRef Name) {
+static ArrayRef<SymbolBody *>
+findDemangled(std::map<std::string, std::vector<SymbolBody *>> &D,
   auto I = D.find(Name);
   if (I != D.end())
     return I->second;
-  return nullptr;
+  return {};
 }
 
 static std::vector<SymbolBody *>
-findAllDemangled(const std::map<std::string, SymbolBody *> &D,
+findAllDemangled(const std::map<std::string, std::vector<SymbolBody *>> &D,
                  const Regex &Re) {
   std::vector<SymbolBody *> Res;
   for (auto &P : D) {
-    SymbolBody *Body = P.second;
-    if (!Body->isUndefined() && const_cast<Regex &>(Re).match(P.first))
+    if (const_cast<Regex &>(Re).match(P.first))
+      for (SymbolBody *Body : P.second)
+        if (!Body->isUndefined())
           Res.push_back(Body);
   }
   return Res;
 }
 
 // This function processes version scripts by updating VersionId
 // member of symbols.
 template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
   // If there's only one anonymous version definition in a version
template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
   // Each version definition has a glob pattern, and all symbols that match
   // with the pattern get that version.
 
   // Users can use "extern C++ {}" directive to match against demangled
   // C++ symbols. For example, you can write a pattern such as
   // "llvm::*::foo(int, ?)". Obviously, there's no way to handle this
   // other than trying to match a regexp against all demangled symbols.
   // So, if "extern C++" feature is used, we demangle all known symbols.
-  std::map<std::string, SymbolBody *> Demangled;
+  std::map<std::string, std::vector<SymbolBody *>> Demangled;
   if (hasExternCpp())
     Demangled = getDemangledSyms();
 
   // First, we assign versions to exact matching symbols,
   // i.e. version definitions not containing any glob meta-characters.
   for (VersionDefinition &V : Config->VersionDefinitions) {
     for (SymbolVersion Sym : V.Globals) {
       if (hasWildcard(Sym.Name))
         continue;
+
       StringRef N = Sym.Name;
-      SymbolBody *B = Sym.IsExternCpp ? findDemangled(Demangled, N) : find(N);
+      ArrayRef<SymbolBody *> Arr = Sym.IsExternCpp
+                                       ? findDemangled(Demangled, N)
+                                       : ArrayRef<SymbolBody *>(find(N));
+      for (SymbolBody *B : Arr)
         setVersionId(B, V.Name, N, V.Id);
     }
   }
 
   // Next, we assign versions to fuzzy matching symbols,
   // i.e. version definitions containing glob meta-characters.
   // Note that because the last match takes precedence over previous matches,
   // we iterate over the definitions in the reverse order.
   for (size_t I = Config->VersionDefinitions.size() - 1; I != (size_t)-1; --I) {

test/ELF/version-script-extern.s

 # DSO-NEXT:      Name: _ZN3abcC1Ev@@LIBSAMPLE_1.0
 # DSO-NEXT:      Value: 0x1003
 # DSO-NEXT:      Size: 0
 # DSO-NEXT:      Binding: Global (0x1)
 # DSO-NEXT:      Type: Function (0x2)
 # DSO-NEXT:      Other: 0
 # DSO-NEXT:      Section: .text (0x6)
 # DSO-NEXT:    }
+# DSO-NEXT:    Symbol {
+# DSO-NEXT:      Name: _ZN3abcC2Ev@@LIBSAMPLE_1.0
+# DSO-NEXT:      Value: 0x1004
+# DSO-NEXT:      Size: 0
+# DSO-NEXT:      Binding: Global (0x1)
+# DSO-NEXT:      Type: Function (0x2)
+# DSO-NEXT:      Other: 0
+# DSO-NEXT:      Section: .text (0x6)
+# DSO-NEXT:    }
 # DSO-NEXT:  ]
 # DSO-NEXT:  Version symbols {
 # DSO-NEXT:    Section Name: .gnu.version
-# DSO-NEXT:    Address: 0x240
-# DSO-NEXT:    Offset: 0x240
+# DSO-NEXT:    Address: 0x258
+# DSO-NEXT:    Offset: 0x258
 # DSO-NEXT:    Link: 1
 # DSO-NEXT:    Symbols [
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 0
 # DSO-NEXT:        Name: @
 # DSO-NEXT:      }
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 3
 # DSO-NEXT:        Name: _Z3bari@@LIBSAMPLE_2.0
 # DSO-NEXT:      }
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 2
 # DSO-NEXT:        Name: _Z3fooi@@LIBSAMPLE_1.0
 # DSO-NEXT:      }
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 2
 # DSO-NEXT:        Name: _Z3zedi@@LIBSAMPLE_1.0
 # DSO-NEXT:      }
 # DSO-NEXT:      Symbol {
 # DSO-NEXT:        Version: 2
 # DSO-NEXT:        Name: _ZN3abcC1Ev@@LIBSAMPLE_1.0
 # DSO-NEXT:      }
+# DSO-NEXT:      Symbol {
+# DSO-NEXT:        Version: 2
+# DSO-NEXT:        Name: _ZN3abcC2Ev@@LIBSAMPLE_1.0
+# DSO-NEXT:      }
 # DSO-NEXT:    ]
 # DSO-NEXT:  }
 
 .text
 .globl _Z3fooi
 .type _Z3fooi,@function
 _Z3fooi:
 retq
 
 .globl _Z3bari
 .type _Z3bari,@function
 _Z3bari:
 retq
 
 .globl _Z3zedi
 .type _Z3zedi,@function
 _Z3zedi:
 retq
 
 .globl _ZN3abcC1Ev
 .type _ZN3abcC1Ev,@function
 _ZN3abcC1Ev:
 retq
+
+.globl _ZN3abcC2Ev
+.type _ZN3abcC2Ev,@function
+_ZN3abcC2Ev:
+retq