[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

Why do you need this?

ELF/SymbolListFile.cpp

84

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

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

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

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

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

129–131

Does this work?

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

134

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

129–131

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

134

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

129–131

Then how about defining a constructor that takes a StringRef?

[grimar]

• Addressed review comment.

ELF/SymbolListFile.cpp

129–131

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

1435

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

1440

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

1448

Grammar nitpick: "to the number of definitions"

1460

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

1536

Grammar nitpick: "if it exists"

1539

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?

265

Please update this comment to cover version definitions.

ELF/Symbols.h

142

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

84

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

1435

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

1440

Ok, I did not know about that.

1448

Thanks !

ELF/Symbols.h

142

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

569

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

1433

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

1458

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

81

Please rebase.

ELF/SymbolTable.cpp

519

Use range-based for loop.

ELF/Writer.cpp

918

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

1434

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

1465

Same here

1506–1507

Fold this variable into its use.

ELF/OutputSections.h

268

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

Done.

ELF/OutputSections.cpp

569

Changed.

1433

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.

1434

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

1458

Done.

1465

Fixed.

1506–1507

Done.

ELF/OutputSections.h

268

Done.

ELF/SymbolListFile.cpp

81

Done.

ELF/SymbolTable.cpp

519

Done.

ELF/Symbols.cpp

269 ↗

(On Diff #61091)

Done.

ELF/Writer.cpp

918

Done.

[ruiu]

ELF/OutputSections.cpp

570

Make this a function comment.

1458

unsigned -> size_t.

1482

Just pass 1 instead of I.

ELF/SymbolListFile.cpp

129–131

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

519

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

521

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

ELF/Symbols.h

430

Does unsigned VersionId : 16 save space?

ELF/Writer.cpp

122–124

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

[grimar]

• Addressed review comments.

[grimar]

ELF/OutputSections.cpp

570

Done.

1458

Done.

1482

Done.

ELF/SymbolListFile.cpp

129–131

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

519

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.

521

Done.

ELF/Symbols.h

430

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

ELF/Writer.cpp

122–124

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

16

Remove.

ELF/SymbolTable.cpp

19

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

ELF/Writer.cpp

11–12

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

19

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

ELF/Config.h

enum ELFKind {
   ELF64BEKind
 };
 
 enum class BuildIdKind { None, Fnv1, Md5, Sha1, Hexstring };
 
 // 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<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;
   bool BsymbolicFunctions;
   bool Demangle = true;
   bool DisableVerify;
   bool DiscardAll;

ELF/Driver.cpp

 
 bool elf::link(ArrayRef<const char *> Args, raw_ostream &Error) {
   HasError = false;
   ErrorOS = &Error;
 
   Configuration C;
   LinkerDriver D;
   ScriptConfiguration SC;
+  VersionScriptConfiguration VSC;
   Config = &C;
   Driver = &D;
   ScriptConfig = &SC;
+  VersionScriptConfig = &VSC;
 
   Driver->main(Args);
   return !HasError;
 }
 
 // Parses a linker -m option.
 static std::pair<ELFKind, uint16_t> parseEmulation(StringRef S) {
   if (S.endswith("_fbsd"))

ELF/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 #include "Driver.h"
 #include "Error.h"
 #include "InputSection.h"
+#include "SymbolListFile.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/raw_ostream.h"
 
elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   if (Index >= Sections.size() || !Sections[Index])
     fatal("invalid section index");
   InputSectionBase<ELFT> *S = Sections[Index];
   if (S == &InputSectionBase<ELFT>::Discarded)
     return S;
   return S->Repl;
 }
 
+static StringRef filterVersion(StringRef Name) {
+  StringRef Version;
+  std::tie(Name, Version) = Name.split('@');
+  // If name contains @@ that means default version.
+  if (Version.startswith("@"))
+    Version == Version.drop_front(1);
+  return Name;
+}
+
 template <class ELFT>
 SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   unsigned char Binding = Sym->getBinding();
   InputSectionBase<ELFT> *Sec = getSection(*Sym);
   if (Binding == STB_LOCAL) {
     if (Sym->st_shndx == SHN_UNDEF)
       return new (Alloc) Undefined(Sym->st_name, Sym->st_other, Sym->getType());
     return new (Alloc) DefinedRegular<ELFT>(*Sym, Sec);
   }
 
-  StringRef Name = check(Sym->getName(this->StringTable));
+  StringRef Name = filterVersion(check(Sym->getName(this->StringTable)));
 
   switch (Sym->st_shndx) {
   case SHN_UNDEF:
     return elf::Symtab<ELFT>::X
         ->addUndefined(Name, Binding, Sym->st_other, Sym->getType(), this)
         ->body();
   case SHN_COMMON:
     return elf::Symtab<ELFT>::X

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;
+
+  struct VerDefEntry {
+    // Version definition flags.
+    unsigned Flags;
+    // Name hash.
+    uint32_t Hash;
+    // Offset in string table.
+    size_t NameOff;
+    // Version definition index.
+    size_t Ndx;
+  };
+  llvm::DenseMap<Version *, VerDefEntry> VerDefs;
+
+public:
+  VersionDefinitionSection();
+  void finalize() override;
+  void writeTo(uint8_t *Buf) override;
+  void createDefs();
+
+  unsigned getVerDefId(Version *Ver);
+};
+
 // 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.
 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

 //===- OutputSections.cpp -------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OutputSections.h"
 #include "Config.h"
 #include "EhFrame.h"
 #include "LinkerScript.h"
+#include "SymbolListFile.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "lld/Core/Parallel.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SHA1.h"
 #include <map>
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 VersionScriptConfig->Versions.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 (VersionScriptConfig->HasNamedVersions) {
+    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() {
+  size_t I = 1;
+  VerDefs[nullptr] = {VER_FLG_BASE, hashSysv(Config->OutputFile),
+                      Out<ELFT>::DynStrTab->addString(Config->OutputFile), I++};
+  for (Version &V : VersionScriptConfig->Versions) {
+    VerDefs[&V] = {0, hashSysv(V.Name), Out<ELFT>::DynStrTab->addString(V.Name),
+                   I++};
+  } // Without this and opening bracket it does not compile under VS2015.
+}
+
+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;
+
+  // sh_info should be set to amount 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());
+
+  for (std::pair<Version *, VerDefEntry> &VD : VerDefs) {
+    VerDefEntry& Def = VD.second;
+
+    Verdef->vd_version = 1;
+    Verdef->vd_flags = Def.Flags;
+    Verdef->vd_ndx = Def.Ndx;
+    Verdef->vd_cnt = 1;
+    Verdef->vd_hash = Def.Hash;
+
+    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 = Def.NameOff;
+    Verdaux->vda_next = 0;
+    ++Verdaux;
+  }
+
+  Verdef[-1].vd_next = 0;
+}
+
+template <class ELFT>
+unsigned VersionDefinitionSection<ELFT>::getVerDefId(Version *Ver) {
+  return VerDefs.find(Ver)->second.Ndx;
+}
+
+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;
+  auto *OutVersym = reinterpret_cast<Elf_Versym *>(Buf);
   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
-      // The reserved identifier for a non-versioned global symbol.
-      OutVersym->vs_index = 1;
     ++OutVersym;
-  }
+
+    SymbolBody *Body = P.first;
+    if (auto *SS = dyn_cast<SharedSymbol<ELFT>>(Body)) {
+      OutVersym->vs_index = SS->VersionId;
+      continue;
+    }
+    if (!VersionScriptConfig->HasNamedVersions ||
+        !Body->symbol()->VersionScriptGlobal) {
+      OutVersym->vs_index = VER_NDX_GLOBAL;
+      continue;
+    }
+
+    OutVersym->vs_index = Out<ELFT>::VerDef->getVerDefId(Body->VerDef);
+  }
+
+template <class ELFT> bool VersionTableSection<ELFT>::isRequired() {
+  return VersionScriptConfig->HasNamedVersions ||
+         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 is exist.
+  NextIndex = 2;
+  if (VersionScriptConfig->HasNamedVersions)
+    NextIndex = std::max(getVerDefNum() + 1, NextIndex);
 }
 
 template <class ELFT>
 void VersionNeedSection<ELFT>::addSymbol(SharedSymbol<ELFT> *SS) {
   if (!SS->Verdef) {
     // The reserved identifier for a non-versioned global symbol.
     SS->VersionId = 1;
     return;

 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);
 
+struct Version {
+  StringRef Name;
+  StringRef Parent;
+  std::vector<llvm::StringRef> Globals;
+};
+
+// VersionScriptConfiguration holds version script parse results.
+struct VersionScriptConfiguration {
+  std::vector<Version> Versions;
+  bool HasNamedVersions = false;
+};
+
+extern VersionScriptConfiguration *VersionScriptConfig;
+
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/SymbolListFile.cpp

 #include "Config.h"
 #include "ScriptParser.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::elf;
 
+VersionScriptConfiguration *elf::VersionScriptConfig;
+
 // Parse the --dynamic-list argument.  A dynamic list is in the form
 //
 //  { symbol1; symbol2; [...]; symbolN };
 //
 // Multiple groups can be defined in the same file and they are merged
 // in only one definition.
 
 class DynamicListParser final : public ScriptParserBase {

 // version script syntax:
 //
 //  { [ global: symbol1; symbol2; [...]; symbolN; ] local: *; };
 //
 // No wildcards are supported, other than for the local entry. Symbol versioning
 // is also not supported.
 
 class VersionScriptParser final : public ScriptParserBase {
+  VersionScriptConfiguration &Opt = *VersionScriptConfig;
+
 public:
   VersionScriptParser(StringRef S) : ScriptParserBase(S) {}
 
   void run();
 };
 
 void VersionScriptParser::run() {
+  bool HasAnonymousTag = false;
+  while (!atEOF() && !Error) {
+    Opt.Versions.push_back(Version());
+    Version &V = Opt.Versions.back();
+
+    StringRef Peek = peek();
+    if (Peek != "{")
+      V.Name = next();
+
+    HasAnonymousTag |= V.Name == "";
+    // It can be only single anonymous version at once.
+    if (HasAnonymousTag && Opt.Versions.size() > 1)
+      setError("anonymous version tag cannot be "
+               "combined with other version tag");
+
     expect("{");
-  if (peek() == "global:") {
+    Peek = peek();
+    if (Peek == "global:") {
       next();
       while (!Error) {
-      Config->VersionScriptGlobals.push_back(next());
+        V.Globals.push_back(next());
         expect(";");
-      if (peek() == "local:")
+        Peek = peek();
+        if (Peek == "local:" || Peek == "}")
           break;
       }
     }
+
+    if (Peek == "local:") {
       expect("local:");
       expect("*");
       expect(";");
+    }
+
     expect("}");
+    if (peek() != ";")
+      V.Parent = next();
     expect(";");
-  if (!atEOF())
-    setError("expected EOF");
+  }
+  Opt.HasNamedVersions = !HasAnonymousTag && !Opt.Versions.empty();
 }
 
 void elf::parseVersionScript(MemoryBufferRef MB) {
   VersionScriptParser(MB.getBuffer()).run();
 }

ELF/SymbolTable.cpp

 // all input files to the symbol table. The symbol table is basically
 // a hash table with the logic to resolve symbol name conflicts using
 // the symbol types.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "Error.h"
+#include "SymbolListFile.h"
 #include "Symbols.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/Support/StringSaver.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
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() {
-  for (StringRef S : Config->VersionScriptGlobals)
-    if (SymbolBody *B = find(S))
+  for (Version &V : VersionScriptConfig->Versions)
+    for (StringRef Name : V.Globals)
+      if (SymbolBody *B = find(Name)) {
         B->symbol()->VersionScriptGlobal = true;
+        B->VerDef = &V;
+      }
 }
 
 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 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 };
 
+  // This is reference to version definition for symbol.
+  Version* VerDef = nullptr;
+
   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 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;
 
   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/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 "SymbolListFile.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.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.updateAlign(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 (VersionScriptConfig->HasNamedVersions)
+    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();
 
     // Set "used" bit for --as-needed.
     if (S->IsUsedInRegularObj && !S->isWeak())
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 (VersionScriptConfig->HasNamedVersions)
+      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/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 %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:
+# DSO-NEXT:       Name:
+# DSO-NEXT:     }
+# DSO-NEXT:     Entry {
+# DSO-NEXT:       Offset: 0x14
+# 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:     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: 2
+# DSO-NEXT:       Cnt: 1
+# DSO-NEXT:       Hash: 98457184
+# DSO-NEXT:       Name: LIBSAMPLE_1.0
+# DSO-NEXT:     }
+# DSO-NEXT:   ]
+# 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