[ELF] - Versionscript: support wildcards for extern "c++" tag.

[grimar]

Summary

Previously for extern keyword only names in quotes (exact match) was supported.
Patch adds support for wildcards, so next scripts can be handled properly:

LIBSAMPLE_1.0 {
   global:            
     extern "C++" {  
       foo*;   
   };                  
 };

[ruiu]

ELF/SymbolTable.cpp

601–602

Why did you move this inside this function?

[grimar]

ELF/SymbolTable.cpp

601–602

Idea was to make
std::map<std::string, SymbolBody *> Demangled to be const.

This change allows to have one-line initialization below then:

const std::map<std::string, SymbolBody *> Demangled = getDemangledSyms();

Instead of something like:

const std::map<std::string, SymbolBody *> Demangled =
    hasExternCpp() ? getDemangledSyms()
                   : std::map<std::string, SymbolBody *>();

[grimar]

ELF/SymbolTable.cpp

601–602

And actually his change is relative to D23793, this patch depends on it.

[grimar]

• Updated.

[ruiu]

LGTM

ELF/SymbolTable.cpp

680

if (!hasWildcard(Sym.Name))
  continue;

[grimar]

ELF/SymbolTable.cpp

680

Done in r280068.

ELF/SymbolTable.cpp

static void setVersionId(SymbolBody *Body, StringRef VersionName,
   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;
   for (Symbol *Sym : SymVector) {
     SymbolBody *B = Sym->body();
     Result[demangle(B->getName())] = 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) {
+  auto I = D.find(Name);
+  if (I != D.end())
+    return I->second;
+  return nullptr;
+}
+
+static std::vector<SymbolBody *>
+findAllDemangled(const std::map<std::string, SymbolBody *> &D,
+                 StringRef Pattern) {
+  std::vector<SymbolBody *> Res;
+  for (auto &P : D) {
+    SymbolBody *Body = P.second;
+    if (!Body->isUndefined() && globMatch(Pattern, P.first))
+      Res.push_back(Body);
+  }
+  return Res;
+}
+
 // This function processes the --version-script option by marking all global
 // symbols with the VersionScriptGlobal flag, which acts as a filter on the
 // dynamic symbol table.
 template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
   // If version script does not contain versions declarations,
   // we just should mark global symbols.
   if (!Config->VersionScriptGlobals.empty()) {
     for (SymbolVersion &Sym : Config->VersionScriptGlobals)
template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
   std::map<std::string, SymbolBody *> Demangled;
   if (hasExternCpp())
     Demangled = getDemangledSyms();
 
   for (VersionDefinition &V : Config->VersionDefinitions) {
     for (SymbolVersion Sym : V.Globals) {
       if (hasWildcard(Sym.Name))
         continue;
-      SymbolBody *B = Sym.IsExternCpp ? Demangled[Sym.Name] : find(Sym.Name);
-      setVersionId(B, V.Name, Sym.Name, V.Id);
+      StringRef N = Sym.Name;
+      SymbolBody *B = Sym.IsExternCpp ? findDemangled(Demangled, N) : find(N);
+      setVersionId(B, V.Name, N, V.Id);
     }
   }
 
   // Handle wildcards.
   for (size_t I = Config->VersionDefinitions.size() - 1; I != (size_t)-1; --I) {
     VersionDefinition &V = Config->VersionDefinitions[I];
     for (SymbolVersion &Sym : V.Globals)
-      if (hasWildcard(Sym.Name))
-        for (SymbolBody *B : findAll(Sym.Name))
+      if (hasWildcard(Sym.Name)) {
+        std::vector<SymbolBody *> All =
+            Sym.IsExternCpp ? findAllDemangled(Demangled, Sym.Name)
+                            : findAll(Sym.Name);
+
+        for (SymbolBody *B : All)
           if (B->symbol()->VersionId == Config->DefaultSymbolVersion)
             B->symbol()->VersionId = V.Id;
       }
   }
+}
 
 template class elf::SymbolTable<ELF32LE>;
 template class elf::SymbolTable<ELF32BE>;
 template class elf::SymbolTable<ELF64LE>;
 template class elf::SymbolTable<ELF64BE>;

test/ELF/version-script-extern-wildcards.s

+# REQUIRES: shell
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: echo "LIBSAMPLE_1.0 { \
+# RUN:   global:             \
+# RUN:      extern "C++" {   \
+# RUN:        foo*;          \
+# RUN:   };                  \
+# RUN: };                    \
+# RUN: LIBSAMPLE_2.0 {       \
+# RUN:   global:             \
+# RUN:     extern "C++" {    \
+# RUN:       zed*;           \
+# RUN:       bar;            \
+# RUN:   };                  \
+# RUN: }; " > %t.script
+# RUN: ld.lld --version-script %t.script -shared %t.o -o %t.so
+# RUN: llvm-readobj -V -dyn-symbols %t.so | FileCheck %s
+
+# CHECK:  Version symbols {
+# CHECK:   Symbols [
+# CHECK:    Name: _Z3bari@
+# CHECK:    Name: _Z3fooi@@LIBSAMPLE_1.0
+# CHECK:    Name: _Z3zedi@@LIBSAMPLE_2.0
+
+.text
+.globl _Z3fooi
+.type _Z3fooi,@function
+_Z3fooi:
+retq
+
+.globl _Z3bari
+.type _Z3bari,@function
+_Z3bari:
+retq
+
+.globl _Z3zedi
+.type _Z3zedi,@function
+_Z3zedi:
+retq