Linker script: support VERSION command.

[ruiu]

Summary

VERSION commands define symbol versions. The grammar of the
commnad is as follows

VERSION { version-script-commands }

where version-script-commands is

[ name ] { version-definitions }.

Note that we already support version-script-commands because
it is being used for version script command.

This patch is based on George's patch https://reviews.llvm.org/D23609

[grimar]

That was really simple. Thanks !

lld/trunk/ELF/LinkerScript.cpp

private:
   void readInclude();
   void readNothing() {}
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readPhdrs();
   void readSearchDir();
   void readSections();
+  void readVersion();
+  void readVersionScriptCommand();
 
   SymbolAssignment *readAssignment(StringRef Name);
   OutputSectionCommand *readOutputSectionDescription(StringRef OutSec);
   std::vector<uint8_t> readOutputSectionFiller();
   std::vector<StringRef> readOutputSectionPhdrs();
   InputSectionDescription *readInputSectionDescription(StringRef Tok);
   std::vector<StringRef> readInputFilePatterns();
   InputSectionDescription *readInputSectionRules(StringRef FilePattern);
   unsigned readPhdrType();
   SortKind readSortKind();
   SymbolAssignment *readProvideHidden(bool Provide, bool Hidden);
   SymbolAssignment *readProvideOrAssignment(StringRef Tok);
   void readSort();
   Expr readAssert();
 
   Expr readExpr();
   Expr readExpr1(Expr Lhs, int MinPrec);
   Expr readPrimary();
   Expr readTernary(Expr Cond);
   Expr readParenExpr();
 
   // For parsing version script.
   void readExtern(std::vector<SymbolVersion> *Globals);
-  void readVersion(StringRef VerStr);
+  void readVersionDeclaration(StringRef VerStr);
   void readGlobal(StringRef VerStr);
   void readLocal();
 
   const static StringMap<Handler> Cmd;
   ScriptConfiguration &Opt = *ScriptConfig;
   StringSaver Saver = {ScriptConfig->Alloc};
   bool IsUnderSysroot;
 };
 
 const StringMap<elf::ScriptParser::Handler> elf::ScriptParser::Cmd = {
     {"ENTRY", &ScriptParser::readEntry},
     {"EXTERN", &ScriptParser::readExtern},
     {"GROUP", &ScriptParser::readGroup},
     {"INCLUDE", &ScriptParser::readInclude},
     {"INPUT", &ScriptParser::readGroup},
     {"OUTPUT", &ScriptParser::readOutput},
     {"OUTPUT_ARCH", &ScriptParser::readOutputArch},
     {"OUTPUT_FORMAT", &ScriptParser::readOutputFormat},
     {"PHDRS", &ScriptParser::readPhdrs},
     {"SEARCH_DIR", &ScriptParser::readSearchDir},
     {"SECTIONS", &ScriptParser::readSections},
+    {"VERSION", &ScriptParser::readVersion},
     {";", &ScriptParser::readNothing}};
 
 void ScriptParser::readVersionScript() {
-  StringRef Msg = "anonymous version definition is used in "
-                  "combination with other version definitions";
-  if (skip("{")) {
-    readVersion("");
-    if (!atEOF())
-      setError(Msg);
+  readVersionScriptCommand();
+    setError("EOF expected, but got " + next());
+}
+
+void ScriptParser::readVersionScriptCommand() {
+  if (skip("{")) {
+    readVersionDeclaration("");
     return;
   }
 
-  while (!atEOF() && !Error) {
+  while (!atEOF() && !Error && peek() != "}") {
     StringRef VerStr = next();
     if (VerStr == "{") {
-      setError(Msg);
+      setError("anonymous version definition is used in "
+               "combination with other version definitions");
       return;
     }
     expect("{");
-    readVersion(VerStr);
+    readVersionDeclaration(VerStr);
   }
 }
 
+void ScriptParser::readVersion() {
+  expect("{");
+  readVersionScriptCommand();
+  expect("}");
+}
+
 void ScriptParser::readLinkerScript() {
   while (!atEOF()) {
     StringRef Tok = next();
     if (Handler Fn = Cmd.lookup(Tok)) {
       (this->*Fn)();
     } else if (SymbolAssignment *Cmd = readProvideOrAssignment(Tok)) {
       if (Opt.HasContents)
         Opt.Commands.emplace_back(Cmd);
unsigned ScriptParser::readPhdrType() {
 
   if (Ret == (unsigned)-1) {
     setError("invalid program header type: " + Tok);
     return PT_NULL;
   }
   return Ret;
 }
 
-void ScriptParser::readVersion(StringRef VerStr) {
+void ScriptParser::readVersionDeclaration(StringRef VerStr) {
   // Identifiers start at 2 because 0 and 1 are reserved
   // for VER_NDX_LOCAL and VER_NDX_GLOBAL constants.
   size_t VersionId = Config->VersionDefinitions.size() + 2;
   Config->VersionDefinitions.push_back({VerStr, VersionId});
 
   if (skip("global:") || peek() != "local:")
     readGlobal(VerStr);
   if (skip("local:"))

lld/trunk/test/ELF/verdef.s

 # MAIN-NEXT:       Version: 4
 # MAIN-NEXT:       Name: c@LIBSAMPLE_3.0
 # MAIN-NEXT:     }
 # MAIN-NEXT:   ]
 # MAIN-NEXT: }
 # MAIN-NEXT: SHT_GNU_verdef {
 # MAIN-NEXT: }
 
+# RUN: echo "VERSION { \
+# RUN:       LIBSAMPLE_1.0 { global: a; local: *; }; \
+# RUN:       LIBSAMPLE_2.0 { global: b; local: *; }; \
+# RUN:       LIBSAMPLE_3.0 { global: c; local: *; }; \
+# RUN:       }" > %t.script
+# RUN: ld.lld --script %t.script -shared -soname shared %t.o -o %t2.so
+# RUN: llvm-readobj -V -dyn-symbols %t2.so | FileCheck --check-prefix=DSO %s
+
 .globl a
 .type  a,@function
 a:
 retq
 
 .globl b
 .type  b,@function
 b:
 retq
 
 .globl c
 .type  c,@function
 c:
 retq

lld/trunk/test/ELF/version-script.s

 
 # RUN: echo "VERSION_1.0{     \
 # RUN:          global: foo1; \
 # RUN:          local: *; };  \
 # RUN:          {             \
 # RUN:          global: foo3; \
 # RUN:          local: *; }; " > %t5.script
 # RUN: not ld.lld --version-script %t5.script -shared %t.o %t2.so -o %t5.so 2>&1 | \
-# RUN:   FileCheck -check-prefix=ERR %s
-# ERR: anonymous version definition is used in combination with other version definitions
+# RUN:   FileCheck -check-prefix=ERR1 %s
+# ERR1: anonymous version definition is used in combination with other version definitions
 
 # RUN: echo    "{             \
 # RUN:          global: foo1; \
 # RUN:          local: *; };  \
 # RUN:       VERSION_2.0 {    \
 # RUN:          global: foo3; \
 # RUN:          local: *; }; " > %t5.script
 # RUN: not ld.lld --version-script %t5.script -shared %t.o %t2.so -o %t5.so 2>&1 | \
-# RUN:   FileCheck -check-prefix=ERR %s
+# RUN:   FileCheck -check-prefix=ERR2 %s
+# ERR2: EOF expected, but got VERSION_2.0
 
 # RUN: echo "VERSION_1.0{     \
 # RUN:          global: foo1; \
 # RUN:          local: *; };  \
 # RUN:       VERSION_2.0 {    \
 # RUN:          global: foo1; \
 # RUN:          local: *; }; " > %t6.script
 # RUN: ld.lld --version-script %t6.script -shared %t.o %t2.so -o %t6.so 2>&1 | \