Index: ELF/Config.h =================================================================== --- ELF/Config.h +++ ELF/Config.h @@ -32,6 +32,14 @@ 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 Globals; +}; + // 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. @@ -50,6 +58,7 @@ llvm::StringRef SoName; llvm::StringRef Sysroot; std::string RPath; + std::vector SymbolVersions; std::vector DynamicList; std::vector SearchPaths; std::vector Undefined; Index: ELF/OutputSections.h =================================================================== --- ELF/OutputSections.h +++ ELF/OutputSections.h @@ -24,6 +24,7 @@ class SymbolBody; struct SectionPiece; +struct Version; template class SymbolTable; template class SymbolTableSection; template class StringTableSection; @@ -230,6 +231,34 @@ // 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 VersionDefinitionSection final : public OutputSectionBase { + typedef typename ELFT::Verdef Elf_Verdef; + typedef typename ELFT::Verdaux Elf_Verdaux; + + struct VerDefEntry { + uint32_t Flags; // Version definition flags. + uint32_t Hash; // Name hash. + size_t NameOff; // Offset in string table. + size_t Ndx; // Version definition index. + }; + + llvm::DenseMap 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 @@ -242,6 +271,7 @@ VersionTableSection(); void finalize() override; void writeTo(uint8_t *Buf) override; + bool isRequired(); }; // The .gnu.version_r section defines the version identifiers used by @@ -258,9 +288,8 @@ // string table offsets of their sonames. std::vector *, 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(); @@ -612,6 +641,7 @@ static StringTableSection *StrTab; static SymbolTableSection *DynSymTab; static SymbolTableSection *SymTab; + static VersionDefinitionSection *VerDef; static VersionTableSection *VerSym; static VersionNeedSection *VerNeed; static Elf_Phdr *TlsPhdr; @@ -640,6 +670,7 @@ template StringTableSection *Out::StrTab; template SymbolTableSection *Out::DynSymTab; template SymbolTableSection *Out::SymTab; +template VersionDefinitionSection *Out::VerDef; template VersionTableSection *Out::VerSym; template VersionNeedSection *Out::VerNeed; template typename ELFT::Phdr *Out::TlsPhdr; Index: ELF/OutputSections.cpp =================================================================== --- ELF/OutputSections.cpp +++ ELF/OutputSections.cpp @@ -563,6 +563,16 @@ 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 DynamicSection::DynamicSection() : OutputSectionBase(".dynamic", SHT_DYNAMIC, SHF_ALLOC | SHF_WRITE) { @@ -665,8 +675,15 @@ if (!Config->Entry.empty()) Add({DT_DEBUG, (uint64_t)0}); - if (size_t NeedNum = Out::VerNeed->getNeedNum()) { + if (Out::VerSym->isRequired()) Add({DT_VERSYM, Out::VerSym}); + + if (!Config->SymbolVersions.empty()) { + Add({DT_VERDEF, Out::VerDef}); + Add({DT_VERDEFNUM, getVerDefNum()}); + } + + if (size_t NeedNum = Out::VerNeed->getNeedNum()) { Add({DT_VERNEED, Out::VerNeed}); Add({DT_VERNEEDNUM, NeedNum}); } @@ -1407,6 +1424,65 @@ } template +VersionDefinitionSection::VersionDefinitionSection() + : OutputSectionBase(".gnu.version_d", SHT_GNU_verdef, SHF_ALLOC) {} + +template void VersionDefinitionSection::createDefs() { + size_t I = 1; + VerDefs[nullptr] = {VER_FLG_BASE, hashSysv(Config->OutputFile), + Out::DynStrTab->addString(Config->OutputFile), I++}; + for (Version &V : Config->SymbolVersions) { + VerDefs[&V] = {0, hashSysv(V.Name), Out::DynStrTab->addString(V.Name), + I++}; + } // Without this and opening bracket it does not compile under VS2015. +} + +template void VersionDefinitionSection::finalize() { + this->Header.sh_size = + (sizeof(Elf_Verdef) + sizeof(Elf_Verdaux)) * getVerDefNum(); + this->Header.sh_link = Out::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 +void VersionDefinitionSection::writeTo(uint8_t *Buf) { + Elf_Verdef *Verdef = reinterpret_cast(Buf); + Elf_Verdaux *Verdaux = + reinterpret_cast(Verdef + getVerDefNum()); + + for (std::pair &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(Verdaux) - reinterpret_cast(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 +unsigned VersionDefinitionSection::getVerDefId(Version *Ver) { + return VerDefs.find(Ver)->second.Ndx; +} + +template VersionTableSection::VersionTableSection() : OutputSectionBase(".gnu.version", SHT_GNU_versym, SHF_ALLOC) { this->Header.sh_addralign = sizeof(uint16_t); @@ -1422,21 +1498,41 @@ } template void VersionTableSection::writeTo(uint8_t *Buf) { - auto *OutVersym = reinterpret_cast(Buf) + 1; + auto *OutVersym = reinterpret_cast(Buf); for (const std::pair &P : Out::DynSymTab->getSymbols()) { - if (auto *SS = dyn_cast>(P.first)) + ++OutVersym; + + SymbolBody *Body = P.first; + if (auto *SS = dyn_cast>(Body)) { OutVersym->vs_index = SS->VersionId; - else + continue; + } + if (!Body->VerDef) { OutVersym->vs_index = VER_NDX_GLOBAL; - ++OutVersym; + continue; + } + + OutVersym->vs_index = Out::VerDef->getVerDefId(Body->VerDef); } } +template bool VersionTableSection::isRequired() { + return !Config->SymbolVersions.empty() || + Out::VerNeed->getNeedNum() != 0; +} + template VersionNeedSection::VersionNeedSection() : OutputSectionBase(".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 (!Config->SymbolVersions.empty()) + NextIndex = std::max(getVerDefNum() + 1, NextIndex); } template @@ -1716,6 +1812,11 @@ template class VersionNeedSection; template class VersionNeedSection; +template class VersionDefinitionSection; +template class VersionDefinitionSection; +template class VersionDefinitionSection; +template class VersionDefinitionSection; + template class BuildIdSection; template class BuildIdSection; template class BuildIdSection; Index: ELF/SymbolListFile.h =================================================================== --- ELF/SymbolListFile.h +++ ELF/SymbolListFile.h @@ -11,6 +11,7 @@ #define LLD_ELF_SYMBOL_LIST_FILE_H #include "lld/Core/LLVM.h" +#include "llvm/ADT/MapVector.h" #include "llvm/Support/MemoryBuffer.h" namespace lld { Index: ELF/SymbolListFile.cpp =================================================================== --- ELF/SymbolListFile.cpp +++ ELF/SymbolListFile.cpp @@ -75,9 +75,13 @@ VersionScriptParser(StringRef S) : ScriptParserBase(S) {} void run(); + +private: + void parseUnversionedScript(); + void parseVersionedScript(); }; -void VersionScriptParser::run() { +void VersionScriptParser::parseUnversionedScript() { expect("{"); if (peek() == "global:") { next(); @@ -97,6 +101,43 @@ setError("expected EOF"); } +void VersionScriptParser::parseVersionedScript() { + while (!atEOF() && !Error) { + Config->SymbolVersions.push_back(Version(next())); + Version &V = Config->SymbolVersions.back(); + + expect("{"); + if (peek() == "global:") { + next(); + while (!Error) { + V.Globals.push_back(next()); + expect(";"); + if (peek() == "local:" || peek() == "}") + break; + } + } + + if (peek() == "local:") { + expect("local:"); + expect("*"); + expect(";"); + } + + expect("}"); + // Skip parent if exist. + if (peek() != ";") + next(); + expect(";"); + } +} + +void VersionScriptParser::run() { + if (peek() == "{") + parseUnversionedScript(); + else + parseVersionedScript(); +} + void elf::parseVersionScript(MemoryBufferRef MB) { VersionScriptParser(MB.getBuffer()).run(); } Index: ELF/SymbolTable.cpp =================================================================== --- ELF/SymbolTable.cpp +++ ELF/SymbolTable.cpp @@ -510,9 +510,21 @@ // symbols with the VersionScriptGlobal flag, which acts as a filter on the // dynamic symbol table. template void SymbolTable::scanVersionScript() { - for (StringRef S : Config->VersionScriptGlobals) - if (SymbolBody *B = find(S)) - B->symbol()->VersionScriptGlobal = true; + // 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 (Version &V : Config->SymbolVersions) + for (StringRef Name : V.Globals) + if (SymbolBody *B = find(Name)) + B->VerDef = &V; } template class elf::SymbolTable; Index: ELF/Symbols.h =================================================================== --- ELF/Symbols.h +++ ELF/Symbols.h @@ -29,6 +29,7 @@ class BitcodeFile; class InputFile; class SymbolBody; +struct Version; template class ObjectFile; template class OutputSection; template class OutputSectionBase; @@ -137,6 +138,9 @@ // 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; } Index: ELF/Symbols.cpp =================================================================== --- ELF/Symbols.cpp +++ ELF/Symbols.cpp @@ -263,8 +263,8 @@ 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()->VerDef)) || + body()->isShared() || (body()->isUndefined() && Config->Shared); } template InputFile *SymbolBody::template getSourceFile(); Index: ELF/Writer.cpp =================================================================== --- ELF/Writer.cpp +++ ELF/Writer.cpp @@ -118,6 +118,7 @@ StringTableSection DynStrTab(".dynstr", true); StringTableSection ShStrTab(".shstrtab", false); SymbolTableSection DynSymTab(DynStrTab); + VersionDefinitionSection VerDef; VersionTableSection VerSym; VersionNeedSection VerNeed; @@ -189,6 +190,7 @@ Out::ShStrTab = &ShStrTab; Out::StrTab = StrTab.get(); Out::SymTab = SymTabSec.get(); + Out::VerDef = &VerDef; Out::VerSym = &VerSym; Out::VerNeed = &VerNeed; Out::MipsRldMap = MipsRldMap.get(); @@ -807,6 +809,9 @@ }); } + if (!Config->SymbolVersions.empty()) + Out::VerDef->createDefs(); + // Now that we have defined all possible symbols including linker- // synthesized ones. Visit all symbols to give the finishing touches. std::vector CommonSymbols; @@ -904,10 +909,14 @@ Add(Out::StrTab); if (isOutputDynamic()) { Add(Out::DynSymTab); - if (Out::VerNeed->getNeedNum() != 0) { + + if (Out::VerSym->isRequired()) Add(Out::VerSym); + if (!Config->SymbolVersions.empty()) + Add(Out::VerDef); + if (Out::VerNeed->getNeedNum() != 0) Add(Out::VerNeed); - } + Add(Out::GnuHashTab); Add(Out::HashTab); Add(Out::Dynamic); Index: test/ELF/Inputs/verdef.s =================================================================== --- test/ELF/Inputs/verdef.s +++ test/ELF/Inputs/verdef.s @@ -0,0 +1,6 @@ +.text +.globl _start +_start: + callq a + callq b + callq c Index: test/ELF/verdef.s =================================================================== --- test/ELF/verdef.s +++ test/ELF/verdef.s @@ -0,0 +1,131 @@ +# 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: 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: 4 +# DSO-NEXT: Cnt: 1 +# DSO-NEXT: Hash: 98456672 +# DSO-NEXT: Name: LIBSAMPLE_3.0 +# DSO-NEXT: } +# DSO-NEXT: Entry { +# DSO-NEXT: Offset: 0x3C +# 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: ] +# 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