[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

84 ↗

(On Diff #60014)

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.

121 ↗

(On Diff #60014)

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 ↗

(On Diff #60014)

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

84 ↗

(On Diff #60014)

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.

121 ↗

(On Diff #60014)

Done.

ELF/SymbolListFile.h

23–27 ↗

(On Diff #60014)

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 ↗

(On Diff #60151)

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

106–108 ↗

(On Diff #60151)

Does this work?

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

111 ↗

(On Diff #60151)

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 ↗

(On Diff #60151)

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 ↗

(On Diff #60151)

Done.

254 ↗

(On Diff #60151)

Done.

ELF/SymbolListFile.cpp

106–108 ↗

(On Diff #60151)

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).

111 ↗

(On Diff #60151)

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

106–108 ↗

(On Diff #60328)

Then how about defining a constructor that takes a StringRef?

[grimar]

• Addressed review comment.

ELF/SymbolListFile.cpp

106–108 ↗

(On Diff #60328)

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 ↗

(On Diff #60437)

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

1437 ↗

(On Diff #60437)

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

1445 ↗

(On Diff #60437)

Grammar nitpick: "to the number of definitions"

1457 ↗

(On Diff #60437)

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

1532 ↗

(On Diff #60437)

Grammar nitpick: "if it exists"

1535 ↗

(On Diff #60437)

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

ELF/OutputSections.h

245–248 ↗

(On Diff #60437)

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 ↗

(On Diff #60437)

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

262 ↗

(On Diff #60437)

Please update this comment to cover version definitions.

ELF/Symbols.h

142 ↗

(On Diff #60437)

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

80 ↗

(On Diff #60437)

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 ↗

(On Diff #60437)

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

1437 ↗

(On Diff #60437)

Ok, I did not know about that.

1445 ↗

(On Diff #60437)

Thanks !

ELF/Symbols.h

142 ↗

(On Diff #60437)

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 ↗

(On Diff #61091)

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

ELF/OutputSections.cpp

566 ↗

(On Diff #61091)

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 ↗

(On Diff #61091)

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

1455 ↗

(On Diff #61091)

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 ↗

(On Diff #61091)

Please rebase.

ELF/SymbolTable.cpp

528 ↗

(On Diff #61091)

Use range-based for loop.

ELF/Writer.cpp

913 ↗

(On Diff #61091)

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 ↗

(On Diff #61091)

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

1462 ↗

(On Diff #61091)

Same here

1499 ↗

(On Diff #61091)

Fold this variable into its use.

ELF/OutputSections.h

256 ↗

(On Diff #61091)

Either .gnu.version_r or .gnu.version_d.

ELF/Symbols.cpp

269 ↗

(On Diff #61091)

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 ↗

(On Diff #61091)

Done.

ELF/OutputSections.cpp

566 ↗

(On Diff #61091)

Changed.

1430 ↗

(On Diff #61091)

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 ↗

(On Diff #61091)

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 ↗

(On Diff #61091)

Done.

1462 ↗

(On Diff #61091)

Fixed.

1499 ↗

(On Diff #61091)

Done.

ELF/OutputSections.h

256 ↗

(On Diff #61091)

Done.

ELF/SymbolListFile.cpp

77 ↗

(On Diff #61091)

Done.

ELF/SymbolTable.cpp

528 ↗

(On Diff #61091)

Done.

ELF/Symbols.cpp

269 ↗

(On Diff #61091)

Done.

ELF/Writer.cpp

913 ↗

(On Diff #61091)

Done.

[ruiu]

ELF/OutputSections.cpp

567 ↗

(On Diff #61163)

Make this a function comment.

1453 ↗

(On Diff #61163)

unsigned -> size_t.

1477 ↗

(On Diff #61163)

Just pass 1 instead of I.

ELF/SymbolListFile.cpp

119–121 ↗

(On Diff #61163)

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

531 ↗

(On Diff #61163)

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

533 ↗

(On Diff #61163)

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

ELF/Symbols.h

420 ↗

(On Diff #61163)

Does unsigned VersionId : 16 save space?

ELF/Writer.cpp

121–123 ↗

(On Diff #61163)

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

[grimar]

• Addressed review comments.

[grimar]

ELF/OutputSections.cpp

567 ↗

(On Diff #61163)

Done.

1453 ↗

(On Diff #61163)

Done.

1477 ↗

(On Diff #61163)

Done.

ELF/SymbolListFile.cpp

119–121 ↗

(On Diff #61163)

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

531 ↗

(On Diff #61163)

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.

533 ↗

(On Diff #61163)

Done.

ELF/Symbols.h

420 ↗

(On Diff #61163)

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 ↗

(On Diff #61163)

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

14 ↗

(On Diff #61194)

Remove.

ELF/SymbolTable.cpp

535 ↗

(On Diff #61194)

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

ELF/Writer.cpp

915–916 ↗

(On Diff #61194)

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

535 ↗

(On Diff #61194)

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

lld/trunk/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) : 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;

lld/trunk/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;
+
+  unsigned FileDefNameOff;
+
+public:
+  VersionDefinitionSection();
+  void finalize() override;
+  void writeTo(uint8_t *Buf) override;
+};
+
 // 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 either .gnu.version_r or .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;
 };
 
 // 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

lld/trunk/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});
 }
 
+// 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.
+static unsigned getVerDefNum() { 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()) {
+  bool HasVerNeed = Out<ELFT>::VerNeed->getNeedNum() != 0;
+  if (HasVerNeed || Out<ELFT>::VerDef)
     Add({DT_VERSYM, Out<ELFT>::VerSym});
+  if (Out<ELFT>::VerDef) {
+    Add({DT_VERDEF, Out<ELFT>::VerDef});
+    Add({DT_VERDEFNUM, getVerDefNum()});
+  }
+  if (HasVerNeed) {
     Add({DT_VERNEED, Out<ELFT>::VerNeed});
-    Add({DT_VERNEEDNUM, NeedNum});
+    Add({DT_VERNEEDNUM, Out<ELFT>::VerNeed->getNeedNum()});
   }
 
   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()});
     Add({DT_MIPS_SYMTABNO, Out<ELFT>::DynSymTab->getNumSymbols()});
     Add({DT_MIPS_LOCAL_GOTNO, Out<ELFT>::Got->getMipsLocalEntriesNum()});
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) {}
+
+static StringRef getFileDefName() {
+  if (!Config->SoName.empty())
+    return Config->SoName;
+  return Config->OutputFile;
+}
+
+template <class ELFT> void VersionDefinitionSection<ELFT>::finalize() {
+  FileDefNameOff = Out<ELFT>::DynStrTab->addString(getFileDefName());
+  for (Version &V : Config->SymbolVersions)
+    V.NameOff = Out<ELFT>::DynStrTab->addString(V.Name);
+
+  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 Elf_Verdef, class Elf_Verdaux>
+static void writeDefinition(Elf_Verdef *&Verdef, Elf_Verdaux *&Verdaux,
+                            uint32_t Flags, uint32_t Index, StringRef Name,
+                            size_t StrTabOffset) {
+  Verdef->vd_version = 1;
+  Verdef->vd_cnt = 1;
+  Verdef->vd_aux =
+      reinterpret_cast<char *>(Verdaux) - reinterpret_cast<char *>(Verdef);
+  Verdef->vd_next = sizeof(Elf_Verdef);
+
+  Verdef->vd_flags = Flags;
+  Verdef->vd_ndx = Index;
+  Verdef->vd_hash = hashSysv(Name);
+  ++Verdef;
+
+  Verdaux->vda_name = StrTabOffset;
+  Verdaux->vda_next = 0;
+  ++Verdaux;
+}
+
+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());
+
+  writeDefinition(Verdef, Verdaux, VER_FLG_BASE, 1, getFileDefName(),
+                  FileDefNameOff);
+
+  uint32_t I = 2;
+  for (Version &V : Config->SymbolVersions)
+    writeDefinition(Verdef, Verdaux, 0 /* Flags */, I++, V.Name, V.NameOff);
+
+  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;
+    OutVersym->vs_index = P.first->symbol()->VersionId;
     ++OutVersym;
   }
 }
 
 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>;

lld/trunk/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

lld/trunk/ELF/SymbolListFile.cpp

 
 class VersionScriptParser final : public ScriptParserBase {
 public:
   VersionScriptParser(StringRef S) : ScriptParserBase(S) {}
 
   void run();
 
 private:
-  void parseVersion();
+  void parseVersion(StringRef Version);
   void parseLocal();
-  void parseVersionSymbols();
+  void parseVersionSymbols(StringRef Version);
 };
 
-void VersionScriptParser::parseVersion() {
+void VersionScriptParser::parseVersion(StringRef Version) {
   expect("{");
   if (peek() == "global:") {
     next();
-    parseVersionSymbols();
+    parseVersionSymbols(Version);
   }
   if (peek() == "local:")
     parseLocal();
   else
-    parseVersionSymbols();
+    parseVersionSymbols(Version);
 
   expect("}");
   expect(";");
 }
 
 void VersionScriptParser::parseLocal() {
   expect("local:");
   expect("*");
   expect(";");
   Config->VersionScriptGlobalByDefault = false;
 }
 
-void VersionScriptParser::parseVersionSymbols() {
+void VersionScriptParser::parseVersionSymbols(StringRef Version) {
+  std::vector<StringRef> *Globals;
+  if (Version.empty()) {
+    Globals = &Config->VersionScriptGlobals;
+  } else {
+    Config->SymbolVersions.push_back(elf::Version(Version));
+    Globals = &Config->SymbolVersions.back().Globals;
+  }
+
   for (;;) {
     StringRef Cur = peek();
     if (Cur == "}" || Cur == "local:")
       return;
     next();
-    Config->VersionScriptGlobals.push_back(Cur);
+    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() == "{") {
+    if (peek() == "{") {
       setError(Msg);
       return;
     }
-    parseVersion();
+    parseVersion(next());
   }
 }
 
 void elf::parseVersionScript(MemoryBufferRef MB) {
   VersionScriptParser(MB.getBuffer()).run();
 }

lld/trunk/ELF/SymbolTable.cpp

std::pair<Symbol *, bool> SymbolTable<ELFT>::insert(StringRef Name) {
   auto P = Symtab.insert(std::make_pair(Name, NumSyms));
   Symbol *Sym;
   if (P.second) {
     Sym = new (Alloc) Symbol;
     Sym->Binding = STB_WEAK;
     Sym->Visibility = STV_DEFAULT;
     Sym->IsUsedInRegularObj = false;
     Sym->ExportDynamic = false;
-    Sym->VersionScriptGlobal = Config->VersionScriptGlobalByDefault;
+    if (Config->VersionScriptGlobalByDefault)
+      Sym->VersionId = VER_NDX_GLOBAL;
+    else
+      Sym->VersionId = VER_NDX_LOCAL;
     SymVector.push_back(Sym);
   } else {
     Sym = SymVector[P.first->second];
   }
   return {Sym, P.second};
 }
 
 // Find an existing symbol or create and insert a new one, then apply the given
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;
+        B->symbol()->VersionId = VER_NDX_GLOBAL;
+    return;
+  }
+
+  // If we have symbols version declarations, we should
+  // assign version references for each symbol.
+  size_t I = 2;
+  for (Version &V : Config->SymbolVersions) {
+    for (StringRef Name : V.Globals)
+      if (SymbolBody *B = find(Name))
+        B->symbol()->VersionId = I;
+    ++I;
+  }
 }
 
 template class elf::SymbolTable<ELF32LE>;
 template class elf::SymbolTable<ELF32BE>;
 template class elf::SymbolTable<ELF64LE>;
 template class elf::SymbolTable<ELF64BE>;

lld/trunk/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.
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 {
   // Symbol binding. This is on the Symbol to track changes during resolution.
   // In particular:
   // An undefined weak is still weak when it resolves to a shared library.
   // An undefined weak will not fetch archive members, but we have to remember
   // it is weak.
   uint8_t Binding;
 
+  // Version definition index.
+  uint16_t VersionId;
+
   // Symbol visibility. This is the computed minimum visibility of all
   // observed non-DSO symbols.
   unsigned Visibility : 2;
 
   // True if the symbol was used for linking and thus need to be added to the
   // output file's symbol table. This is true for all symbols except for
   // unreferenced DSO symbols and bitcode symbols that are unreferenced except
   // by other bitcode objects.
   unsigned IsUsedInRegularObj : 1;
 
   // If this flag is true and the symbol has protected or default visibility, it
   // will appear in .dynsym. This flag is set by interposable DSO symbols in
   // 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;
-
   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.

lld/trunk/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() ||
+  return (ExportDynamic && VersionId != VER_NDX_LOCAL) || 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>();
 

lld/trunk/ELF/Writer.cpp

template <class ELFT> void elf::writeResult(SymbolTable<ELFT> *Symtab) {
   std::unique_ptr<EhFrameHeader<ELFT>> EhFrameHdr;
   std::unique_ptr<GnuHashTableSection<ELFT>> GnuHashTab;
   std::unique_ptr<GotPltSection<ELFT>> GotPlt;
   std::unique_ptr<HashTableSection<ELFT>> HashTab;
   std::unique_ptr<RelocationSection<ELFT>> RelaPlt;
   std::unique_ptr<StringTableSection<ELFT>> StrTab;
   std::unique_ptr<SymbolTableSection<ELFT>> SymTabSec;
   std::unique_ptr<OutputSection<ELFT>> MipsRldMap;
+  std::unique_ptr<VersionDefinitionSection<ELFT>> VerDef;
 
   if (Config->BuildId == BuildIdKind::Fnv1)
     BuildId.reset(new BuildIdFnv1<ELFT>);
   else if (Config->BuildId == BuildIdKind::Md5)
     BuildId.reset(new BuildIdMd5<ELFT>);
   else if (Config->BuildId == BuildIdKind::Sha1)
     BuildId.reset(new BuildIdSha1<ELFT>);
   else if (Config->BuildId == BuildIdKind::Hexstring)
if (Config->EMachine == EM_MIPS && !Config->Shared) {
     // of executable file which is pointed to by the DT_MIPS_RLD_MAP entry.
     // See "Dynamic section" in Chapter 5 in the following document:
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
     MipsRldMap.reset(new OutputSection<ELFT>(".rld_map", SHT_PROGBITS,
                                              SHF_ALLOC | SHF_WRITE));
     MipsRldMap->setSize(sizeof(uintX_t));
     MipsRldMap->updateAlignment(sizeof(uintX_t));
   }
+  if (!Config->SymbolVersions.empty())
+    VerDef.reset(new VersionDefinitionSection<ELFT>());
 
   Out<ELFT>::Bss = &Bss;
   Out<ELFT>::BuildId = BuildId.get();
   Out<ELFT>::DynStrTab = &DynStrTab;
   Out<ELFT>::DynSymTab = &DynSymTab;
   Out<ELFT>::Dynamic = &Dynamic;
   Out<ELFT>::EhFrame = &EhFrame;
   Out<ELFT>::EhFrameHdr = EhFrameHdr.get();
   Out<ELFT>::GnuHashTab = GnuHashTab.get();
   Out<ELFT>::Got = &Got;
   Out<ELFT>::GotPlt = GotPlt.get();
   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.get();
   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;
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) {
+
+    bool HasVerNeed = Out<ELFT>::VerNeed->getNeedNum() != 0;
+    if (Out<ELFT>::VerDef || HasVerNeed)
       Add(Out<ELFT>::VerSym);
+    if (Out<ELFT>::VerDef)
+      Add(Out<ELFT>::VerDef);
+    if (HasVerNeed)
       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);
   }

lld/trunk/test/ELF/Inputs/verdef.s

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

lld/trunk/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: ]

lld/trunk/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

lld/trunk/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