[ELF] - Basic versioned symbols support implemented.

[grimar]

Summary

Patch implements basic support of versioned symbols.
There is no wildcards patterns matching except local: *;
There is no support for hierarchies.
There is no support for symbols overrides (@ vs @@ not handled).

This patch allows programs that using simple scripts to link and run.

[grimar]

• Teach version-script parser to parse parent versions declarations. That allows to parse script file from reproduce file posted by Rafael in original issue thread (https://llvm.org/bugs/show_bug.cgi?id=23231).

After that change, I can link the reproduce if add the --allow-multiple-definition flag. Flag helps here as this patch does not support comparing versioned vs unversioned symbols yet. So for example

acl_compat.So contains acl_add_perm@FBSD_1.0
acl_perm.So contains acl_add_perm

Resolving fails without flag with duplicate symbol error now.

[ruiu]

Here is my first round of review.

ELF/InputFiles.cpp

343 ↗

(On Diff #60014)

Why do you need this?

ELF/SymbolListFile.cpp

91–95

A version definition without a version name is not actually a version definition in the sense that they controls only visibility and have nothing to do with symbol versioning. I think it is better to handle that case completely differently from symbol versioning.

99

Since you are not using this member at all, please remove Parent member from the struct and just discard the next token here.

ELF/SymbolListFile.h

23–27

Move this definition to Config.h and make version definitions a member of Config class.

[grimar]

• Addressed review comments.

[grimar]

In D21018#452308, @ruiu wrote:

Here is my first round of review.

Thanks for review ! My response to comments are below.

ELF/InputFiles.cpp

343 ↗

(On Diff #60014)

Right, for this patch and its trivial versionscript and cases this is excessive. That left from my experiments with bit more complex cases.
Removed.

ELF/SymbolListFile.cpp

91–95

Ok. I was thinking about that as about a some virtual "base version of the library".

Spec says: "Symbols defined in the library which aren't specifically bound to a version node are effectively bound to an unspecified base version of the library. " (http://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_node/ld_25.html). That is not exactly our case probably, but it is sounds relative.
I reimplemented code according to your comment though, lets see how it goes.

99

Done.

ELF/SymbolListFile.h

23–27

Done.

[ruiu]

For some reason, I received no email notifications on this review thread. George, do you have an idea why?

I haven't fully understand the core part of the patch yet, so this review is mostly on stylistic things. I'll read it again later today or tomorrow. (I'm traveling for a few days until Sunday.)

ELF/OutputSections.h

246

Using a platform-dependent integral type for a ELF flag is a bit alarming. Can you use uint32_t?

You can format like this

uint32_t Flags; // Version definition flags
uint32_t Hash;  // ...

ELF/SymbolListFile.cpp

154–156

Does this work?

Config->SymbolVersions.push_back({next()});

159

You don't need to cache the result of peek() -- it's a cheap function, and this function is not in a performance-critical path.

[ruiu]

ELF/OutputSections.h

254

Add a blank line.

[grimar]

In D21018#453725, @ruiu wrote:

For some reason, I received no email notifications on this review thread. George, do you have an idea why?

I think the only difference here from my usual style was that I quoted the part of your message and posted responce "Thanks for review ! My response to comments are below." in the same message with responces on review comments. Usually I think I do not do that and comments just auto merged to the last (patch updated) post. I am always using web form for that, so no much ways to do almost the same here exist.

Not sure that it can be the reason, I added you as a subscriber just in case as well, hope that helps.

I haven't fully understand the core part of the patch yet, so this review is mostly on stylistic things. I'll read it again later today or tomorrow. (I'm traveling for a few days until Sunday.)

Ok, just in case I think I`ll also be able to address any comments for this in next 2 days if any.

[grimar]

• Addressed review comments.

ELF/OutputSections.h

246

Done.

254

Done.

ELF/SymbolListFile.cpp

154–156

Actually this does not. Though it should be valid С++ construction and works in msvs/gcc,
as far I know clang produces an error if you do not specify all members in aggregate specialization.
So this might be:

Config->SymbolVersions.push_back({next(), {}});

to work. And I do not like this, because if you change the members of struct (amount of them),
you have to be sure to check and update all such places to support clang.

I updated this place, since it is single, but above was the reason why I did not do that initially (even was thinking about adding constructor for Name to Version struct).

159

Done.

[ruiu]

Ahh, I got the reason why it didn't appear in my inbox. It went to a spam folder. I'm sorry about that. If you have sent me mails and did not get responses, please re-send.

ELF/SymbolListFile.cpp

154–156

Then how about defining a constructor that takes a StringRef?

[grimar]

• Addressed review comment.

ELF/SymbolListFile.cpp

154–156

Done. That is not very consistent with other lld code, but solves the problem.
(actually I just do not understand why it can not be solved(fixed) in clang, as this feature of c++ language looks
pretty cool for me).

[pcc]

ELF/OutputSections.cpp

1432

Can we rename our implementation of the ELF hash function to something like hashElf? I previously wasn't aware that we had one.

1437

This is a well-known problem, we probably don't need to call out every instance of it.

1445

Grammar nitpick: "to the number of definitions"

1457

It isn't deterministic to iterate over a DenseMap like that.

1517

Grammar nitpick: "if it exists"

1520

The std::max seems redundant because getVerDefNum() cannot return a value less than 2 here.

ELF/OutputSections.h

245–248

I don't think you need either of the flags or hash fields here. The first one is never anything but zero in your implementation, and you can compute the second one as you produce the contents of the .gnu.version_d section.

251

Instead of having this DenseMap, could you move VerDefEntry's fields to Version?

253

Please update this comment to cover version definitions.

ELF/Symbols.h

143

This field belongs on Symbol, as it is a property of a symbol name (and this won't work correctly if a bitcode file defines a versioned symbol). Can you please move this to Symbol and add a test showing that LTO works correctly with this feature?

On that point, I'm not sure that we want all 3 of SharedSymbol::VersionId, Symbol::VersionScriptGlobal and this new field. Did you think about unifying them somehow?

[• rafael]

ELF/SymbolListFile.cpp

85

Do we really need to duplicate the parsing? We should be able to have a single parser and take different actions based on the name, no?

[grimar]

Hi Peter ! Thanks for usefull review. I hope to update this one soon. As soon as solve unifying problem you're mentioned.

ELF/OutputSections.cpp

1432

I have nothing against that if Rui and Rafael also support the new naming. That can be committed separatelly.

1437

Ok, I did not know about that.

1445

Thanks !

ELF/Symbols.h

143

Probably yes. I am working on unifying.

[grimar]

• Addressed review comments (all except creating test for LTO, I am working on it as never did such ones yet I think, will update patch later today I think).

Note: script parsing code in this version based on Rafael patch "[PATCH] Make local: optional.", to show how new functionality fits.

[grimar]

• Added LTO test.
• Fixed issue: sh_addralign field was not set for .gnu.version_d

[ruiu]

ELF/Config.h

38

Version(llvm::StringRef Name) : Name(Name) {}

ELF/OutputSections.cpp

566

Maybe the comment is too detailed and didn't actually say what it is doing? I'd say "Returns the number of version definition entries. Because the first entry is for the version definition itself, it is the number of versioned symbols plus one. Note that we don't support multiple versions yet."

1430

Other sections finalize() functions add strings to .dymstr. Is there any reason you didn't choose to do this in finalize()?

1455

You are writing two different types of records in this loop -- one for the first entry and the other for the remaining entries. It is better to separate the first entry from the others. Then you can remove all the IsBase dispatches from this loop.

ELF/SymbolListFile.cpp

77

Please rebase.

ELF/SymbolTable.cpp

528

Use range-based for loop.

ELF/Writer.cpp

913

Instead of adding isRequired() method, don't instantiate Out<ELFT>::VerSym if not needed. It's what we usually do for other sections.

[pcc]

ELF/OutputSections.cpp

1431

I think this should be the soname, not the output file name.

1462

Same here

1499

Fold this variable into its use.

ELF/OutputSections.h

256

Either .gnu.version_r or .gnu.version_d.

ELF/Symbols.cpp

269

This is the only place where we are using the VerDef and VersionScriptGlobal fields. Can you replace (VersionScriptGlobal || body()->symbol()->VerDef) here with VersionId != VER_NDX_LOCAL and remove both of those fields?

(Also, body()->symbol()-> is unnecessary here, as it just takes you back to the Symbol you started with.)

[grimar]

Thank you for reviews ! I`ll address your comments during my tomorrow.

[grimar]

• Addressed review comments.

[grimar]

ELF/Config.h

38

Done.

ELF/OutputSections.cpp

566

Changed.

1430

Moved to finalize(). I think there was some problem, not really remember what exactly in very first iteration of this patch (createDefs did more work that time). Now it is redundant.

1431

Checked that, both ld/gold use soname, and if it is not set then output file name is taken. Corrected the logic to match.

1455

Done.

1462

Fixed.

1499

Done.

ELF/OutputSections.h

256

Done.

ELF/SymbolListFile.cpp

77

Done.

ELF/SymbolTable.cpp

528

Done.

ELF/Symbols.cpp

269

Done.

ELF/Writer.cpp

913

Done.

[ruiu]

ELF/OutputSections.cpp

567

Make this a function comment.

1455

unsigned -> size_t.

1479

Just pass 1 instead of I.

ELF/SymbolListFile.cpp

115–117

So you are constructing a Version object in two steps -- first by passing only Version parameter to the constructor and then add Cur to its Globals array, right? That's a bit hard to read. Is there any way to do this in one step?

ELF/SymbolTable.cpp

528

size_t should be more accurate type (in practice they don't differ though.)

530

Increment this at end of the loop -- that's easier to read.

ELF/Symbols.h

423

Does unsigned VersionId : 16 save space?

ELF/Writer.cpp

121–123

So, instead of instantiating them unconditionally, can you instantiate them only when needed?

[grimar]

• Addressed review comments.

[grimar]

ELF/OutputSections.cpp

567

Done.

1455

Done.

1479

Done.

ELF/SymbolListFile.cpp

115–117

Oh. There was a bug here. It created new elf::Version for each global. Though that did not affect whole functionality, it is defenitely not what I wanted.
Fixed.

ELF/SymbolTable.cpp

528

Probably yes, but we also have VersionId of type uint16_t, so I am not sure how much it can be called accurate in total. Changed to size_t.

530

Done.

ELF/Symbols.h

423

72 vs 80, yes.
Moved it under uint8_t Binding; The same result but looks a bit nicer I think ?

ELF/Writer.cpp

121–123

Ah, sorry, I misunderstood at first. Fixed for Verdef (I think because of VerNeed it is not possible to perform that change for other 2, as Out<ELFT>::VerNeed->addSymbol(SS) called after creation of sections).

[ruiu]

LGTM

ELF/SymbolListFile.h

2

Remove.

ELF/SymbolTable.cpp

31

I'm wondering if this could be I++?

ELF/Writer.cpp

10–11

Add doesn't do anything if an argument is null. So you can remove the if guard.

[grimar]

In D21018#461946, @ruiu wrote:

LGTM

What a good morning :) Thanks for review, I'll commit in a few hours then.

ELF/SymbolTable.cpp

31

No, because each Version can have a list of globals. And all of them should receive the same VersionId.

ELF/Config.h

enum ELFKind {
   ELF32LEKind,
   ELF32BEKind,
   ELF64LEKind,
   ELF64BEKind
 };
 
 enum class BuildIdKind { None, Fnv1, Md5, Sha1, Hexstring };
 
+// This struct contains symbols version definition that
+// can be found in version script if it is used for link.
+struct Version {
+  Version(llvm::StringRef Name) { this->Name = Name; }
+  llvm::StringRef Name;
+  std::vector<llvm::StringRef> Globals;
+  size_t NameOff; // Offset in string table.
+};
+
 // This struct contains the global configuration for the linker.
 // Most fields are direct mapping from the command line options
 // and such fields have the same name as the corresponding options.
 // Most fields are initialized by the driver.
 struct Configuration {
   Symbol *EntrySym = nullptr;
   InputFile *FirstElf = nullptr;
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef LtoAAPipeline;
   llvm::StringRef LtoNewPmPasses;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
+  std::vector<Version> SymbolVersions;
   std::vector<llvm::StringRef> DynamicList;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
   std::vector<llvm::StringRef> VersionScriptGlobals;
   std::vector<uint8_t> BuildIdVector;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;

ELF/OutputSections.h

 #include "llvm/Support/MD5.h"
 #include "llvm/Support/SHA1.h"
 
 namespace lld {
 namespace elf {
 
 class SymbolBody;
 struct SectionPiece;
+struct Version;
 template <class ELFT> class SymbolTable;
 template <class ELFT> class SymbolTableSection;
 template <class ELFT> class StringTableSection;
 template <class ELFT> class EhInputSection;
 template <class ELFT> class InputSection;
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class MergeInputSection;
 template <class ELFT> class MipsReginfoInputSection;
private:
 
   // A vector of symbols and their string table offsets.
   std::vector<std::pair<SymbolBody *, size_t>> Symbols;
 };
 
 // For more information about .gnu.version and .gnu.version_r see:
 // https://www.akkadia.org/drepper/symbol-versioning
 
+// The .gnu.version_d section which has a section type of SHT_GNU_verdef shall
+// contain symbol version definitions. The number of entries in this section
+// shall be contained in the DT_VERDEFNUM entry of the .dynamic section.
+// The section shall contain an array of Elf_Verdef structures, optionally
+// followed by an array of Elf_Verdaux structures.
+template <class ELFT>
+class VersionDefinitionSection final : public OutputSectionBase<ELFT> {
+  typedef typename ELFT::Verdef Elf_Verdef;
+  typedef typename ELFT::Verdaux Elf_Verdaux;
+
+  size_t FileDefNameOff;
+
+public:
+  VersionDefinitionSection();
+  void finalize() override;
+  void writeTo(uint8_t *Buf) override;
+  void createDefs();
+};
+
 // The .gnu.version section specifies the required version of each symbol in the
 // dynamic symbol table. It contains one Elf_Versym for each dynamic symbol
 // table entry. An Elf_Versym is just a 16-bit integer that refers to a version
-// identifier defined in the .gnu.version_r section.
+// identifier defined in the .gnu.version_d section. The values 0 and 1 are
+// reserved. All other values are used for versions in the own object or in any
+// of the dependencies.
 template <class ELFT>
 class VersionTableSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::Versym Elf_Versym;
 
 public:
   VersionTableSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
+  bool isRequired();
 };
 
 // The .gnu.version_r section defines the version identifiers used by
 // .gnu.version. It contains a linked list of Elf_Verneed data structures. Each
 // Elf_Verneed specifies the version requirements for a single DSO, and contains
 // a reference to a linked list of Elf_Vernaux data structures which define the
 // mapping from version identifiers to version names.
 template <class ELFT>
 class VersionNeedSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::Verneed Elf_Verneed;
   typedef typename ELFT::Vernaux Elf_Vernaux;
 
   // A vector of shared files that need Elf_Verneed data structures and the
   // string table offsets of their sonames.
   std::vector<std::pair<SharedFile<ELFT> *, size_t>> Needed;
 
-  // The next available version identifier. Identifiers start at 2 because 0 and
-  // 1 are reserved.
-  unsigned NextIndex = 2;
+  // The next available version identifier.
+  unsigned NextIndex;
 
 public:
   VersionNeedSection();
   void addSymbol(SharedSymbol<ELFT> *SS);
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getNeedNum() const { return Needed.size(); }
 };
template <class ELFT> struct Out {
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
   static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;
   static StringTableSection<ELFT> *ShStrTab;
   static StringTableSection<ELFT> *StrTab;
   static SymbolTableSection<ELFT> *DynSymTab;
   static SymbolTableSection<ELFT> *SymTab;
+  static VersionDefinitionSection<ELFT> *VerDef;
   static VersionTableSection<ELFT> *VerSym;
   static VersionNeedSection<ELFT> *VerNeed;
   static Elf_Phdr *TlsPhdr;
   static OutputSectionBase<ELFT> *ElfHeader;
   static OutputSectionBase<ELFT> *ProgramHeaders;
 };
 
 template <class ELFT> BuildIdSection<ELFT> *Out<ELFT>::BuildId;

 template <class ELFT> PltSection<ELFT> *Out<ELFT>::Plt;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaDyn;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaPlt;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::DynStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::ShStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::StrTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::DynSymTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::SymTab;
+template <class ELFT> VersionDefinitionSection<ELFT> *Out<ELFT>::VerDef;
 template <class ELFT> VersionTableSection<ELFT> *Out<ELFT>::VerSym;
 template <class ELFT> VersionNeedSection<ELFT> *Out<ELFT>::VerNeed;
 template <class ELFT> typename ELFT::Phdr *Out<ELFT>::TlsPhdr;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::ElfHeader;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::ProgramHeaders;
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_ELF_OUTPUT_SECTIONS_H

ELF/OutputSections.cpp

std::stable_sort(Symbols.begin(), Symbols.end(),
                      return L.Hash % NBuckets < R.Hash % NBuckets;
                    });
 
   V.erase(Mid, V.end());
   for (const SymbolData &Sym : Symbols)
     V.push_back({Sym.Body, Sym.STName});
 }
 
+static unsigned getVerDefNum() {
+  // At least one version dependency must exist. Additional version dependencies
+  // can be present, the number being indicated by the vn_cnt value of
+  // Elf_Verdef. We do not support version hierarchies currently, so each
+  // Elf_Verdef associated exactly with single Elf_Verdaux for us.
+  // The base version definition is always present when version definitions, or
+  // symbol auto-reduction, have been applied to the file.
+  return Config->SymbolVersions.size() + 1;
+}
+
 template <class ELFT>
 DynamicSection<ELFT>::DynamicSection()
     : OutputSectionBase<ELFT>(".dynamic", SHT_DYNAMIC, SHF_ALLOC | SHF_WRITE) {
   Elf_Shdr &Header = this->Header;
   Header.sh_addralign = sizeof(uintX_t);
   Header.sh_entsize = ELFT::Is64Bits ? 16 : 8;
 
   // .dynamic section is not writable on MIPS.
template <class ELFT> void DynamicSection<ELFT>::finalize() {
   if (DtFlags)
     Add({DT_FLAGS, DtFlags});
   if (DtFlags1)
     Add({DT_FLAGS_1, DtFlags1});
 
   if (!Config->Entry.empty())
     Add({DT_DEBUG, (uint64_t)0});
 
-  if (size_t NeedNum = Out<ELFT>::VerNeed->getNeedNum()) {
+  if (Out<ELFT>::VerSym->isRequired())
     Add({DT_VERSYM, Out<ELFT>::VerSym});
+
+  if (!Config->SymbolVersions.empty()) {
+    Add({DT_VERDEF, Out<ELFT>::VerDef});
+    Add({DT_VERDEFNUM, getVerDefNum()});
+  }
+
+  if (size_t NeedNum = Out<ELFT>::VerNeed->getNeedNum()) {
     Add({DT_VERNEED, Out<ELFT>::VerNeed});
     Add({DT_VERNEEDNUM, NeedNum});
   }
 
   if (Config->EMachine == EM_MIPS) {
     Add({DT_MIPS_RLD_VERSION, 1});
     Add({DT_MIPS_FLAGS, RHF_NOTPOT});
     Add({DT_MIPS_BASE_ADDRESS, (uintX_t)Target->getVAStart()});
case SymbolBody::LazyObjectKind:
     break;
   case SymbolBody::DefinedBitcodeKind:
     llvm_unreachable("should have been replaced");
   }
   return nullptr;
 }
 
 template <class ELFT>
+VersionDefinitionSection<ELFT>::VersionDefinitionSection()
+    : OutputSectionBase<ELFT>(".gnu.version_d", SHT_GNU_verdef, SHF_ALLOC) {}
+
+template <class ELFT> void VersionDefinitionSection<ELFT>::createDefs() {
+  FileDefNameOff = Out<ELFT>::DynStrTab->addString(Config->OutputFile);
+  for (Version &V : Config->SymbolVersions)
+    V.NameOff = Out<ELFT>::DynStrTab->addString(V.Name);
+}
+
+template <class ELFT> void VersionDefinitionSection<ELFT>::finalize() {
+  this->Header.sh_size =
+      (sizeof(Elf_Verdef) + sizeof(Elf_Verdaux)) * getVerDefNum();
+  this->Header.sh_link = Out<ELFT>::DynStrTab->SectionIndex;
+  this->Header.sh_addralign = sizeof(uint32_t);
+
+  // sh_info should be set to the number of definitions. This fact is missed in
+  // documentation, but confirmed by binutils community:
+  // https://sourceware.org/ml/binutils/2014-11/msg00355.html
+  this->Header.sh_info = getVerDefNum();
+}
+
+template <class ELFT>
+void VersionDefinitionSection<ELFT>::writeTo(uint8_t *Buf) {
+  Elf_Verdef *Verdef = reinterpret_cast<Elf_Verdef *>(Buf);
+  Elf_Verdaux *Verdaux =
+      reinterpret_cast<Elf_Verdaux *>(Verdef + getVerDefNum());
+
+  size_t Cnt = Config->SymbolVersions.size() + 1;
+  for (size_t I = 0; I < Cnt; ++I) {
+    bool IsBase = I == 0;
+
+    Verdef->vd_version = 1;
+    Verdef->vd_flags = IsBase ? VER_FLG_BASE : 0;
+    Verdef->vd_ndx = I + 1;
+    Verdef->vd_cnt = 1;
+    Verdef->vd_hash = IsBase ? hashSysv(Config->OutputFile)
+                             : hashSysv(Config->SymbolVersions[I - 1].Name);
+
+    Verdef->vd_aux =
+        reinterpret_cast<char *>(Verdaux) - reinterpret_cast<char *>(Verdef);
+    Verdef->vd_next = sizeof(Elf_Verdef);
+    ++Verdef;
+
+    // Now write the single Elf_Verdaux entry.
+    Verdaux->vda_name =
+        IsBase ? FileDefNameOff : Config->SymbolVersions[I - 1].NameOff;
+    Verdaux->vda_next = 0;
+    ++Verdaux;
+  }
+
+  Verdef[-1].vd_next = 0;
+}
+
+template <class ELFT>
 VersionTableSection<ELFT>::VersionTableSection()
     : OutputSectionBase<ELFT>(".gnu.version", SHT_GNU_versym, SHF_ALLOC) {
   this->Header.sh_addralign = sizeof(uint16_t);
 }
 
 template <class ELFT> void VersionTableSection<ELFT>::finalize() {
   this->Header.sh_size =
       sizeof(Elf_Versym) * (Out<ELFT>::DynSymTab->getSymbols().size() + 1);
   this->Header.sh_entsize = sizeof(Elf_Versym);
   // At the moment of june 2016 GNU docs does not mention that sh_link field
   // should be set, but Sun docs do. Also readelf relies on this field.
   this->Header.sh_link = Out<ELFT>::DynSymTab->SectionIndex;
 }
 
 template <class ELFT> void VersionTableSection<ELFT>::writeTo(uint8_t *Buf) {
   auto *OutVersym = reinterpret_cast<Elf_Versym *>(Buf) + 1;
   for (const std::pair<SymbolBody *, size_t> &P :
        Out<ELFT>::DynSymTab->getSymbols()) {
-    if (auto *SS = dyn_cast<SharedSymbol<ELFT>>(P.first))
-      OutVersym->vs_index = SS->VersionId;
-    else
-      OutVersym->vs_index = VER_NDX_GLOBAL;
+    SymbolBody *Body = P.first;
+    OutVersym->vs_index = Body->symbol()->VersionId;
     ++OutVersym;
   }
 }
 
+template <class ELFT> bool VersionTableSection<ELFT>::isRequired() {
+  return !Config->SymbolVersions.empty() ||
+         Out<ELFT>::VerNeed->getNeedNum() != 0;
+}
+
 template <class ELFT>
 VersionNeedSection<ELFT>::VersionNeedSection()
     : OutputSectionBase<ELFT>(".gnu.version_r", SHT_GNU_verneed, SHF_ALLOC) {
   this->Header.sh_addralign = sizeof(uint32_t);
+
+  // Identifiers in verneed section start at 2 because 0 and 1 are reserved
+  // for VER_NDX_LOCAL and VER_NDX_GLOBAL.
+  // First identifiers are reserved by verdef section if it exist.
+  NextIndex = getVerDefNum() + 1;
 }
 
 template <class ELFT>
 void VersionNeedSection<ELFT>::addSymbol(SharedSymbol<ELFT> *SS) {
   if (!SS->Verdef) {
-    SS->VersionId = VER_NDX_GLOBAL;
+    SS->symbol()->VersionId = VER_NDX_GLOBAL;
     return;
   }
   SharedFile<ELFT> *F = SS->File;
   // If we don't already know that we need an Elf_Verneed for this DSO, prepare
   // to create one by adding it to our needed list and creating a dynstr entry
   // for the soname.
   if (F->VerdefMap.empty())
     Needed.push_back({F, Out<ELFT>::DynStrTab->addString(F->getSoName())});
   typename SharedFile<ELFT>::NeededVer &NV = F->VerdefMap[SS->Verdef];
   // If we don't already know that we need an Elf_Vernaux for this Elf_Verdef,
   // prepare to create one by allocating a version identifier and creating a
   // dynstr entry for the version name.
   if (NV.Index == 0) {
     NV.StrTab = Out<ELFT>::DynStrTab->addString(
         SS->File->getStringTable().data() + SS->Verdef->getAux()->vda_name);
     NV.Index = NextIndex++;
   }
-  SS->VersionId = NV.Index;
+  SS->symbol()->VersionId = NV.Index;
 }
 
 template <class ELFT> void VersionNeedSection<ELFT>::writeTo(uint8_t *Buf) {
   // The Elf_Verneeds need to appear first, followed by the Elf_Vernauxs.
   auto *Verneed = reinterpret_cast<Elf_Verneed *>(Buf);
   auto *Vernaux = reinterpret_cast<Elf_Vernaux *>(Verneed + Needed.size());
 
   for (std::pair<SharedFile<ELFT> *, size_t> &P : Needed) {

 template class VersionTableSection<ELF64LE>;
 template class VersionTableSection<ELF64BE>;
 
 template class VersionNeedSection<ELF32LE>;
 template class VersionNeedSection<ELF32BE>;
 template class VersionNeedSection<ELF64LE>;
 template class VersionNeedSection<ELF64BE>;
 
+template class VersionDefinitionSection<ELF32LE>;
+template class VersionDefinitionSection<ELF32BE>;
+template class VersionDefinitionSection<ELF64LE>;
+template class VersionDefinitionSection<ELF64BE>;
+
 template class BuildIdSection<ELF32LE>;
 template class BuildIdSection<ELF32BE>;
 template class BuildIdSection<ELF64LE>;
 template class BuildIdSection<ELF64BE>;
 
 template class BuildIdFnv1<ELF32LE>;
 template class BuildIdFnv1<ELF32BE>;
 template class BuildIdFnv1<ELF64LE>;

ELF/SymbolListFile.h

 //===- SymbolListFile.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_SYMBOL_LIST_FILE_H
 #define LLD_ELF_SYMBOL_LIST_FILE_H
 
 #include "lld/Core/LLVM.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace lld {
 namespace elf {
 
 void parseDynamicList(MemoryBufferRef MB);
 void parseVersionScript(MemoryBufferRef MB);
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/SymbolListFile.cpp

 //
 // No wildcards are supported, other than for the local entry. Symbol versioning
 // is also not supported.
 
 class VersionScriptParser final : public ScriptParserBase {
 public:
   VersionScriptParser(StringRef S) : ScriptParserBase(S) {}
 
+  ~VersionScriptParser() {
+    if (!hasLocal)
+      Config->VersionScript = false;
+  }
+
   void run();
 
 private:
-  void parseVersion();
+  bool hasLocal = false;
+  void parseVersion(StringRef Version);
+  void parseLocal();
+  void parseVersionSymbols(StringRef Version);
 };
 
-void VersionScriptParser::parseVersion() {
+void VersionScriptParser::parseVersion(StringRef Version) {
   expect("{");
   if (peek() == "global:") {
     next();
-    while (!Error) {
-      Config->VersionScriptGlobals.push_back(next());
-      expect(";");
-      if (peek() == "local:")
-        break;
-    }
-  }
+    parseVersionSymbols(Version);
+  if (peek() == "local:")
+    parseLocal();
+  else
+    parseVersionSymbols(Version);
+
+  expect("}");
+  expect(";");
+
+void VersionScriptParser::parseLocal() {
   expect("local:");
   expect("*");
   expect(";");
-  expect("}");
+  hasLocal = true;
+}
+
+void VersionScriptParser::parseVersionSymbols(StringRef Version) {
+  for (;;) {
+    StringRef Cur = peek();
+    if (Cur == "}" || Cur == "local:")
+      return;
+    next();
+    if (Version.empty()) {
+      Config->VersionScriptGlobals.push_back(Cur);
       expect(";");
+      continue;
+    }
+
+    Config->SymbolVersions.push_back(elf::Version(Version));
+    elf::Version &V = Config->SymbolVersions.back();
+    V.Globals.push_back(Cur);
+    expect(";");
+  }
 }
 
 void VersionScriptParser::run() {
   StringRef Msg = "anonymous version definition is used in "
                   "combination with other version definitions";
   if (peek() == "{") {
-    parseVersion();
+    parseVersion("");
     if (!atEOF())
       setError(Msg);
     return;
   }
 
   while (!atEOF() && !Error) {
-    if (next() == "{") {
+    StringRef Version = next();
+    if (Version == "{") {
       setError(Msg);
       return;
     }
-    parseVersion();
+    parseVersion(Version);
   }
 }
 
 void elf::parseVersionScript(MemoryBufferRef MB) {
   VersionScriptParser(MB.getBuffer()).run();
 }

ELF/SymbolTable.cpp

 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf;
 
 // All input object files must be for the same architecture
 // (e.g. it does not make sense to link x86 object files with
 // MIPS object files.) This function checks for that error.
 template <class ELFT> static bool isCompatible(InputFile *FileP) {
   auto *F = dyn_cast<ELFFileBase<ELFT>>(FileP);
   if (!F)
     return true;
   if (F->getELFKind() == Config->EKind && F->getEMachine() == Config->EMachine)
     return true;
for (StringRef S : Config->DynamicList)
     if (SymbolBody *B = find(S))
       B->symbol()->ExportDynamic = true;
 }
 
 // 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 (StringRef S : Config->VersionScriptGlobals)
       if (SymbolBody *B = find(S))
         B->symbol()->VersionScriptGlobal = true;
+    return;
+  }
+
+  // If we have symbols version declarations, we should
+  // assign version references for each symbol.
+  for (size_t I = 0, E = Config->SymbolVersions.size(); I < E; ++I) {
+    lld::elf::Version &V = Config->SymbolVersions[I];
+    for (StringRef Name : V.Globals)
+      if (SymbolBody *B = find(Name)) {
+        B->symbol()->VerDef = &V;
+        B->symbol()->VersionId = I + 2;
+      }
+  }
 }
 
 template class elf::SymbolTable<ELF32LE>;
 template class elf::SymbolTable<ELF32BE>;
 template class elf::SymbolTable<ELF64LE>;
 template class elf::SymbolTable<ELF64BE>;

ELF/Symbols.h

 namespace lld {
 namespace elf {
 
 class ArchiveFile;
 class BitcodeFile;
 class InputFile;
 class LazyObjectFile;
 class SymbolBody;
+struct Version;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class OutputSection;
 template <class ELFT> class OutputSectionBase;
 template <class ELFT> class SharedFile;
 
 // Returns a demangled C++ symbol name. If Name is not a mangled
 // name or the system does not provide __cxa_demangle function,
 // it returns the unmodified string.
public:
   // The Type field may also have this value. It means that we have not yet seen
   // a non-Lazy symbol with this name, so we don't know what its type is. The
   // Type field is normally set to this value for Lazy symbols unless we saw a
   // weak undefined symbol first, in which case we need to remember the original
   // symbol's type in order to check for TLS mismatches.
   enum { UnknownType = 255 };
 
   bool isSection() const { return Type == llvm::ELF::STT_SECTION; }
   bool isTls() const { return Type == llvm::ELF::STT_TLS; }
   bool isFunc() const { return Type == llvm::ELF::STT_FUNC; }
   bool isGnuIFunc() const { return Type == llvm::ELF::STT_GNU_IFUNC; }
   bool isObject() const { return Type == llvm::ELF::STT_OBJECT; }
   bool isFile() const { return Type == llvm::ELF::STT_FILE; }
 
 protected:
   struct Str {
     const char *S;
SharedSymbol(SharedFile<ELFT> *F, StringRef Name, const Elf_Sym &Sym,
     // IFuncs defined in DSOs are treated as functions by the static linker.
     if (isGnuIFunc())
       Type = llvm::ELF::STT_FUNC;
   }
 
   SharedFile<ELFT> *File;
   const Elf_Sym &Sym;
 
-  // This field is initially a pointer to the symbol's version definition. As
-  // symbols are added to the version table, this field is replaced with the
-  // version identifier to be stored in .gnu.version in the output file.
-  union {
-    const Elf_Verdef *Verdef;
-    uint16_t VersionId;
-  };
+  // This field is a pointer to the symbol's version definition.
 
   // OffsetInBss is significant only when needsCopy() is true.
   uintX_t OffsetInBss = 0;
 
   bool needsCopy() const { return this->NeedsCopyOrPltAddr && !this->isFunc(); }
 };
 
 // This class represents a symbol defined in an archive file. It is
struct Symbol {
   // executables, by most symbols in DSOs and executables built with
   // --export-dynamic, and by dynamic lists.
   unsigned ExportDynamic : 1;
 
   // This flag acts as an additional filter on the dynamic symbol list. It is
   // set if there is no version script, or if the symbol appears in the global
   // section of the version script.
   unsigned VersionScriptGlobal : 1;
 
+  // This is reference to version definition for symbol.
+  Version* VerDef = nullptr;
+
+  // Version definition index.
+  uint16_t VersionId = llvm::ELF::VER_NDX_GLOBAL;
+
   bool includeInDynsym() const;
   bool isWeak() const { return Binding == llvm::ELF::STB_WEAK; }
 
   // This field is used to store the Symbol's SymbolBody. This instantiation of
   // AlignedCharArrayUnion gives us a struct with a char array field that is
   // large and aligned enough to store any derived class of SymbolBody. We
   // assume that the size and alignment of ELF64LE symbols is sufficient for any
   // ELFT, and we verify this with the static_asserts in replaceBody.

ELF/Symbols.cpp

#else
   free(Buf);
   return S;
 #endif
 }
 
 bool Symbol::includeInDynsym() const {
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return false;
-  return (ExportDynamic && VersionScriptGlobal) || body()->isShared() ||
-         (body()->isUndefined() && Config->Shared);
+  return (ExportDynamic && (VersionScriptGlobal || body()->symbol()->VerDef)) ||
+         body()->isShared() || (body()->isUndefined() && Config->Shared);
 }
 
 template InputFile *SymbolBody::template getSourceFile<ELF32LE>();
 template InputFile *SymbolBody::template getSourceFile<ELF32BE>();
 template InputFile *SymbolBody::template getSourceFile<ELF64LE>();
 template InputFile *SymbolBody::template getSourceFile<ELF64BE>();
 
 template uint32_t SymbolBody::template getVA<ELF32LE>(uint32_t) const;

ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "Relocations.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
template <class ELFT> void elf::writeResult(SymbolTable<ELFT> *Symtab) {
   GotSection<ELFT> Got;
   InterpSection<ELFT> Interp;
   PltSection<ELFT> Plt;
   RelocationSection<ELFT> RelaDyn(Config->Rela ? ".rela.dyn" : ".rel.dyn",
                                   Config->ZCombreloc);
   StringTableSection<ELFT> DynStrTab(".dynstr", true);
   StringTableSection<ELFT> ShStrTab(".shstrtab", false);
   SymbolTableSection<ELFT> DynSymTab(DynStrTab);
+  VersionDefinitionSection<ELFT> VerDef;
   VersionTableSection<ELFT> VerSym;
   VersionNeedSection<ELFT> VerNeed;
 
   OutputSectionBase<ELFT> ElfHeader("", 0, SHF_ALLOC);
   ElfHeader.setSize(sizeof(Elf_Ehdr));
   OutputSectionBase<ELFT> ProgramHeaders("", 0, SHF_ALLOC);
   ProgramHeaders.updateAlignment(sizeof(uintX_t));
 
   // Instantiate optional output sections if they are needed.
   std::unique_ptr<BuildIdSection<ELFT>> BuildId;
template <class ELFT> void elf::writeResult(SymbolTable<ELFT> *Symtab) {
   Out<ELFT>::HashTab = HashTab.get();
   Out<ELFT>::Interp = &Interp;
   Out<ELFT>::Plt = &Plt;
   Out<ELFT>::RelaDyn = &RelaDyn;
   Out<ELFT>::RelaPlt = RelaPlt.get();
   Out<ELFT>::ShStrTab = &ShStrTab;
   Out<ELFT>::StrTab = StrTab.get();
   Out<ELFT>::SymTab = SymTabSec.get();
+  Out<ELFT>::VerDef = &VerDef;
   Out<ELFT>::VerSym = &VerSym;
   Out<ELFT>::VerNeed = &VerNeed;
   Out<ELFT>::MipsRldMap = MipsRldMap.get();
   Out<ELFT>::Opd = nullptr;
   Out<ELFT>::OpdBuf = nullptr;
   Out<ELFT>::TlsPhdr = nullptr;
   Out<ELFT>::ElfHeader = &ElfHeader;
   Out<ELFT>::ProgramHeaders = &ProgramHeaders;
Sec->forEachInputSection([&](InputSectionBase<ELFT> *S) {
         Sec->setSize(Off + S->getSize());
       } else if (auto *EH = dyn_cast<EhInputSection<ELFT>>(S)) {
         if (EH->RelocSection)
           scanRelocations(*EH, *EH->RelocSection);
       }
     });
   }
 
+  if (!Config->SymbolVersions.empty())
+    Out<ELFT>::VerDef->createDefs();
+
   // Now that we have defined all possible symbols including linker-
   // synthesized ones. Visit all symbols to give the finishing touches.
   std::vector<DefinedCommon *> CommonSymbols;
   for (Symbol *S : Symtab.getSymbols()) {
     SymbolBody *Body = S->body();
 
     // We only report undefined symbols in regular objects. This means that we
     // will accept an undefined reference in bitcode if it can be optimized out.
template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
 
   // This order is not the same as the final output order
   // because we sort the sections using their attributes below.
   Add(Out<ELFT>::SymTab);
   Add(Out<ELFT>::ShStrTab);
   Add(Out<ELFT>::StrTab);
   if (isOutputDynamic()) {
     Add(Out<ELFT>::DynSymTab);
-    if (Out<ELFT>::VerNeed->getNeedNum() != 0) {
+
+    if (Out<ELFT>::VerSym->isRequired())
       Add(Out<ELFT>::VerSym);
+    if (!Config->SymbolVersions.empty())
+      Add(Out<ELFT>::VerDef);
+    if (Out<ELFT>::VerNeed->getNeedNum() != 0)
       Add(Out<ELFT>::VerNeed);
-    }
+
     Add(Out<ELFT>::GnuHashTab);
     Add(Out<ELFT>::HashTab);
     Add(Out<ELFT>::Dynamic);
     Add(Out<ELFT>::DynStrTab);
     if (Out<ELFT>::RelaDyn->hasRelocs())
       Add(Out<ELFT>::RelaDyn);
     Add(Out<ELFT>::MipsRldMap);
   }

test/ELF/Inputs/verdef.s

+.text
+.globl _start
+_start:
+ callq a
+ callq b
+ callq c

test/ELF/lto/version-script.ll

+; REQUIRES: x86
+; RUN: llvm-as %s -o %t.o
+; RUN: echo "VERSION_1.0{ global: foo; local: *; }; VERSION_2.0{ global: bar; local: *; };" > %t.script
+; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 -shared --version-script %t.script -save-temps
+; RUN: llvm-dis < %t2.lto.bc | FileCheck %s
+; RUN: llvm-readobj -V -dyn-symbols %t2 | FileCheck --check-prefix=DSO %s
+
+target triple = "x86_64-unknown-linux-gnu"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+define void @foo() {
+  ret void
+}
+
+define void @bar() {
+  ret void
+}
+
+; CHECK: define void @foo()
+; CHECK: define void @bar()
+
+; DSO: DynamicSymbols [
+; DSO:   Symbol {
+; DSO:     Name: @ (0)
+; DSO:     Value: 0x0
+; DSO:     Size: 0
+; DSO:     Binding: Local
+; DSO:     Type: None
+; DSO:     Other: 0
+; DSO:     Section: Undefined
+; DSO:   }
+; DSO:   Symbol {
+; DSO:     Name: foo@@VERSION_1.0
+; DSO:     Value: 0x1000
+; DSO:     Size: 1
+; DSO:     Binding: Global
+; DSO:     Type: Function
+; DSO:     Other: 0
+; DSO:     Section: .text
+; DSO:   }
+; DSO:   Symbol {
+; DSO:     Name: bar@@VERSION_2.0
+; DSO:     Value: 0x1010
+; DSO:     Size: 1
+; DSO:     Binding: Global
+; DSO:     Type: Function
+; DSO:     Other: 0
+; DSO:     Section: .text
+; DSO:   }
+; DSO: ]

test/ELF/verdef.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: echo "LIBSAMPLE_1.0{  \
+# RUN:          global: a;   \
+# RUN:          local: *; }; \
+# RUN:       LIBSAMPLE_2.0{  \
+# RUN:          global: b;   \
+# RUN:          local: *; }; \
+# RUN:       LIBSAMPLE_3.0{  \
+# RUN:          global: c;   \
+# RUN:          local: *; };" > %t.script
+# RUN: ld.lld --version-script %t.script -shared %t.o -o %t.so
+# RUN: llvm-readobj -V -dyn-symbols %t.so | FileCheck --check-prefix=DSO %s
+
+# DSO:        Version symbols {
+# DSO-NEXT:   Section Name: .gnu.version
+# DSO-NEXT:   Address: 0x228
+# DSO-NEXT:   Offset: 0x228
+# 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: 2
+# DSO-NEXT:       Name: a@@LIBSAMPLE_1.0
+# DSO-NEXT:     }
+# DSO-NEXT:     Symbol {
+# DSO-NEXT:       Version: 3
+# DSO-NEXT:       Name: b@@LIBSAMPLE_2.0
+# DSO-NEXT:     }
+# DSO-NEXT:     Symbol {
+# DSO-NEXT:       Version: 4
+# DSO-NEXT:       Name: c@@LIBSAMPLE_3.0
+# DSO-NEXT:     }
+# DSO-NEXT:   ]
+# DSO-NEXT: }
+# DSO-NEXT: Version definition {
+# DSO-NEXT:   Section Name: .gnu.version_d
+# DSO-NEXT:   Address: 0x230
+# DSO-NEXT:   Offset: 0x230
+# DSO-NEXT:   Link: 5
+# DSO-NEXT:   Entries [
+# DSO-NEXT:     Entry {
+# DSO-NEXT:       Offset: 0x0
+# DSO-NEXT:       Rev: 1
+# DSO-NEXT:       Flags: 1
+# DSO-NEXT:       Index: 1
+# DSO-NEXT:       Cnt: 1
+# DSO-NEXT:       Hash: 146942095
+# DSO-NEXT:       Name:
+# DSO-NEXT:     }
+# DSO-NEXT:     Entry {
+# DSO-NEXT:       Offset: 0x14
+# DSO-NEXT:       Rev: 1
+# DSO-NEXT:       Flags: 0
+# DSO-NEXT:       Index: 2
+# DSO-NEXT:       Cnt: 1
+# DSO-NEXT:       Hash: 98457184
+# DSO-NEXT:       Name: LIBSAMPLE_1.0
+# DSO-NEXT:     }
+# DSO-NEXT:     Entry {
+# DSO-NEXT:       Offset: 0x28
+# DSO-NEXT:       Rev: 1
+# DSO-NEXT:       Flags: 0
+# DSO-NEXT:       Index: 3
+# DSO-NEXT:       Cnt: 1
+# DSO-NEXT:       Hash: 98456416
+# DSO-NEXT:       Name: LIBSAMPLE_2.0
+# DSO-NEXT:     }
+# DSO-NEXT:     Entry {
+# DSO-NEXT:       Offset: 0x3C
+# DSO-NEXT:       Rev: 1
+# DSO-NEXT:       Flags: 0
+# DSO-NEXT:       Index: 4
+# DSO-NEXT:       Cnt: 1
+# DSO-NEXT:       Hash: 98456672
+# DSO-NEXT:       Name: LIBSAMPLE_3.0
+# DSO-NEXT:     }
+# DSO-NEXT:   ]
+# DSO-NEXT: }
+# DSO-NEXT: SHT_GNU_verneed {
+# DSO-NEXT: }
+
+## Check that we can link agains DSO we produced.
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/verdef.s -o %tmain.o
+# RUN: ld.lld %tmain.o %t.so -o %tout
+# RUN: llvm-readobj -V %tout | FileCheck --check-prefix=MAIN %s
+
+# MAIN:      Version symbols {
+# MAIN-NEXT:   Section Name: .gnu.version
+# MAIN-NEXT:   Address: 0x10228
+# MAIN-NEXT:   Offset: 0x228
+# MAIN-NEXT:   Link: 1
+# MAIN-NEXT:   Symbols [
+# MAIN-NEXT:     Symbol {
+# MAIN-NEXT:       Version: 0
+# MAIN-NEXT:       Name: @
+# MAIN-NEXT:     }
+# MAIN-NEXT:     Symbol {
+# MAIN-NEXT:       Version: 2
+# MAIN-NEXT:       Name: a@LIBSAMPLE_1.0
+# MAIN-NEXT:     }
+# MAIN-NEXT:     Symbol {
+# MAIN-NEXT:       Version: 3
+# MAIN-NEXT:       Name: b@LIBSAMPLE_2.0
+# MAIN-NEXT:     }
+# MAIN-NEXT:     Symbol {
+# MAIN-NEXT:       Version: 4
+# MAIN-NEXT:       Name: c@LIBSAMPLE_3.0
+# MAIN-NEXT:     }
+# MAIN-NEXT:   ]
+# MAIN-NEXT: }
+# MAIN-NEXT: Version definition {
+# MAIN-NEXT: }
+
+.globl a
+.type  a,@function
+a:
+retq
+
+.globl b
+.type  b,@function
+b:
+retq
+
+.globl c
+.type  c,@function
+c:
+retq

test/ELF/version-script.s

 
 # RUN: echo "VERSION_1.0{      \
 # RUN:          global: foo1;  \
 # RUN:          local: *; };   \
 # RUN:       VERSION_2.0{      \
 # RUN:          global: foo3;  \
 # RUN:          local: *; }; " > %t4.script
 # RUN: ld.lld --version-script %t4.script -shared %t.o %t2.so -o %t4.so
-# RUN: llvm-readobj -dyn-symbols %t4.so | FileCheck --check-prefix=DSO %s
+# RUN: llvm-readobj -dyn-symbols %t4.so | FileCheck --check-prefix=VERDSO %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 | \

 # EXE-NEXT:     Size: 0
 # EXE-NEXT:     Binding: Global (0x1)
 # EXE-NEXT:     Type: None (0x0)
 # EXE-NEXT:     Other: 0
 # EXE-NEXT:     Section: .text (0x5)
 # EXE-NEXT:   }
 # EXE-NEXT: ]
 
+# VERDSO:      DynamicSymbols [
+# VERDSO-NEXT:   Symbol {
+# VERDSO-NEXT:     Name: @
+# VERDSO-NEXT:     Value: 0x0
+# VERDSO-NEXT:     Size: 0
+# VERDSO-NEXT:     Binding: Local
+# VERDSO-NEXT:     Type: None
+# VERDSO-NEXT:     Other: 0
+# VERDSO-NEXT:     Section: Undefined
+# VERDSO-NEXT:   }
+# VERDSO-NEXT:   Symbol {
+# VERDSO-NEXT:     Name: bar@
+# VERDSO-NEXT:     Value: 0x0
+# VERDSO-NEXT:     Size: 0
+# VERDSO-NEXT:     Binding: Global
+# VERDSO-NEXT:     Type: Function
+# VERDSO-NEXT:     Other: 0
+# VERDSO-NEXT:     Section: Undefined
+# VERDSO-NEXT:   }
+# VERDSO-NEXT:   Symbol {
+# VERDSO-NEXT:     Name: foo1@@VERSION_1.0
+# VERDSO-NEXT:     Value: 0x1000
+# VERDSO-NEXT:     Size: 0
+# VERDSO-NEXT:     Binding: Global
+# VERDSO-NEXT:     Type: None
+# VERDSO-NEXT:     Other: 0
+# VERDSO-NEXT:     Section: .text
+# VERDSO-NEXT:   }
+# VERDSO-NEXT:   Symbol {
+# VERDSO-NEXT:     Name: foo3@@VERSION_2.0
+# VERDSO-NEXT:     Value: 0x1007
+# VERDSO-NEXT:     Size: 0
+# VERDSO-NEXT:     Binding: Global
+# VERDSO-NEXT:     Type: None
+# VERDSO-NEXT:     Other: 0
+# VERDSO-NEXT:     Section: .text
+# VERDSO-NEXT:   }
+# VERDSO-NEXT: ]
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld -shared %t.o %t2.so -o %t.so
+# RUN: llvm-readobj -dyn-symbols %t.so | FileCheck --check-prefix=ALL %s
+
+# RUN: echo "{ global: foo1; foo3; };" > %t2.script
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld --version-script %t2.script -shared %t.o %t2.so -o %t.so
+# RUN: llvm-readobj -dyn-symbols %t.so | FileCheck --check-prefix=ALL %s
+
+# ALL:      DynamicSymbols [
+# ALL-NEXT:   Symbol {
+# ALL-NEXT:     Name: @
+# ALL-NEXT:     Value: 0x0
+# ALL-NEXT:     Size: 0
+# ALL-NEXT:     Binding: Local
+# ALL-NEXT:     Type: None
+# ALL-NEXT:     Other: 0
+# ALL-NEXT:     Section: Undefined
+# ALL-NEXT:   }
+# ALL-NEXT:  Symbol {
+# ALL-NEXT:    Name: _start@
+# ALL-NEXT:    Value:
+# ALL-NEXT:    Size: 0
+# ALL-NEXT:    Binding: Global
+# ALL-NEXT:    Type: None
+# ALL-NEXT:    Other: 0
+# ALL-NEXT:    Section: .text
+# ALL-NEXT:  }
+# ALL-NEXT:  Symbol {
+# ALL-NEXT:    Name: bar@
+# ALL-NEXT:    Value:
+# ALL-NEXT:    Size: 0
+# ALL-NEXT:    Binding: Global
+# ALL-NEXT:    Type: Function
+# ALL-NEXT:    Other: 0
+# ALL-NEXT:    Section: Undefined
+# ALL-NEXT:  }
+# ALL-NEXT:  Symbol {
+# ALL-NEXT:    Name: foo1@
+# ALL-NEXT:    Value:
+# ALL-NEXT:    Size: 0
+# ALL-NEXT:    Binding: Global
+# ALL-NEXT:    Type: None
+# ALL-NEXT:    Other: 0
+# ALL-NEXT:    Section: .text
+# ALL-NEXT:  }
+# ALL-NEXT:  Symbol {
+# ALL-NEXT:    Name: foo2@
+# ALL-NEXT:    Value:
+# ALL-NEXT:    Size: 0
+# ALL-NEXT:    Binding: Global
+# ALL-NEXT:    Type: None
+# ALL-NEXT:    Other: 0
+# ALL-NEXT:    Section: .text
+# ALL-NEXT:  }
+# ALL-NEXT:  Symbol {
+# ALL-NEXT:    Name: foo3@
+# ALL-NEXT:    Value:
+# ALL-NEXT:    Size: 0
+# ALL-NEXT:    Binding: Global
+# ALL-NEXT:    Type: None
+# ALL-NEXT:    Other: 0
+# ALL-NEXT:    Section: .text
+# ALL-NEXT:  }
+# ALL-NEXT: ]
+
 .globl foo1
 foo1:
   call bar@PLT
   ret
 
 .globl foo2
 foo2:
   ret