[ELF] - Added support for extern "c++" local symbols in version script.

[grimar]

Summary

Previously we did not support them,
patch implements this functionality.

[ruiu]

ELF/LinkerScript.cpp

1799–1808

We have very similar code in readGlobal. Can you factor it out?

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

1799–1808

Done.

[ruiu]

ELF/LinkerScript.cpp

1788

I don't think you need Globals. You could just stop reading until local: in any context.

[grimar]

• Rebased, addressed comment.

[grimar]

ELF/LinkerScript.cpp

1788

That what seems obvious and was what I first think of.
But also it would parse something like next I think:

...
local:
<locals1>
local:
<local2>
...
It does not look clean.

Actually if you're ok with that, I am fine either,
as I also do not like that flag.

[grimar]

ELF/LinkerScript.cpp

1788

Ah, I see my mistake now, above can't happen, please ignore my comment then.

[ruiu]

LGTM

ELF/SymbolTable.cpp

710

Is there any reason to add single quotes? Please remove them because V.Name doesn't contain such quotes.

[grimar]

ELF/SymbolTable.cpp

710

Lets add them for V.Name ? That is consistent with other messages we added recently

[ruiu]

ELF/SymbolTable.cpp

710

Well, what you pass here is a version name, and that's the right thing to do. If you want to add single quotes, do it in the string in error().

ELF/LinkerScript.cpp

void ScriptParser::readVersionDeclaration(StringRef VerStr) {
   // "Ver2 { global: foo; local: *; } Ver1;" has "Ver1" as a parent. This
   // version hierarchy is, probably against your instinct, purely for human; the
   // runtime doesn't care about them at all. In LLD, we simply skip the token.
   if (!VerStr.empty() && peek() != ";")
     skip();
   expect(";");
 }
 
 void ScriptParser::readLocal(StringRef VerStr) {
   if (consume("*")) {
     Config->DefaultSymbolVersion = VER_NDX_LOCAL;
     expect(";");
     return;
   }
 
   if (VerStr.empty())
     setError("locals list for anonymous version is not supported");
 
   std::vector<SymbolVersion> &Locals = Config->VersionDefinitions.back().Locals;
-  while (!Error && peek() != "}") {
+  for (;;) {
+    if (consume("extern"))
+      readExtern(&Locals);
+    StringRef Cur = peek();
+    if (Cur == "}" || Error)
+      return;
     StringRef Tok = next();
     Locals.push_back({unquote(Tok), false, hasWildcard(Tok)});
     expect(";");
   }
 }
 
-void ScriptParser::readExtern(std::vector<SymbolVersion> *Globals) {
+void ScriptParser::readExtern(std::vector<SymbolVersion> *V) {
   expect("\"C++\"");
   expect("{");
 
   for (;;) {
     if (peek() == "}" || Error)
       break;
     bool HasWildcard = !peek().startswith("\"") && hasWildcard(peek());
-    Globals->push_back({unquote(next()), true, HasWildcard});
+    V->push_back({unquote(next()), true, HasWildcard});
     expect(";");
   }
 
   expect("}");
   expect(";");
 }
 
 void ScriptParser::readGlobal(StringRef VerStr) {

ELF/SymbolTable.cpp

SymbolTable<ELFT>::getDemangledSyms() {
   for (Symbol *Sym : SymVector) {
     SymbolBody *B = Sym->body();
     Result[demangle(B->getName())].push_back(B);
   }
   return Result;
 }
 
 static bool hasExternCpp() {
-  for (VersionDefinition &V : Config->VersionDefinitions)
+  for (VersionDefinition &V : Config->VersionDefinitions) {
     for (SymbolVersion Sym : V.Globals)
       if (Sym.IsExternCpp)
         return true;
+    for (SymbolVersion Sym : V.Locals)
+      if (Sym.IsExternCpp)
+        return true;
+  }
   return false;
 }
 
 static ArrayRef<SymbolBody *>
 findDemangled(std::map<std::string, std::vector<SymbolBody *>> &D,
               StringRef Name) {
   auto I = D.find(Name);
   if (I != D.end())
template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
   // 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, 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 (Sym.HasWildcards)
-        continue;
-
-      StringRef N = Sym.Name;
-      if (Sym.IsExternCpp) {
-        for (SymbolBody *B : findDemangled(Demangled, N))
-          setVersionId(B, V.Name, N, V.Id);
-        continue;
-      }
-      setVersionId(find(N), V.Name, N, V.Id);
-    }
-    for (SymbolVersion Sym : V.Locals) {
-      if (Sym.HasWildcards)
-        continue;
-      setVersionId(find(Sym.Name), V.Name, Sym.Name, VER_NDX_LOCAL);
+  auto assignVersion = [&](SymbolVersion &Sym, size_t Version,
+                           StringRef VerName) {
+      return;
+      for (SymbolBody *B : findDemangled(Demangled, Sym.Name))
+        setVersionId(B, VerName, Sym.Name, Version);
+      return;
     }
+    setVersionId(find(Sym.Name), VerName, Sym.Name, Version);
+  };
+
+  // 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)
+      assignVersion(Sym, V.Id, V.Name);
+    for (SymbolVersion Sym : V.Locals)
+      assignVersion(Sym, VER_NDX_LOCAL, "'local'");
   }
 
   // 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.
   auto assignFuzzyVersion = [&](SymbolVersion &Sym, size_t Version) {
     if (!Sym.HasWildcards)

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

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: echo "FOO { local: extern \"C++\" { \"abb(int)\"; }; };" > %t.script
+# RUN: ld.lld --version-script %t.script -shared %t.o -o %t.so
+# RUN: llvm-readobj -V %t.so | FileCheck %s --check-prefix=ABB
+# ABB:      Symbols [
+# ABB-NEXT:   Symbol {
+# ABB-NEXT:     Version: 0
+# ABB-NEXT:     Name: @
+# ABB-NEXT:   }
+# ABB-NEXT:   Symbol {
+# ABB-NEXT:     Version: 1
+# ABB-NEXT:     Name: _Z3abci@
+# ABB-NEXT:   }
+# ABB-NEXT: ]
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: echo "FOO { local: extern \"C++\" { abb*; }; };" > %t.script
+# RUN: ld.lld --version-script %t.script -shared %t.o -o %t.so
+# RUN: llvm-readobj -V %t.so | FileCheck %s --check-prefix=ABB
+
+# RUN: echo "FOO { local: extern \"C++\" { abc*; }; };" > %t.script
+# RUN: ld.lld --version-script %t.script -shared %t.o -o %t.so
+# RUN: llvm-readobj -V %t.so | FileCheck %s --check-prefix=ABC
+# ABC:      Symbols [
+# ABC-NEXT:   Symbol {
+# ABC-NEXT:     Version: 0
+# ABC-NEXT:     Name: @
+# ABC-NEXT:   }
+# ABC-NEXT:   Symbol {
+# ABC-NEXT:     Version: 1
+# ABC-NEXT:     Name: _Z3abbi@
+# ABC-NEXT:   }
+# ABC-NEXT: ]
+
+.globl _Z3abbi
+.type _Z3abbi,@function
+_Z3abbi:
+retq
+
+.globl _Z3abci
+.type _Z3abci,@function
+_Z3abci:
+retq

test/ELF/version-script-locals.s

 # RUN: ld.lld --version-script %t.script -shared %t.o -o %t.so
 # RUN: llvm-readobj -dyn-symbols %t.so | FileCheck --check-prefix=MIX %s
 # MIX:  DynamicSymbols [
 # MIX:      _start@@VERSION_1.0
 # MIX-NOT:  foo1
 # MIX-NOT:  foo2
 # MIX-NOT:  foo3
 
-# RUN: echo "VERSION_1.0 { global: *; local: extern \"C++\" { foo*; } };" > %t.script
-# RUN: not ld.lld --version-script %t.script -shared %t.o -o %t.so 2>&1 \
-# RUN:   | FileCheck --check-prefix=EXTERNERR %s
-# EXTERNERR: ; expected, but got "C++"
-
 .globl foo1
 foo1:
   ret
 
 .globl foo2
 foo2:
   ret
 
 .globl foo3
 foo3:
   ret
 
 .globl _start
 _start:
   ret

test/ELF/version-script-noundef.s

 # REQUIRES: x86
 
 # RUN: echo "VERSION_1.0 { global: bar; };" > %t.script
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: not ld.lld --version-script %t.script -shared --no-undefined-version \
 # RUN:   %t.o -o %t.so 2>&1 | FileCheck -check-prefix=ERR1 %s
 # ERR1: version script assignment of VERSION_1.0 to symbol bar failed: symbol not defined
 
 # RUN: echo "VERSION_1.0 { global: und; };" > %t2.script
 # RUN: not ld.lld --version-script %t2.script -shared --no-undefined-version \
 # RUN:   %t.o -o %t.so 2>&1 | FileCheck -check-prefix=ERR2 %s
 # ERR2: version script assignment of VERSION_1.0 to symbol und failed: symbol not defined
 
+# RUN: echo "VERSION_1.0 { local: und; };" > %t3.script
+# RUN: not ld.lld --version-script %t3.script -shared --no-undefined-version \
+# RUN:   %t.o -o %t.so 2>&1 | FileCheck -check-prefix=ERR3 %s
+# ERR3: version script assignment of 'local' to symbol und failed: symbol not defined
+
 .text
 .globl foo
 .type foo,@function
 foo:
 callq und@PLT