Don't store names in the symbols

[• espindola]

Summary

Most of the linker doesn't have to handle symbol names. The parts that do are close enough to the symbol table that they can get the name from there.

This deletes the boilerplate for tracking whether we have a name or name offset. It also reduces SymbolBody from 56 to 40 bytes on x86_64.

The performance results are more mixed than what I was expecting, but I think the patch is still worth it:

the gold plugin

master 0.389837796
patch  0.390047270

clang

master 0.669623963
patch  0.666252931

llvm-as

master 0.035799643
patch  0.035869600

the gold plugin fsds

master 0.417012576
patch  0.415979779

clang fsds

master 0.722732074
patch  0.719288980

llvm-as fsds

master 0.032511485
patch  0.032528634

scylla

master 4.915247943
patch  4.978490188

[ruiu]

If this is neutral in terms of performance, I wouldn't probably do this, as it feels pretty natural to me to have symbols have names, even though we do not use them often in the linker. It is also useful for debugging and easy to understand.

In addition to that, this change seems to make it hard to parallelize file parsing. Currently, most part of file parsing does not interact with other parts of the linker, so we can call them in parallel. However, if you pass Resolve to each parsing function, it is no longer possible.

ELF/InputFiles.h

83–84

I'd define three functions instead of dispatching three ways in a single function.

115

Is there any reason to use llvm::function_read instead of std::function?

[• rafael]

If this is neutral in terms of performance, I wouldn't probably do this, as it feels pretty natural to me to have symbols have names, even though we do not use them often in the linker. It is also useful for debugging and easy to understand.

Fair enough.

In addition to that, this change seems to make it hard to parallelize file parsing. Currently, most part of file parsing does not interact with other parts of the linker, so we can call them in parallel. However, if you pass Resolve to each parsing function, it is no longer possible.

True. I did try keeping just the offset, but that requires most of the
changes in this patch anyway. Otherwise we compute the size of global
symbols multiple times.

Comment at: ELF/InputFiles.h:115
@@ -113,2 +114,3 @@

explicit ObjectFile(MemoryBufferRef M);

• void parse(llvm::DenseSet<StringRef> &ComdatGroups);

+ void parse(llvm::function_ref<void(StringRef, SymbolBody *)> Resolve,

+ llvm::DenseSet<StringRef> &ComdatGroups);

Is there any reason to use llvm::function_read instead of std::function?

It is supposed to be faster for when we don't need to store it
somewhere. I confess I don't know the details.

Cheers,
Rafael

ELF/InputFiles.h

public:
   uint8_t getOSABI() const {
     return getObj().getHeader()->e_ident[llvm::ELF::EI_OSABI];
   }
 
   StringRef getStringTable() const { return StringTable; }
 
   uint32_t getSectionIndex(const Elf_Sym &Sym) const;
 
+  enum WhichSymbols { LOCAL_SYMBOLS, GLOBAL_SYMBOLS, ALL_SYMBOLS };
+  Elf_Sym_Range getElfSymbols(WhichSymbols);
+
 protected:
   llvm::object::ELFFile<ELFT> ELFObj;
   const Elf_Shdr *Symtab = nullptr;
   ArrayRef<Elf_Word> SymtabSHNDX;
   StringRef StringTable;
   void initStringTable();
-  Elf_Sym_Range getElfSymbols(bool OnlyGlobals);
 };
 
 // .o file.
 template <class ELFT> class ObjectFile : public ELFFileBase<ELFT> {
   typedef ELFFileBase<ELFT> Base;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::SymRange Elf_Sym_Range;
   typedef typename ELFT::Word Elf_Word;
   typedef typename ELFT::uint uintX_t;
 
   StringRef getShtGroupSignature(const Elf_Shdr &Sec);
   ArrayRef<Elf_Word> getShtGroupEntries(const Elf_Shdr &Sec);
 
 public:
   static bool classof(const InputFile *F) {
     return F->kind() == Base::ObjectKind;
   }
 
   ArrayRef<SymbolBody *> getSymbols();
-  ArrayRef<SymbolBody *> getLocalSymbols();
   ArrayRef<SymbolBody *> getNonLocalSymbols();
 
   explicit ObjectFile(MemoryBufferRef M);
-  void parse(llvm::DenseSet<StringRef> &ComdatGroups);
+  void parse(llvm::function_ref<void(StringRef, SymbolBody *)> Resolve,
+             llvm::DenseSet<StringRef> &ComdatGroups);
 
   ArrayRef<InputSectionBase<ELFT> *> getSections() const { return Sections; }
   InputSectionBase<ELFT> *getSection(const Elf_Sym &Sym) const;
 
   SymbolBody &getSymbolBody(uint32_t SymbolIndex) const {
     return *SymbolBodies[SymbolIndex];
   }
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
 
   // Get MIPS GP0 value defined by this file. This value represents the gp value
   // used to create the relocatable object and required to support
   // R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.
   uint32_t getMipsGp0() const;
 
   // The number is the offset in the string table. It will be used as the
   // st_name of the symbol.
   std::vector<std::pair<const DefinedRegular<ELFT> *, unsigned>> KeptLocalSyms;
 
 private:
   void initializeSections(llvm::DenseSet<StringRef> &ComdatGroups);
-  void initializeSymbols();
+  void
+  initializeSymbols(llvm::function_ref<void(StringRef, SymbolBody *)> Resolve);
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Shdr &Sec);
   InputSectionBase<ELFT> *createInputSection(const Elf_Shdr &Sec);
 
-  SymbolBody *createSymbolBody(const Elf_Sym *Sym);
+  std::pair<StringRef, SymbolBody *> createSymbolBody(const Elf_Sym *Sym);
 
   // List of all sections defined by this file.
   std::vector<InputSectionBase<ELFT> *> Sections;
 
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;
 
   // MIPS .reginfo section defined by this file.
private:
   std::vector<Lazy> LazySymbols;
   llvm::DenseSet<uint64_t> Seen;
 };
 
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M);
   static bool classof(const InputFile *F);
-  void parse(llvm::DenseSet<StringRef> &ComdatGroups);
+  void parse(llvm::function_ref<void(StringRef, SymbolBody *)> Resolve,
+             llvm::DenseSet<StringRef> &ComdatGroups);
   ArrayRef<SymbolBody *> getSymbols() { return SymbolBodies; }
   static bool shouldSkip(const llvm::object::BasicSymbolRef &Sym);
 
 private:
   std::vector<SymbolBody *> SymbolBodies;
   llvm::BumpPtrAllocator Alloc;
   llvm::StringSaver Saver{Alloc};
-  SymbolBody *
+  std::pair<StringRef, SymbolBody *>
   createSymbolBody(const llvm::DenseSet<const llvm::Comdat *> &KeptComdats,
                    const llvm::object::IRObjectFile &Obj,
                    const llvm::object::BasicSymbolRef &Sym);
 };
 
 // .so file.
 template <class ELFT> class SharedFile : public ELFFileBase<ELFT> {
   typedef ELFFileBase<ELFT> Base;
public:
 
   static bool classof(const InputFile *F) {
     return F->kind() == Base::SharedKind;
   }
 
   explicit SharedFile(MemoryBufferRef M);
 
   void parseSoName();
-  void parseRest();
+  void parseRest(llvm::function_ref<void(StringRef, SymbolBody *)> Resolve);
 
   // Used for --as-needed
   bool AsNeeded = false;
   bool IsUsed = false;
   bool isNeeded() const { return !AsNeeded || IsUsed; }
 };
 
 std::unique_ptr<InputFile> createObjectFile(MemoryBufferRef MB,
                                             StringRef ArchiveName = "");
 std::unique_ptr<InputFile> createSharedFile(MemoryBufferRef MB);
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/InputFiles.cpp

 template <class ELFT>
 ELFKind ELFFileBase<ELFT>::getELFKind() {
   if (ELFT::TargetEndianness == support::little)
     return ELFT::Is64Bits ? ELF64LEKind : ELF32LEKind;
   return ELFT::Is64Bits ? ELF64BEKind : ELF32BEKind;
 }
 
 template <class ELFT>
-typename ELFT::SymRange ELFFileBase<ELFT>::getElfSymbols(bool OnlyGlobals) {
+typename ELFT::SymRange ELFFileBase<ELFT>::getElfSymbols(WhichSymbols Which) {
   if (!Symtab)
     return Elf_Sym_Range(nullptr, nullptr);
   Elf_Sym_Range Syms = ELFObj.symbols(Symtab);
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   uint32_t FirstNonLocal = Symtab->sh_info;
   if (FirstNonLocal > NumSymbols)
     fatal("invalid sh_info in symbol table");
 
-  if (OnlyGlobals)
+  switch (Which) {
+  case LOCAL_SYMBOLS:
+    return makeArrayRef(Syms.begin() + 1, Syms.begin() + FirstNonLocal);
+  case GLOBAL_SYMBOLS:
     return makeArrayRef(Syms.begin() + FirstNonLocal, Syms.end());
+  case ALL_SYMBOLS:
     return makeArrayRef(Syms.begin(), Syms.end());
   }
+}
 
 template <class ELFT>
 uint32_t ELFFileBase<ELFT>::getSectionIndex(const Elf_Sym &Sym) const {
   uint32_t I = Sym.st_shndx;
   if (I == ELF::SHN_XINDEX)
     return ELFObj.getExtendedSymbolTableIndex(&Sym, Symtab, SymtabSHNDX);
   if (I >= ELF::SHN_LORESERVE)
     return 0;

 ArrayRef<SymbolBody *> elf::ObjectFile<ELFT>::getNonLocalSymbols() {
   if (!this->Symtab)
     return this->SymbolBodies;
   uint32_t FirstNonLocal = this->Symtab->sh_info;
   return makeArrayRef(this->SymbolBodies).slice(FirstNonLocal);
 }
 
 template <class ELFT>
-ArrayRef<SymbolBody *> elf::ObjectFile<ELFT>::getLocalSymbols() {
-  if (!this->Symtab)
-    return this->SymbolBodies;
-  uint32_t FirstNonLocal = this->Symtab->sh_info;
-  return makeArrayRef(this->SymbolBodies).slice(1, FirstNonLocal - 1);
-}
-
-template <class ELFT>
 ArrayRef<SymbolBody *> elf::ObjectFile<ELFT>::getSymbols() {
   if (!this->Symtab)
     return this->SymbolBodies;
   return makeArrayRef(this->SymbolBodies).slice(1);
 }
 
 template <class ELFT> uint32_t elf::ObjectFile<ELFT>::getMipsGp0() const {
   if (MipsReginfo)
     return MipsReginfo->Reginfo->ri_gp_value;
   return 0;
 }
 
 template <class ELFT>
-void elf::ObjectFile<ELFT>::parse(DenseSet<StringRef> &ComdatGroups) {
+void elf::ObjectFile<ELFT>::parse(
+    function_ref<void(StringRef, SymbolBody *)> Resolve,
+    DenseSet<StringRef> &ComdatGroups) {
   // Read section and symbol tables.
   initializeSections(ComdatGroups);
-  initializeSymbols();
+  initializeSymbols(Resolve);
 }
 
 // Sections with SHT_GROUP and comdat bits define comdat section groups.
 // They are identified and deduplicated by group name. This function
 // returns a group name.
 template <class ELFT>
 StringRef elf::ObjectFile<ELFT>::getShtGroupSignature(const Elf_Shdr &Sec) {
   const ELFFile<ELFT> &Obj = this->ELFObj;
elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
   // output was choosen. Proccess them as usual input sections.
   if (!Config->Relocatable && Name == ".eh_frame")
     return new (EHAlloc.Allocate()) EHInputSection<ELFT>(this, &Sec);
   if (shouldMerge<ELFT>(Sec))
     return new (MAlloc.Allocate()) MergeInputSection<ELFT>(this, &Sec);
   return new (Alloc) InputSection<ELFT>(this, &Sec);
 }
 
-template <class ELFT> void elf::ObjectFile<ELFT>::initializeSymbols() {
+template <class ELFT>
+void elf::ObjectFile<ELFT>::initializeSymbols(
+    function_ref<void(StringRef, SymbolBody *)> Resolve) {
   this->initStringTable();
-  Elf_Sym_Range Syms = this->getElfSymbols(false);
+  Elf_Sym_Range Syms = this->getElfSymbols(ELFFileBase<ELFT>::ALL_SYMBOLS);
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   SymbolBodies.reserve(NumSymbols);
-  for (const Elf_Sym &Sym : Syms)
-    SymbolBodies.push_back(createSymbolBody(&Sym));
+  for (const Elf_Sym &Sym : Syms) {
+    auto P = createSymbolBody(&Sym);
+    SymbolBody *B = P.second;
+    SymbolBodies.push_back(B);
+    if (!B->isLocal())
+      Resolve(P.first, B);
+  }
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   uint32_t Index = this->getSectionIndex(Sym);
   if (Index == 0)
     return nullptr;
   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;
 }
 
 template <class ELFT>
-SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
-   unsigned char Binding = Sym->getBinding();
+std::pair<StringRef, SymbolBody *>
+elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   InputSectionBase<ELFT> *Sec = getSection(*Sym);
   if (Binding == STB_LOCAL) {
     if (Sym->st_shndx == SHN_UNDEF)
-      return new (Alloc) UndefinedElf<ELFT>(*Sym);
-    return new (Alloc) DefinedRegular<ELFT>(*Sym, Sec);
+      return std::make_pair("", new (Alloc) UndefinedElf<ELFT>(*Sym));
+    return std::make_pair("", new (Alloc) DefinedRegular<ELFT>(*Sym, Sec));
   }
 
   StringRef Name = check(Sym->getName(this->StringTable));
 
   switch (Sym->st_shndx) {
   case SHN_UNDEF:
-    return new (Alloc) UndefinedElf<ELFT>(Name, *Sym);
+    return std::make_pair(Name, new (Alloc) UndefinedElf<ELFT>(*Sym));
   case SHN_COMMON:
-    return new (Alloc) DefinedCommon(Name, Sym->st_size, Sym->st_value, Binding,
-                                     Sym->st_other, Sym->getType());
+    return std::make_pair(
+        Name, new (Alloc) DefinedCommon(Sym->st_size, Sym->st_value, Binding,
+                                        Sym->st_other, Sym->getType()));
   }
 
   switch (Binding) {
   default:
     fatal("unexpected binding");
   case STB_GLOBAL:
   case STB_WEAK:
   case STB_GNU_UNIQUE:
     if (Sec == &InputSection<ELFT>::Discarded)
-      return new (Alloc) UndefinedElf<ELFT>(Name, *Sym);
-    return new (Alloc) DefinedRegular<ELFT>(Name, *Sym, Sec);
+      return std::make_pair(Name, new (Alloc) UndefinedElf<ELFT>(*Sym));
+    return std::make_pair(Name, new (Alloc) DefinedRegular<ELFT>(*Sym, Sec));
   }
 }
 
 void ArchiveFile::parse() {
   File = check(Archive::create(MB), "failed to parse archive");
 
   // Allocate a buffer for Lazy objects.
   size_t NumSyms = File->getNumberOfSymbols();
if (Dyn.d_tag == DT_SONAME) {
         fatal("invalid DT_SONAME entry");
       SoName = StringRef(this->StringTable.data() + Val);
       return;
     }
   }
 }
 
 // Fully parse the shared object file. This must be called after parseSoName().
-template <class ELFT> void SharedFile<ELFT>::parseRest() {
-  Elf_Sym_Range Syms = this->getElfSymbols(true);
+template <class ELFT>
+void SharedFile<ELFT>::parseRest(
+    function_ref<void(StringRef, SymbolBody *)> Resolve) {
+  Elf_Sym_Range Syms = this->getElfSymbols(ELFFileBase<ELFT>::GLOBAL_SYMBOLS);
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   SymbolBodies.reserve(NumSymbols);
   for (const Elf_Sym &Sym : Syms) {
     StringRef Name = check(Sym.getName(this->StringTable));
-    if (Sym.isUndefined())
+    if (Sym.isUndefined()) {
       Undefs.push_back(Name);
-    else
-      SymbolBodies.emplace_back(this, Name, Sym);
+    } else {
+      SymbolBodies.emplace_back(this, Sym);
+      Resolve(Name, &SymbolBodies.back());
+    }
   }
 }
 
 BitcodeFile::BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
 
 bool BitcodeFile::classof(const InputFile *F) {
   return F->kind() == BitcodeKind;
 }
 
 static uint8_t getGvVisibility(const GlobalValue *GV) {
   switch (GV->getVisibility()) {
   case GlobalValue::DefaultVisibility:
     return STV_DEFAULT;
   case GlobalValue::HiddenVisibility:
     return STV_HIDDEN;
   case GlobalValue::ProtectedVisibility:
     return STV_PROTECTED;
   }
   llvm_unreachable("unknown visibility");
 }
 
-SymbolBody *
+std::pair<StringRef, SymbolBody *>
 BitcodeFile::createSymbolBody(const DenseSet<const Comdat *> &KeptComdats,
                               const IRObjectFile &Obj,
                               const BasicSymbolRef &Sym) {
   const GlobalValue *GV = Obj.getSymbolGV(Sym.getRawDataRefImpl());
   assert(GV);
   if (const Comdat *C = GV->getComdat())
     if (!KeptComdats.count(C))
-      return nullptr;
+      return std::make_pair("", nullptr);
 
   uint8_t Visibility = getGvVisibility(GV);
 
   SmallString<64> Name;
   raw_svector_ostream OS(Name);
   Sym.printName(OS);
   StringRef NameRef = Saver.save(StringRef(Name));
 
   const Module &M = Obj.getModule();
   SymbolBody *Body;
   uint32_t Flags = Sym.getFlags();
   bool IsWeak = Flags & BasicSymbolRef::SF_Weak;
   if (Flags & BasicSymbolRef::SF_Undefined) {
-    Body = new (Alloc) Undefined(NameRef, IsWeak, Visibility, false);
+    Body = new (Alloc) Undefined(IsWeak, Visibility, false);
   } else if (Flags & BasicSymbolRef::SF_Common) {
     const DataLayout &DL = M.getDataLayout();
     uint64_t Size = DL.getTypeAllocSize(GV->getValueType());
     Body = new (Alloc)
-        DefinedCommon(NameRef, Size, GV->getAlignment(),
-                      IsWeak ? STB_WEAK : STB_GLOBAL, Visibility, /*Type*/ 0);
+        DefinedCommon(Size, GV->getAlignment(), IsWeak ? STB_WEAK : STB_GLOBAL,
+                      Visibility, /*Type*/ 0);
   } else {
-    Body = new (Alloc) DefinedBitcode(NameRef, IsWeak, Visibility);
+    Body = new (Alloc) DefinedBitcode(IsWeak, Visibility);
   }
   if (GV->isThreadLocal())
     Body->Type = STT_TLS;
-  return Body;
+  return std::make_pair(NameRef, Body);
 }
 
 bool BitcodeFile::shouldSkip(const BasicSymbolRef &Sym) {
   uint32_t Flags = Sym.getFlags();
   if (!(Flags & BasicSymbolRef::SF_Global))
     return true;
   if (Flags & BasicSymbolRef::SF_FormatSpecific)
     return true;
   return false;
 }
 
-void BitcodeFile::parse(DenseSet<StringRef> &ComdatGroups) {
+void BitcodeFile::parse(function_ref<void(StringRef, SymbolBody *)> Resolve,
+                        DenseSet<StringRef> &ComdatGroups) {
   LLVMContext Context;
   std::unique_ptr<IRObjectFile> Obj = check(IRObjectFile::create(MB, Context));
   const Module &M = Obj->getModule();
 
   DenseSet<const Comdat *> KeptComdats;
   for (const auto &P : M.getComdatSymbolTable()) {
     StringRef N = Saver.save(P.first());
     if (ComdatGroups.insert(N).second)
       KeptComdats.insert(&P.second);
   }
 
-  for (const BasicSymbolRef &Sym : Obj->symbols())
-    if (!shouldSkip(Sym))
-      SymbolBodies.push_back(createSymbolBody(KeptComdats, *Obj, Sym));
+  for (const BasicSymbolRef &Sym : Obj->symbols()) {
+    if (shouldSkip(Sym))
+      continue;
+    auto P = createSymbolBody(KeptComdats, *Obj, Sym);
+    SymbolBodies.push_back(P.second);
+    if (P.second)
+      Resolve(P.first, P.second);
+  }
 }
 
 template <typename T>
 static std::unique_ptr<InputFile> createELFFileAux(MemoryBufferRef MB) {
   std::unique_ptr<T> Ret = llvm::make_unique<T>(MB);
 
   if (!Config->FirstElf)
     Config->FirstElf = Ret.get();

ELF/OutputSections.h

public:
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::SymRange Elf_Sym_Range;
   typedef typename ELFT::uint uintX_t;
   SymbolTableSection(SymbolTable<ELFT> &Table,
                      StringTableSection<ELFT> &StrTabSec);
 
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
-  void addSymbol(SymbolBody *Body);
+  void addSymbol(StringRef Name, SymbolBody *Body);
   StringTableSection<ELFT> &getStrTabSec() const { return StrTabSec; }
   unsigned getNumSymbols() const { return NumLocals + Symbols.size() + 1; }
 
-  ArrayRef<std::pair<SymbolBody *, size_t>> getSymbols() const {
-    return Symbols;
-  }
+  struct Sym {
+    StringRef Name;
+    SymbolBody *Body;
+    size_t Offset;
+  };
+
+  ArrayRef<Sym> getSymbols() const { return Symbols; }
 
   unsigned NumLocals = 0;
   StringTableSection<ELFT> &StrTabSec;
 
 private:
   void writeLocalSymbols(uint8_t *&Buf);
   void writeGlobalSymbols(uint8_t *Buf);
 
   const OutputSectionBase<ELFT> *getOutputSection(SymbolBody *Sym);
   static uint8_t getSymbolBinding(SymbolBody *Body);
 
   SymbolTable<ELFT> &Table;
 
-  // A vector of symbols and their string table offsets.
-  std::vector<std::pair<SymbolBody *, size_t>> Symbols;
+  std::vector<Sym> Symbols;
 };
 
 template <class ELFT>
 class RelocationSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::uint uintX_t;
 

 
 public:
   GnuHashTableSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
 
   // Adds symbols to the hash table.
   // Sorts the input to satisfy GNU hash section requirements.
-  void addSymbols(std::vector<std::pair<SymbolBody *, size_t>> &Symbols);
+  void addSymbols(std::vector<typename SymbolTableSection<ELFT>::Sym> &Symbols);
 
 private:
   static unsigned calcNBuckets(unsigned NumHashed);
   static unsigned calcMaskWords(unsigned NumHashed);
 
   void writeHeader(uint8_t *&Buf);
   void writeBloomFilter(uint8_t *&Buf);
   void writeHashTable(uint8_t *Buf);

ELF/OutputSections.cpp

template <class ELFT> void HashTableSection<ELFT>::writeTo(uint8_t *Buf) {
   unsigned NumSymbols = Out<ELFT>::DynSymTab->getNumSymbols();
   auto *P = reinterpret_cast<Elf_Word *>(Buf);
   *P++ = NumSymbols; // nbucket
   *P++ = NumSymbols; // nchain
 
   Elf_Word *Buckets = P;
   Elf_Word *Chains = P + NumSymbols;
 
-  for (const std::pair<SymbolBody *, unsigned> &P :
+  for (const typename SymbolTableSection<ELFT>::Sym &S :
        Out<ELFT>::DynSymTab->getSymbols()) {
-    SymbolBody *Body = P.first;
-    StringRef Name = Body->getName();
-    unsigned I = Body->DynsymIndex;
-    uint32_t Hash = hashSysv(Name) % NumSymbols;
+    unsigned I = S.Body->DynsymIndex;
+    uint32_t Hash = hashSysv(S.Name) % NumSymbols;
     Chains[I] = Buckets[Hash];
     Buckets[Hash] = I;
   }
 }
 
 static uint32_t hashGnu(StringRef Name) {
   uint32_t H = 5381;
   for (uint8_t C : Name)
static bool includeInGnuHashTable(SymbolBody *B) {
   return !B->isUndefined();
 }
 
 // Add symbols to this symbol hash table. Note that this function
 // destructively sort a given vector -- which is needed because
 // GNU-style hash table places some sorting requirements.
 template <class ELFT>
 void GnuHashTableSection<ELFT>::addSymbols(
-    std::vector<std::pair<SymbolBody *, size_t>> &V) {
-  auto Mid = std::stable_partition(V.begin(), V.end(),
-                                   [](std::pair<SymbolBody *, size_t> &P) {
-                                     return !includeInGnuHashTable(P.first);
-                                   });
+    std::vector<typename SymbolTableSection<ELFT>::Sym> &V) {
+  auto Mid = std::stable_partition(
+      V.begin(), V.end(), [](typename SymbolTableSection<ELFT>::Sym &P) {
+        return !includeInGnuHashTable(P.Body);
   if (Mid == V.end())
     return;
-  for (auto I = Mid, E = V.end(); I != E; ++I) {
-    SymbolBody *B = I->first;
-    size_t StrOff = I->second;
-    Symbols.push_back({B, StrOff, hashGnu(B->getName())});
-  }
+  for (auto I = Mid, E = V.end(); I != E; ++I)
+    Symbols.push_back({I->Body, I->Offset, hashGnu(I->Name)});
 
   unsigned NBuckets = calcNBuckets(Symbols.size());
   std::stable_sort(Symbols.begin(), Symbols.end(),
                    [&](const SymbolData &L, const SymbolData &R) {
                      return L.Hash % NBuckets < R.Hash % NBuckets;
                    });
 
   V.erase(Mid, V.end());
   for (const SymbolData &Sym : Symbols)
-    V.push_back({Sym.Body, Sym.STName});
+    // We don't need the name anymore.
+    V.push_back({"", Sym.Body, Sym.STName});
 }
 
 template <class ELFT>
 DynamicSection<ELFT>::DynamicSection(SymbolTable<ELFT> &SymTab)
     : OutputSectionBase<ELFT>(".dynamic", SHT_DYNAMIC, SHF_ALLOC | SHF_WRITE),
       SymTab(SymTab) {
   Elf_Shdr &Header = this->Header;
   Header.sh_addralign = sizeof(uintX_t);
SymbolTableSection<ELFT>::SymbolTableSection(
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 // Orders symbols according to their positions in the GOT,
 // in compliance with MIPS ABI rules.
 // See "Global Offset Table" in Chapter 5 in the following document
 // for detailed description:
 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-static bool sortMipsSymbols(const std::pair<SymbolBody *, unsigned> &L,
-                            const std::pair<SymbolBody *, unsigned> &R) {
+template <class ELFT>
+static bool sortMipsSymbols(const typename SymbolTableSection<ELFT>::Sym &L,
+                            const typename SymbolTableSection<ELFT>::Sym &R) {
   // Sort entries related to non-local preemptible symbols by GOT indexes.
   // All other entries go to the first part of GOT in arbitrary order.
-  bool LIsInLocalGot = !L.first->isInGot() || !L.first->isPreemptible();
-  bool RIsInLocalGot = !R.first->isInGot() || !R.first->isPreemptible();
+  bool LIsInLocalGot = !L.Body->isInGot() || !L.Body->isPreemptible();
+  bool RIsInLocalGot = !R.Body->isInGot() || !R.Body->isPreemptible();
   if (LIsInLocalGot || RIsInLocalGot)
     return !RIsInLocalGot;
-  return L.first->GotIndex < R.first->GotIndex;
+  return L.Body->GotIndex < R.Body->GotIndex;
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
   if (this->Header.sh_size)
     return; // Already finalized.
 
   this->Header.sh_size = getNumSymbols() * sizeof(Elf_Sym);
   this->Header.sh_link = StrTabSec.SectionIndex;
   this->Header.sh_info = NumLocals + 1;
 
   if (Config->Relocatable) {
     size_t I = NumLocals;
-    for (const std::pair<SymbolBody *, size_t> &P : Symbols)
-      P.first->DynsymIndex = ++I;
+    for (const SymbolTableSection::Sym &S : Symbols)
+      S.Body->DynsymIndex = ++I;
     return;
   }
 
   if (!StrTabSec.isDynamic()) {
-    std::stable_sort(Symbols.begin(), Symbols.end(),
-                     [](const std::pair<SymbolBody *, unsigned> &L,
-                        const std::pair<SymbolBody *, unsigned> &R) {
-                       return getSymbolBinding(L.first) == STB_LOCAL &&
-                              getSymbolBinding(R.first) != STB_LOCAL;
-                     });
+    std::stable_sort(
+        Symbols.begin(), Symbols.end(),
+        [](const SymbolTableSection::Sym &L, const SymbolTableSection::Sym &R) {
+          return getSymbolBinding(L.Body) == STB_LOCAL &&
+                 getSymbolBinding(R.Body) != STB_LOCAL;
     return;
   }
   if (Out<ELFT>::GnuHashTab)
     // NB: It also sorts Symbols to meet the GNU hash table requirements.
     Out<ELFT>::GnuHashTab->addSymbols(Symbols);
   else if (Config->EMachine == EM_MIPS)
-    std::stable_sort(Symbols.begin(), Symbols.end(), sortMipsSymbols);
+    std::stable_sort(Symbols.begin(), Symbols.end(), sortMipsSymbols<ELFT>);
   size_t I = 0;
-  for (const std::pair<SymbolBody *, size_t> &P : Symbols)
-    P.first->DynsymIndex = ++I;
+  for (const SymbolTableSection::Sym &S : Symbols)
+    S.Body->DynsymIndex = ++I;
 }
 
 template <class ELFT>
-void SymbolTableSection<ELFT>::addSymbol(SymbolBody *B) {
-  Symbols.push_back({B, StrTabSec.addString(B->getName(), false)});
+void SymbolTableSection<ELFT>::addSymbol(StringRef Name, SymbolBody *B) {
+  Symbols.push_back({Name, B, StrTabSec.addString(Name, false)});
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
   Buf += sizeof(Elf_Sym);
 
   // All symbols with STB_LOCAL binding precede the weak and global symbols.
   // .dynsym only contains global symbols.
   if (!Config->DiscardAll && !StrTabSec.isDynamic())
void SymbolTableSection<ELFT>::writeLocalSymbols(uint8_t *&Buf) {
   }
 }
 
 template <class ELFT>
 void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {
   // Write the internal symbol table contents to the output symbol table
   // pointed by Buf.
   auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
-  for (const std::pair<SymbolBody *, size_t> &P : Symbols) {
-    SymbolBody *Body = P.first;
-    size_t StrOff = P.second;
+  for (const Sym &S : Symbols) {
+    SymbolBody *Body = S.Body;
 
     uint8_t Type = Body->Type;
     uintX_t Size = Body->getSize<ELFT>();
 
     ESym->setBindingAndType(getSymbolBinding(Body), Type);
     ESym->st_size = Size;
-    ESym->st_name = StrOff;
+    ESym->st_name = S.Offset;
     ESym->setVisibility(Body->getVisibility());
     ESym->st_value = Body->getVA<ELFT>();
 
     if (const OutputSectionBase<ELFT> *OutSec = getOutputSection(Body))
       ESym->st_shndx = OutSec->SectionIndex;
     else if (isa<DefinedRegular<ELFT>>(Body))
       ESym->st_shndx = SHN_ABS;
 

ELF/SymbolTable.h

DefinedRegular<ELFT> *addIgnored(StringRef Name,
                                    uint8_t Visibility = llvm::ELF::STV_HIDDEN);
 
   void scanShlibUndefined();
   SymbolBody *find(StringRef Name);
   void wrap(StringRef Name);
   InputFile *findFile(SymbolBody *B);
 
 private:
-  Symbol *insert(SymbolBody *New);
+  Symbol *insert(StringRef Name, SymbolBody *New);
   void addLazy(Lazy *New);
   void addMemberFile(Undefined *Undef, Lazy *L);
-  void resolve(SymbolBody *Body);
-  std::string conflictMsg(SymbolBody *Old, SymbolBody *New);
+  void resolve(StringRef Name, SymbolBody *Body);
+  std::string conflictMsg(StringRef Name, SymbolBody *Old, SymbolBody *New);
 
   // The order the global symbols are in is not defined. We can use an arbitrary
   // order, but it has to be reproducible. That is true even when cross linking.
   // The default hashing of StringRef produces different results on 32 and 64
   // bit systems so we use a MapVector. That is arbitrary, deterministic but
   // a bit inefficient.
   // FIXME: Experiment with passing in a custom hashing or sorting the symbols
   // once symbol resolution is finished.

ELF/SymbolTable.cpp

void SymbolTable<ELFT>::addFile(std::unique_ptr<InputFile> File) {
   // .so file
   if (auto *F = dyn_cast<SharedFile<ELFT>>(FileP)) {
     // DSOs are uniquified not by filename but by soname.
     F->parseSoName();
     if (!SoNames.insert(F->getSoName()).second)
       return;
 
     SharedFiles.emplace_back(cast<SharedFile<ELFT>>(File.release()));
-    F->parseRest();
-    for (SharedSymbol<ELFT> &B : F->getSharedSymbols())
-      resolve(&B);
+    F->parseRest([&](StringRef Name, SymbolBody *B) { resolve(Name, B); });
     return;
   }
 
   // LLVM bitcode file.
   if (auto *F = dyn_cast<BitcodeFile>(FileP)) {
     BitcodeFiles.emplace_back(cast<BitcodeFile>(File.release()));
-    F->parse(ComdatGroups);
-    for (SymbolBody *B : F->getSymbols())
-      if (B)
-        resolve(B);
+    F->parse([&](StringRef Name, SymbolBody *B) { resolve(Name, B); },
+             ComdatGroups);
     return;
   }
 
   // .o file
   auto *F = cast<ObjectFile<ELFT>>(FileP);
   ObjectFiles.emplace_back(cast<ObjectFile<ELFT>>(File.release()));
-  F->parse(ComdatGroups);
-  for (SymbolBody *B : F->getNonLocalSymbols())
-    resolve(B);
+  F->parse([&](StringRef Name, SymbolBody *B) { resolve(Name, B); },
+           ComdatGroups);
 }
 
 template <class ELFT> void SymbolTable<ELFT>::addCombinedLtoObject() {
   if (BitcodeFiles.empty())
     return;
 
   // Compile bitcode files.
   Lto.reset(new BitcodeCompiler);
   for (const std::unique_ptr<BitcodeFile> &F : BitcodeFiles)
     Lto->add(*F);
   std::unique_ptr<InputFile> IF = Lto->compile();
   ObjectFile<ELFT> *Obj = cast<ObjectFile<ELFT>>(IF.release());
 
   // Replace bitcode symbols.
   llvm::DenseSet<StringRef> DummyGroups;
-  Obj->parse(DummyGroups);
-  for (SymbolBody *Body : Obj->getNonLocalSymbols()) {
-    Symbol *Sym = insert(Body);
+
+  Obj->parse(
+      [&](StringRef Name, SymbolBody *Body) {
+        Symbol *Sym = insert(Name, Body);
         Sym->Body->setUsedInRegularObj();
         if (!Sym->Body->isUndefined() && Body->isUndefined())
-      continue;
+          return;
         if (Sym->Body->MustBeInDynSym)
           Body->MustBeInDynSym = true;
         Sym->Body = Body;
-  }
+      },
+      DummyGroups);
+
   ObjectFiles.emplace_back(Obj);
 }
 
 // Add an undefined symbol.
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addUndefined(StringRef Name) {
-  auto *Sym = new (Alloc) Undefined(Name, false, STV_DEFAULT, false);
-  resolve(Sym);
+  auto *Sym = new (Alloc) Undefined(false, STV_DEFAULT, false);
+  resolve(Name, Sym);
   return Sym;
 }
 
 // Add an undefined symbol. Unlike addUndefined, that symbol
 // doesn't have to be resolved, thus "opt" (optional).
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addUndefinedOpt(StringRef Name) {
-  auto *Sym = new (Alloc) Undefined(Name, false, STV_HIDDEN, true);
-  resolve(Sym);
+  auto *Sym = new (Alloc) Undefined(false, STV_HIDDEN, true);
+  resolve(Name, Sym);
   return Sym;
 }
 
 template <class ELFT>
 DefinedRegular<ELFT> *SymbolTable<ELFT>::addAbsolute(StringRef Name,
                                                      uint8_t Visibility) {
   // Pass nullptr because absolute symbols have no corresponding input sections.
-  auto *Sym = new (Alloc) DefinedRegular<ELFT>(Name, STB_GLOBAL, Visibility);
-  resolve(Sym);
+  auto *Sym = new (Alloc) DefinedRegular<ELFT>(STB_GLOBAL, Visibility);
+  resolve(Name, Sym);
   return Sym;
 }
 
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addSynthetic(StringRef Name,
                                             OutputSectionBase<ELFT> &Sec,
                                             uintX_t Val, uint8_t Visibility) {
-  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, Val, Sec, Visibility);
-  resolve(Sym);
+  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Val, Sec, Visibility);
+  resolve(Name, Sym);
   return Sym;
 }
 
 // Add Name as an "ignored" symbol. An ignored symbol is a regular
 // linker-synthesized defined symbol, but is only defined if needed.
 template <class ELFT>
 DefinedRegular<ELFT> *SymbolTable<ELFT>::addIgnored(StringRef Name,
                                                     uint8_t Visibility) {
static std::string getFilename(InputFile *F) {
   if (!F->ArchiveName.empty())
     return (F->ArchiveName + "(" + F->getName() + ")").str();
   return F->getName();
 }
 
 // Construct a string in the form of "Sym in File1 and File2".
 // Used to construct an error message.
 template <class ELFT>
-std::string SymbolTable<ELFT>::conflictMsg(SymbolBody *Old, SymbolBody *New) {
+std::string SymbolTable<ELFT>::conflictMsg(StringRef Name, SymbolBody *Old,
+                                           SymbolBody *New) {
   InputFile *F1 = findFile(Old);
   InputFile *F2 = findFile(New);
-  StringRef Sym = Old->getName();
-  return demangle(Sym) + " in " + getFilename(F1) + " and " + getFilename(F2);
+  return demangle(Name) + " in " + getFilename(F1) + " and " + getFilename(F2);
 }
 
 // This function resolves conflicts if there's an existing symbol with
 // the same name. Decisions are made based on symbol type.
-template <class ELFT> void SymbolTable<ELFT>::resolve(SymbolBody *New) {
-  Symbol *Sym = insert(New);
+template <class ELFT>
+void SymbolTable<ELFT>::resolve(StringRef Name, SymbolBody *New) {
+  Symbol *Sym = insert(Name, New);
   if (Sym->Body == New)
     return;
 
   SymbolBody *Existing = Sym->Body;
 
   if (auto *L = dyn_cast<Lazy>(Existing)) {
     if (auto *Undef = dyn_cast<Undefined>(New)) {
       addMemberFile(Undef, L);
       return;
     }
     // Found a definition for something also in an archive.
     // Ignore the archive definition.
     if (L->isUsedInRegularObj())
       New->setUsedInRegularObj();
     Sym->Body = New;
     return;
   }
 
   if (New->isTls() != Existing->isTls()) {
-    error("TLS attribute mismatch for symbol: " + conflictMsg(Existing, New));
+    error("TLS attribute mismatch for symbol: " +
+          conflictMsg(Name, Existing, New));
     return;
   }
 
   // compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
   // equivalent (conflicting), or more preferable, respectively.
-  int Comp = Existing->compare(New);
+  int Comp = Existing->compare(Name, New);
   if (Comp == 0) {
-    std::string S = "duplicate symbol: " + conflictMsg(Existing, New);
+    std::string S = "duplicate symbol: " + conflictMsg(Name, Existing, New);
     if (Config->AllowMultipleDefinition)
       warning(S);
     else
       error(S);
     return;
   }
   if (Comp < 0)
     Sym->Body = New;
 }
 
 // Find an existing symbol or create and insert a new one.
-template <class ELFT> Symbol *SymbolTable<ELFT>::insert(SymbolBody *New) {
-  StringRef Name = New->getName();
+template <class ELFT>
+Symbol *SymbolTable<ELFT>::insert(StringRef Name, SymbolBody *New) {
   Symbol *&Sym = Symtab[Name];
   if (!Sym)
     Sym = new (Alloc) Symbol{New};
   New->setBackref(Sym);
   return Sym;
 }
 
 template <class ELFT> SymbolBody *SymbolTable<ELFT>::find(StringRef Name) {
   auto It = Symtab.find(Name);
   if (It == Symtab.end())
     return nullptr;
   return It->second->Body;
 }
 
 template <class ELFT> void SymbolTable<ELFT>::addLazy(Lazy *L) {
-  Symbol *Sym = insert(L);
+  Symbol *Sym = insert(L->getName(), L);
   if (Sym->Body == L)
     return;
   if (auto *Undef = dyn_cast<Undefined>(Sym->Body)) {
     Sym->Body = L;
     addMemberFile(Undef, L);
   }
 }
 

ELF/Symbols.h

public:
   bool isDefined() const { return SymbolKind <= DefinedLast; }
   bool isCommon() const { return SymbolKind == DefinedCommonKind; }
   bool isLazy() const { return SymbolKind == LazyKind; }
   bool isShared() const { return SymbolKind == SharedKind; }
   bool isLocal() const { return Binding == llvm::ELF::STB_LOCAL; }
   bool isUsedInRegularObj() const { return IsUsedInRegularObj; }
   bool isPreemptible() const;
 
-  // Returns the symbol name.
-  StringRef getName() const {
-    assert(!isLocal());
-    return StringRef(Name.S, Name.Len);
-  }
-  uint32_t getNameOffset() const {
-    assert(isLocal());
-    return NameOffset;
-  }
-
   uint8_t getVisibility() const { return StOther & 0x3; }
 
   unsigned DynsymIndex = 0;
   uint32_t GlobalDynIndex = -1;
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   uint32_t ThunkIndex = -1;
public:
   // you can access P->Backref->Body to get the resolver's result.
   void setBackref(Symbol *P) { Backref = P; }
   SymbolBody &repl() { return Backref ? *Backref->Body : *this; }
   Symbol *getSymbol() const { return Backref; }
 
   // Decides which symbol should "win" in the symbol table, this or
   // the Other. Returns 1 if this wins, -1 if the Other wins, or 0 if
   // they are duplicate (conflicting) symbols.
-  int compare(SymbolBody *Other);
+  int compare(StringRef Name, SymbolBody *Other);
 
 protected:
-  SymbolBody(Kind K, StringRef Name, uint8_t Binding, uint8_t StOther,
-             uint8_t Type)
+  SymbolBody(Kind K, uint8_t Binding, uint8_t StOther, uint8_t Type)
       : SymbolKind(K), MustBeInDynSym(false), NeedsCopyOrPltAddr(false),
-        Type(Type), Binding(Binding), StOther(StOther),
-        Name({Name.data(), Name.size()}) {
-    assert(!isLocal());
+        Type(Type), Binding(Binding), StOther(StOther) {
     IsUsedInRegularObj =
         K != SharedKind && K != LazyKind && K != DefinedBitcodeKind;
   }
 
-  SymbolBody(Kind K, uint32_t NameOffset, uint8_t StOther, uint8_t Type);
-
   const unsigned SymbolKind : 8;
 
   // True if the symbol was used for linking and thus need to be
   // added to the output file's symbol table. It is usually true,
   // but if it is a shared symbol that were not referenced by anyone,
   // it can be false.
   unsigned IsUsedInRegularObj : 1;
 
public:
   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; }
   void setVisibility(uint8_t V) { StOther = (StOther & ~0x3) | V; }
 
 protected:
-  struct Str {
-    const char *S;
-    size_t Len;
-  };
-  union {
-    Str Name;
-    uint32_t NameOffset;
-  };
   Symbol *Backref = nullptr;
 };
 
 // The base class for any defined symbols.
 class Defined : public SymbolBody {
 public:
-  Defined(Kind K, StringRef Name, uint8_t Binding, uint8_t StOther,
-          uint8_t Type);
-  Defined(Kind K, uint32_t NameOffset, uint8_t StOther, uint8_t Type);
+  Defined(Kind K, uint8_t Binding, uint8_t Other, uint8_t Type);
   static bool classof(const SymbolBody *S) { return S->isDefined(); }
 };
 
 // The defined symbol in LLVM bitcode files.
 class DefinedBitcode : public Defined {
 public:
-  DefinedBitcode(StringRef Name, bool IsWeak, uint8_t StOther);
+  DefinedBitcode(bool IsWeak, uint8_t Other);
   static bool classof(const SymbolBody *S);
 };
 
 class DefinedCommon : public Defined {
 public:
-  DefinedCommon(StringRef N, uint64_t Size, uint64_t Alignment, uint8_t Binding,
-                uint8_t StOther, uint8_t Type);
+  DefinedCommon(uint64_t Size, uint64_t Alignment, uint8_t Binding,
+                uint8_t Other, uint8_t Type);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedCommonKind;
   }
 
   // The output offset of this common symbol in the output bss. Computed by the
   // writer.
   uint64_t OffsetInBss;
 
   // The maximum alignment we have seen for this symbol.
   uint64_t Alignment;
 
   uint64_t Size;
 };
 
 // Regular defined symbols read from object file symbol tables.
 template <class ELFT> class DefinedRegular : public Defined {
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::uint uintX_t;
 
 public:
-  DefinedRegular(StringRef Name, const Elf_Sym &Sym,
-                 InputSectionBase<ELFT> *Section)
-      : Defined(SymbolBody::DefinedRegularKind, Name, Sym.getBinding(),
-                Sym.st_other, Sym.getType()),
-        Value(Sym.st_value), Size(Sym.st_size),
-        Section(Section ? Section->Repl : NullInputSection) {}
-
   DefinedRegular(const Elf_Sym &Sym, InputSectionBase<ELFT> *Section)
-      : Defined(SymbolBody::DefinedRegularKind, Sym.st_name, Sym.st_other,
+      : Defined(SymbolBody::DefinedRegularKind, Sym.getBinding(), Sym.st_other,
                 Sym.getType()),
         Value(Sym.st_value), Size(Sym.st_size),
-        Section(Section ? Section->Repl : NullInputSection) {
-    assert(isLocal());
-  }
+        Section(Section ? Section->Repl : NullInputSection) {}
 
-  DefinedRegular(StringRef Name, uint8_t Binding, uint8_t StOther)
-      : Defined(SymbolBody::DefinedRegularKind, Name, Binding, StOther,
+  DefinedRegular(uint8_t Binding, uint8_t Other)
+      : Defined(SymbolBody::DefinedRegularKind, Binding, Other,
                 llvm::ELF::STT_NOTYPE),
         Value(0), Size(0), Section(NullInputSection) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedRegularKind;
   }
 
   uintX_t Value;

 
 // DefinedSynthetic is a class to represent linker-generated ELF symbols.
 // The difference from the regular symbol is that DefinedSynthetic symbols
 // don't belong to any input files or sections. Thus, its constructor
 // takes an output section to calculate output VA, etc.
 template <class ELFT> class DefinedSynthetic : public Defined {
 public:
   typedef typename ELFT::uint uintX_t;
-  DefinedSynthetic(StringRef N, uintX_t Value, OutputSectionBase<ELFT> &Section,
-                   uint8_t StOther);
+  DefinedSynthetic(uintX_t Value, OutputSectionBase<ELFT> &Section,
+                   uint8_t Other);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedSyntheticKind;
   }
 
   // Special value designates that the symbol 'points'
   // to the end of the section.
   static const uintX_t SectionEnd = uintX_t(-1);
 
   uintX_t Value;
   const OutputSectionBase<ELFT> &Section;
 };
 
 // Undefined symbol.
 class Undefined : public SymbolBody {
   typedef SymbolBody::Kind Kind;
   bool CanKeepUndefined;
 
 protected:
-  Undefined(Kind K, StringRef N, uint8_t Binding, uint8_t StOther,
-            uint8_t Type);
-  Undefined(Kind K, uint32_t NameOffset, uint8_t StOther, uint8_t Type);
+  Undefined(Kind K, uint8_t Binding, uint8_t Other, uint8_t Type);
 
 public:
-  Undefined(StringRef N, bool IsWeak, uint8_t StOther, bool CanKeepUndefined);
+  Undefined(bool IsWeak, uint8_t Other, bool CanKeepUndefined);
 
   static bool classof(const SymbolBody *S) { return S->isUndefined(); }
 
   bool canKeepUndefined() const { return CanKeepUndefined; }
 };
 
 template <class ELFT> class UndefinedElf : public Undefined {
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Sym Elf_Sym;
 
 public:
-  UndefinedElf(StringRef N, const Elf_Sym &Sym);
   UndefinedElf(const Elf_Sym &Sym);
 
   uintX_t Size;
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::UndefinedElfKind;
   }
 };
 
 template <class ELFT> class SharedSymbol : public Defined {
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::uint uintX_t;
 
 public:
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::SharedKind;
   }
 
-  SharedSymbol(SharedFile<ELFT> *F, StringRef Name, const Elf_Sym &Sym)
-      : Defined(SymbolBody::SharedKind, Name, Sym.getBinding(), Sym.st_other,
+  SharedSymbol(SharedFile<ELFT> *F, const Elf_Sym &Sym)
+      : Defined(SymbolBody::SharedKind, Sym.getBinding(), Sym.st_other,
                 Sym.getType()),
         File(F), Sym(Sym) {}
 
   SharedFile<ELFT> *File;
   const Elf_Sym &Sym;
 
   // 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
 // created from an archive file header, and it knows how to load an
 // object file from an archive to replace itself with a defined
 // symbol. If the resolver finds both Undefined and Lazy for
 // the same name, it will ask the Lazy to load a file.
 class Lazy : public SymbolBody {
 public:
   Lazy(ArchiveFile *F, const llvm::object::Archive::Symbol S)
-      : SymbolBody(LazyKind, S.getName(), llvm::ELF::STB_GLOBAL,
-                   llvm::ELF::STV_DEFAULT, /* Type */ 0),
+      : SymbolBody(LazyKind, llvm::ELF::STB_GLOBAL, llvm::ELF::STV_DEFAULT,
+                   /* Type */ 0),
         File(F), Sym(S) {}
 
   static bool classof(const SymbolBody *S) { return S->kind() == LazyKind; }
 
   // Returns an object file for this symbol, or a nullptr if the file
   // was already returned.
   std::unique_ptr<InputFile> getMember();
 
+  StringRef getName() const { return Sym.getName(); }
+
 private:
   ArchiveFile *File;
   const llvm::object::Archive::Symbol Sym;
 };
 
 // Some linker-generated symbols need to be created as
 // DefinedRegular symbols.
 template <class ELFT> struct ElfSym {

ELF/Symbols.cpp

case SymbolBody::LazyKind:
     assert(Body.isUsedInRegularObj() && "lazy symbol reached writer");
     return 0;
   case SymbolBody::DefinedBitcodeKind:
     llvm_unreachable("should have been replaced");
   }
   llvm_unreachable("invalid symbol kind");
 }
 
-SymbolBody::SymbolBody(Kind K, uint32_t NameOffset, uint8_t StOther,
-                       uint8_t Type)
-    : SymbolKind(K), MustBeInDynSym(false), NeedsCopyOrPltAddr(false),
-      Type(Type), Binding(STB_LOCAL), StOther(StOther), NameOffset(NameOffset) {
-  IsUsedInRegularObj =
-      K != SharedKind && K != LazyKind && K != DefinedBitcodeKind;
-}
-
 // Returns true if a symbol can be replaced at load-time by a symbol
 // with the same name defined in other ELF executable or DSO.
 bool SymbolBody::isPreemptible() const {
   if (isLocal())
     return false;
 
   if (isShared())
     return true;

 static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) {
   if (VA == STV_DEFAULT)
     return VB;
   if (VB == STV_DEFAULT)
     return VA;
   return std::min(VA, VB);
 }
 
-static int compareCommons(DefinedCommon *A, DefinedCommon *B) {
+static int compareCommons(StringRef Name, DefinedCommon *A, DefinedCommon *B) {
   if (Config->WarnCommon)
-    warning("multiple common of " + A->getName());
+    warning("multiple common of " + Name);
   A->Alignment = B->Alignment = std::max(A->Alignment, B->Alignment);
   return A->Size < B->Size ? -1 : 1;
 }
 
 // Returns 1, 0 or -1 if this symbol should take precedence
 // over the Other, tie or lose, respectively.
-int SymbolBody::compare(SymbolBody *Other) {
+int SymbolBody::compare(StringRef Name, SymbolBody *Other) {
   assert(!isLazy() && !Other->isLazy());
   std::tuple<bool, bool, bool> L(isDefined(), !isShared(), !isWeak());
   std::tuple<bool, bool, bool> R(Other->isDefined(), !Other->isShared(),
                                  !Other->isWeak());
 
   // Normalize
   if (L > R)
-    return -Other->compare(this);
+    return -Other->compare(Name, this);
 
   uint8_t V = getMinVisibility(getVisibility(), Other->getVisibility());
   setVisibility(V);
   Other->setVisibility(V);
 
   if (IsUsedInRegularObj || Other->IsUsedInRegularObj)
     IsUsedInRegularObj = Other->IsUsedInRegularObj = true;
 
   // We want to export all symbols that exist both in the executable
   // and in DSOs, so that the symbols in the executable can interrupt
   // symbols in the DSO at runtime.
   if (isShared() != Other->isShared())
     if (isa<Defined>(isShared() ? Other : this)) {
       IsUsedInRegularObj = Other->IsUsedInRegularObj = true;
       MustBeInDynSym = Other->MustBeInDynSym = true;
     }
 
   if (L != R)
     return -1;
   if (!isDefined() || isShared() || isWeak())
     return 1;
   if (!isCommon() && !Other->isCommon())
     return 0;
   if (isCommon() && Other->isCommon())
-    return compareCommons(cast<DefinedCommon>(this),
+    return compareCommons(Name, cast<DefinedCommon>(this),
                           cast<DefinedCommon>(Other));
   if (Config->WarnCommon)
-    warning("common " + this->getName() + " is overridden");
+    warning("common " + Name + " is overridden");
   return isCommon() ? -1 : 1;
 }
 
-Defined::Defined(Kind K, StringRef Name, uint8_t Binding, uint8_t Visibility,
-                 uint8_t Type)
-    : SymbolBody(K, Name, Binding, Visibility, Type) {}
-
-Defined::Defined(Kind K, uint32_t NameOffset, uint8_t Visibility, uint8_t Type)
-    : SymbolBody(K, NameOffset, Visibility, Type) {}
+Defined::Defined(Kind K, uint8_t Binding, uint8_t Other, uint8_t Type)
+    : SymbolBody(K, Binding, Other, Type) {}
 
-DefinedBitcode::DefinedBitcode(StringRef Name, bool IsWeak, uint8_t Visibility)
-    : Defined(DefinedBitcodeKind, Name, IsWeak ? STB_WEAK : STB_GLOBAL,
-              Visibility, 0 /* Type */) {}
+DefinedBitcode::DefinedBitcode(bool IsWeak, uint8_t Other)
+    : Defined(DefinedBitcodeKind, IsWeak ? STB_WEAK : STB_GLOBAL, Other,
+              0 /* Type */) {}
 
 bool DefinedBitcode::classof(const SymbolBody *S) {
   return S->kind() == DefinedBitcodeKind;
 }
 
-Undefined::Undefined(SymbolBody::Kind K, StringRef N, uint8_t Binding,
-                     uint8_t Other, uint8_t Type)
-    : SymbolBody(K, N, Binding, Other, Type), CanKeepUndefined(false) {}
-
-Undefined::Undefined(SymbolBody::Kind K, uint32_t NameOffset,
-                     uint8_t Visibility, uint8_t Type)
-    : SymbolBody(K, NameOffset, Visibility, Type), CanKeepUndefined(false) {}
-
-Undefined::Undefined(StringRef N, bool IsWeak, uint8_t Visibility,
-                     bool CanKeepUndefined)
-    : Undefined(SymbolBody::UndefinedKind, N, IsWeak ? STB_WEAK : STB_GLOBAL,
-                Visibility, 0 /* Type */) {
+Undefined::Undefined(bool IsWeak, uint8_t Other, bool CanKeepUndefined)
+    : Undefined(SymbolBody::UndefinedKind, IsWeak ? STB_WEAK : STB_GLOBAL,
+                Other, 0) {
   this->CanKeepUndefined = CanKeepUndefined;
 }
 
-template <typename ELFT>
-UndefinedElf<ELFT>::UndefinedElf(StringRef N, const Elf_Sym &Sym)
-    : Undefined(SymbolBody::UndefinedElfKind, N, Sym.getBinding(), Sym.st_other,
-                Sym.getType()),
-      Size(Sym.st_size) {}
+Undefined::Undefined(SymbolBody::Kind K, uint8_t Binding, uint8_t Other,
+                     uint8_t Type)
+    : SymbolBody(K, Binding, Other, Type), CanKeepUndefined(false) {}
 
 template <typename ELFT>
 UndefinedElf<ELFT>::UndefinedElf(const Elf_Sym &Sym)
-    : Undefined(SymbolBody::UndefinedElfKind, NameOffset, Sym.st_other,
+    : Undefined(SymbolBody::UndefinedElfKind, Sym.getBinding(), Sym.st_other,
                 Sym.getType()),
-      Size(Sym.st_size) {
-  assert(Sym.getBinding() == STB_LOCAL);
-}
+      Size(Sym.st_size) {}
 
 template <typename ELFT>
-DefinedSynthetic<ELFT>::DefinedSynthetic(StringRef N, uintX_t Value,
+DefinedSynthetic<ELFT>::DefinedSynthetic(uintX_t Value,
                                          OutputSectionBase<ELFT> &Section,
                                          uint8_t Visibility)
-    : Defined(SymbolBody::DefinedSyntheticKind, N, STB_GLOBAL, Visibility,
+    : Defined(SymbolBody::DefinedSyntheticKind, STB_GLOBAL, Visibility,
               0 /* Type */),
       Value(Value), Section(Section) {}
 
-DefinedCommon::DefinedCommon(StringRef N, uint64_t Size, uint64_t Alignment,
-                             uint8_t Binding, uint8_t Visibility, uint8_t Type)
-    : Defined(SymbolBody::DefinedCommonKind, N, Binding, Visibility, Type),
+DefinedCommon::DefinedCommon(uint64_t Size, uint64_t Alignment, uint8_t Binding,
+                             uint8_t Visibility, uint8_t Type)
+    : Defined(SymbolBody::DefinedCommonKind, Binding, Visibility, Type),
       Alignment(Alignment), Size(Size) {}
 
 std::unique_ptr<InputFile> Lazy::getMember() {
   MemoryBufferRef MBRef = File->getMember(&Sym);
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (MBRef.getBuffer().empty())

ELF/Writer.cpp

void Writer<ELFT>::scanRelocs(InputSectionBase<ELFT> &S,
   ELFFile<ELFT> &EObj = S.getFile()->getObj();
   if (RelSec.sh_type == SHT_RELA)
     scanRelocs(S, EObj.relas(&RelSec));
   else
     scanRelocs(S, EObj.rels(&RelSec));
 }
 
 template <class ELFT>
-static void reportUndefined(SymbolTable<ELFT> &Symtab, SymbolBody *Sym) {
+static void reportUndefined(SymbolTable<ELFT> &Symtab, StringRef Name,
+                            SymbolBody *Sym) {
   if ((Config->Relocatable || Config->Shared) && !Config->NoUndefined)
     return;
 
-  std::string Msg = "undefined symbol: " + Sym->getName().str();
+  std::string Msg = "undefined symbol: " + Name.str();
   if (InputFile *File = Symtab.findFile(Sym))
     Msg += " in " + File->getName().str();
   if (Config->NoinhibitExec)
     warning(Msg);
   else
     error(Msg);
 }
 

 
 // Local symbols are not in the linker's symbol table. This function scans
 // each object file's symbol table to copy local symbols to the output.
 template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
   if (!Out<ELFT>::SymTab)
     return;
   for (const std::unique_ptr<elf::ObjectFile<ELFT>> &F :
        Symtab.getObjectFiles()) {
-    const char *StrTab = F->getStringTable().data();
-    for (SymbolBody *B : F->getLocalSymbols()) {
+    StringRef StrTab = F->getStringTable();
+    ArrayRef<SymbolBody *> Bodies = F->getSymbols();
+    unsigned Index = 0;
+    auto Syms = F->getElfSymbols(ELFFileBase<ELFT>::LOCAL_SYMBOLS);
+    for (const Elf_Sym &Sym : Syms) {
+      unsigned Cur = Index++;
+      SymbolBody *B = Bodies[Cur];
       auto *DR = dyn_cast<DefinedRegular<ELFT>>(B);
       // No reason to keep local undefined symbol in symtab.
       if (!DR)
         continue;
-      StringRef SymName(StrTab + B->getNameOffset());
+      StringRef SymName = check(Sym.getName(StrTab));
       InputSectionBase<ELFT> *Sec = DR->Section;
       if (!shouldKeepInSymtab<ELFT>(Sec, SymName, *B))
         continue;
       if (Sec && !Sec->Live)
         continue;
       ++Out<ELFT>::SymTab->NumLocals;
       if (Config->Relocatable)
         B->DynsymIndex = Out<ELFT>::SymTab->NumLocals;
template <class ELFT> void Writer<ELFT>::createSections() {
 
   // 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 (auto &P : Symtab.getSymbols()) {
     SymbolBody *Body = P.second->Body;
     if (auto *U = dyn_cast<Undefined>(Body))
       if (!U->isWeak() && !U->canKeepUndefined())
-        reportUndefined<ELFT>(Symtab, Body);
+        reportUndefined<ELFT>(Symtab, P.first, Body);
 
     if (auto *C = dyn_cast<DefinedCommon>(Body))
       CommonSymbols.push_back(C);
 
     if (!includeInSymtab<ELFT>(*Body))
       continue;
     if (Out<ELFT>::SymTab)
-      Out<ELFT>::SymTab->addSymbol(Body);
+      Out<ELFT>::SymTab->addSymbol(P.first, Body);
 
     if (isOutputDynamic() && includeInDynsym(*Body))
-      Out<ELFT>::DynSymTab->addSymbol(Body);
+      Out<ELFT>::DynSymTab->addSymbol(P.first, Body);
   }
 
   // Do not proceed if there was an undefined symbol.
   if (HasError)
     return;
 
   addCommonSymbols(CommonSymbols);