Compact symbols from 96 to 88 bytes

[• rafael]

Summary

By using an index instead of a pointer for verdef we can put the index next to the alignment field. This uses the otherwise wasted area and reduces the shared symbol size.

By itself the performance change of this is in the noise, but I have a followup patch to remove another 8 bytes that improves performance when combined with this.

[ruiu]

ELF/InputFiles.h

309

If you can trigger this by passing a malformed object file, this should be a fatal() instead of assert().

ELF/SymbolTable.cpp

481

unsigned -> uint32_t for consistency.

ELF/SyntheticSections.cpp

2309

You are using getVerdef only here. I might delete that function and just make the member variable public.

[• rafael]

Address review comments.

[ruiu]

LGTM

[• espindola]

r320449

ELF/InputFiles.h

template <class ELFT> class SharedFile : public ELFFileBase<ELFT> {
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Versym Elf_Versym;
 
   std::vector<StringRef> Undefs;
   const Elf_Shdr *VersymSec = nullptr;
   const Elf_Shdr *VerdefSec = nullptr;
 
 public:
+  std::vector<const Elf_Verdef *> Verdefs;
   std::string SoName;
 
   llvm::ArrayRef<StringRef> getUndefinedSymbols() { return Undefs; }
 
   static bool classof(const InputFile *F) {
     return F->kind() == Base::SharedKind;
   }
 
   SharedFile(MemoryBufferRef M, StringRef DefaultSoName);
 
   void parseSoName();
   void parseRest();
   std::vector<const Elf_Verdef *> parseVerdefs(const Elf_Versym *&Versym);
 
   struct NeededVer {
     // The string table offset of the version name in the output file.
     size_t StrTab;
 
     // The version identifier for this version name.
     uint16_t Index;
   };
 

ELF/InputFiles.cpp

SharedFile<ELFT>::parseVerdefs(const Elf_Versym *&Versym) {
 
   return Verdefs;
 }
 
 // Fully parse the shared object file. This must be called after parseSoName().
 template <class ELFT> void SharedFile<ELFT>::parseRest() {
   // Create mapping from version identifiers to Elf_Verdef entries.
   const Elf_Versym *Versym = nullptr;
-  std::vector<const Elf_Verdef *> Verdefs = parseVerdefs(Versym);
+  Verdefs = parseVerdefs(Versym);
 
   ArrayRef<Elf_Shdr> Sections = CHECK(this->getObj().sections(), this);
 
   // Add symbols to the symbol table.
   Elf_Sym_Range Syms = this->getGlobalELFSyms();
   for (const Elf_Sym &Sym : Syms) {
     unsigned VersymIndex = 0;
     if (Versym) {
for (const Elf_Sym &Sym : Syms) {
     if (VersymIndex != VER_NDX_GLOBAL) {
       if (VersymIndex >= Verdefs.size()) {
         error("corrupt input file: version definition index " +
               Twine(VersymIndex) + " for symbol " + Name +
               " is out of bounds\n>>> defined in " + toString(this));
         continue;
       }
       Ver = Verdefs[VersymIndex];
+    } else {
+      VersymIndex = 0;
     }
 
     // We do not usually care about alignments of data in shared object
     // files because the loader takes care of it. However, if we promote a
     // DSO symbol to point to .bss due to copy relocation, we need to keep
     // the original alignment requirements. We infer it here.
     uint64_t Alignment = 1;
     if (Sym.st_value)
       Alignment = 1ULL << countTrailingZeros((uint64_t)Sym.st_value);
     if (0 < Sym.st_shndx && Sym.st_shndx < Sections.size()) {
       uint64_t SecAlign = Sections[Sym.st_shndx].sh_addralign;
       Alignment = std::min(Alignment, SecAlign);
     }
     if (Alignment > UINT32_MAX)
       error(toString(this) + ": alignment too large: " + Name);
 
     if (!Hidden)
-      Symtab->addShared(Name, this, Sym, Alignment, Ver);
+      Symtab->addShared(Name, this, Sym, Alignment, VersymIndex);
 
     // Also add the symbol with the versioned name to handle undefined symbols
     // with explicit versions.
     if (Ver) {
       StringRef VerName = this->StringTable.data() + Ver->getAux()->vda_name;
       Name = Saver.save(Name + "@" + VerName);
-      Symtab->addShared(Name, this, Sym, Alignment, Ver);
+      Symtab->addShared(Name, this, Sym, Alignment, VersymIndex);
     }
   }
 }
 
 static ELFKind getBitcodeELFKind(const Triple &T) {
   if (T.isLittleEndian())
     return T.isArch64Bit() ? ELF64LEKind : ELF32LEKind;
   return T.isArch64Bit() ? ELF64BEKind : ELF32BEKind;

ELF/SymbolTable.h

public:
   template <class ELFT>
   Symbol *addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
                      uint64_t Value, uint64_t Size, uint8_t Binding,
                      SectionBase *Section, InputFile *File);
 
   template <class ELFT>
   void addShared(StringRef Name, SharedFile<ELFT> *F,
                  const typename ELFT::Sym &Sym, uint32_t Alignment,
-                 const typename ELFT::Verdef *Verdef);
+                 uint32_t VerdefIndex);
 
   template <class ELFT>
   Symbol *addLazyArchive(StringRef Name, ArchiveFile *F,
                          const llvm::object::Archive::Symbol S);
 
   template <class ELFT> void addLazyObject(StringRef Name, LazyObjFile &Obj);
 
   Symbol *addBitcode(StringRef Name, uint8_t Binding, uint8_t StOther,

ELF/SymbolTable.cpp

else if (Cmp == 0)
     reportDuplicate<ELFT>(S, dyn_cast_or_null<InputSectionBase>(Section),
                           Value);
   return S;
 }
 
 template <typename ELFT>
 void SymbolTable::addShared(StringRef Name, SharedFile<ELFT> *File,
                             const typename ELFT::Sym &Sym, uint32_t Alignment,
-                            const typename ELFT::Verdef *Verdef) {
+                            uint32_t VerdefIndex) {
   // DSO symbols do not affect visibility in the output, so we pass STV_DEFAULT
   // as the visibility, which will leave the visibility in the symbol table
   // unchanged.
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, Sym.getType(), STV_DEFAULT,
                                     /*CanOmitFromDynSym*/ true, File);
   // Make sure we preempt DSO symbols with default visibility.
   if (Sym.getVisibility() == STV_DEFAULT)
     S->ExportDynamic = true;
 
   // An undefined symbol with non default visibility must be satisfied
   // in the same DSO.
   if (WasInserted || ((S->isUndefined() || S->isLazy()) &&
                       S->getVisibility() == STV_DEFAULT)) {
     uint8_t Binding = S->Binding;
     replaceSymbol<SharedSymbol>(S, File, Name, Sym.getBinding(), Sym.st_other,
                                 Sym.getType(), Sym.st_value, Sym.st_size,
-                                Alignment, Verdef);
+                                Alignment, VerdefIndex);
     if (!WasInserted) {
       S->Binding = Binding;
       if (!S->isWeak() && !Config->GcSections)
         File->IsNeeded = true;
     }
   }
 }
 

 
 template void SymbolTable::addLazyObject<ELF32LE>(StringRef, LazyObjFile &);
 template void SymbolTable::addLazyObject<ELF32BE>(StringRef, LazyObjFile &);
 template void SymbolTable::addLazyObject<ELF64LE>(StringRef, LazyObjFile &);
 template void SymbolTable::addLazyObject<ELF64BE>(StringRef, LazyObjFile &);
 
 template void SymbolTable::addShared<ELF32LE>(StringRef, SharedFile<ELF32LE> *,
                                               const typename ELF32LE::Sym &,
-                                              uint32_t Alignment,
-                                              const typename ELF32LE::Verdef *);
+                                              uint32_t Alignment, uint32_t);
 template void SymbolTable::addShared<ELF32BE>(StringRef, SharedFile<ELF32BE> *,
                                               const typename ELF32BE::Sym &,
-                                              uint32_t Alignment,
-                                              const typename ELF32BE::Verdef *);
+                                              uint32_t Alignment, uint32_t);
 template void SymbolTable::addShared<ELF64LE>(StringRef, SharedFile<ELF64LE> *,
                                               const typename ELF64LE::Sym &,
-                                              uint32_t Alignment,
-                                              const typename ELF64LE::Verdef *);
+                                              uint32_t Alignment, uint32_t);
 template void SymbolTable::addShared<ELF64BE>(StringRef, SharedFile<ELF64BE> *,
                                               const typename ELF64BE::Sym &,
-                                              uint32_t Alignment,
-                                              const typename ELF64BE::Verdef *);
+                                              uint32_t Alignment, uint32_t);
 
 template void SymbolTable::fetchIfLazy<ELF32LE>(StringRef);
 template void SymbolTable::fetchIfLazy<ELF32BE>(StringRef);
 template void SymbolTable::fetchIfLazy<ELF64LE>(StringRef);
 template void SymbolTable::fetchIfLazy<ELF64BE>(StringRef);
 
 template void SymbolTable::scanShlibUndefined<ELF32LE>();
 template void SymbolTable::scanShlibUndefined<ELF32BE>();
 template void SymbolTable::scanShlibUndefined<ELF64LE>();
 template void SymbolTable::scanShlibUndefined<ELF64BE>();

ELF/Symbols.h

 };
 
 class SharedSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) { return S->kind() == SharedKind; }
 
   SharedSymbol(InputFile *File, StringRef Name, uint8_t Binding,
                uint8_t StOther, uint8_t Type, uint64_t Value, uint64_t Size,
-               uint32_t Alignment, const void *Verdef)
-      : Symbol(SharedKind, File, Name, Binding, StOther, Type), Verdef(Verdef),
-        Value(Value), Size(Size), Alignment(Alignment) {
+               uint32_t Alignment, uint32_t VerdefIndex)
+      : Symbol(SharedKind, File, Name, Binding, StOther, Type), Value(Value),
+        Size(Size), VerdefIndex(VerdefIndex), Alignment(Alignment) {
     // GNU ifunc is a mechanism to allow user-supplied functions to
     // resolve PLT slot values at load-time. This is contrary to the
     // regualr symbol resolution scheme in which symbols are resolved just
     // by name. Using this hook, you can program how symbols are solved
     // for you program. For example, you can make "memcpy" to be resolved
     // to a SSE-enabled version of memcpy only when a machine running the
     // program supports the SSE instruction set.
     //
     // Naturally, such symbols should always be called through their PLT
     // slots. What GNU ifunc symbols point to are resolver functions, and
     // calling them directly doesn't make sense (unless you are writing a
     // loader).
     //
     // For DSO symbols, we always call them through PLT slots anyway.
     // So there's no difference between GNU ifunc and regular function
     // symbols if they are in DSOs. So we can handle GNU_IFUNC as FUNC.
     if (this->Type == llvm::ELF::STT_GNU_IFUNC)
       this->Type = llvm::ELF::STT_FUNC;
   }
 
   template <class ELFT> SharedFile<ELFT> *getFile() const {
     return cast<SharedFile<ELFT>>(File);
   }
 
-  // This field is a pointer to the symbol's version definition.
-  const void *Verdef;
-
   // If not null, there is a copy relocation to this section.
   InputSection *CopyRelSec = nullptr;
 
   uint64_t Value; // st_value
   uint64_t Size;  // st_size
+
+  // This field is a index to the symbol's version definition.
+  uint32_t VerdefIndex;
+
   uint32_t Alignment;
 };
 
 // This represents a symbol that is not yet in the link, but we know where to
 // find it if needed. If the resolver finds both Undefined and Lazy for the same
 // name, it will ask the Lazy to load a file.
 //
 // A special complication is the handling of weak undefined symbols. They should

ELF/SyntheticSections.cpp

VersionNeedSection<ELFT>::VersionNeedSection()
   // 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 *SS) {
-  auto *Ver = reinterpret_cast<const typename ELFT::Verdef *>(SS->Verdef);
+  SharedFile<ELFT> *File = SS->getFile<ELFT>();
+  const typename ELFT::Verdef *Ver = File->Verdefs[SS->VerdefIndex];
   if (!Ver) {
     SS->VersionId = VER_NDX_GLOBAL;
     return;
   }
 
-  SharedFile<ELFT> *File = SS->getFile<ELFT>();
-
   // 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 (File->VerdefMap.empty())
     Needed.push_back({File, InX::DynStrTab->addString(File->SoName)});
   typename SharedFile<ELFT>::NeededVer &NV = File->VerdefMap[Ver];
   // 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