Add a Global symbol type

[• espindola]

Summary

This is an idea on how to fix the D46103 problem with VerdefIndex.

By having Global symbol type we can avoid having unused PltIndex, GotPltIndex and DynsymIndex in each local symbol. VerdefIndex could be moved there too.

This reduces peak allocation when linking chrome from 568.1 to 562.1.

[• espindola]

Fix a crash.

ELF/LinkerScript.cpp

void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
   // However, if an expression is `x = .`, there's no way to know its
   // value at the moment.
   //
   // We want to set symbol values early if we can. This allows us to
   // use symbols as variables in linker scripts. Doing so allows us to
   // write expressions like this: `alignment = 16; . = ALIGN(., alignment)`.
   uint64_t SymValue = Value.Sec ? 0 : Value.getValue();
 
-  replaceSymbol<Defined>(Sym, nullptr, Cmd->Name, STB_GLOBAL, Visibility,
-                         STT_NOTYPE, SymValue, 0, Sec);
+  replaceSymbol<Global>(Sym, nullptr, Cmd->Name, STB_GLOBAL, Visibility,
   Cmd->Sym = cast<Defined>(Sym);
 }
 
 // This function is called from LinkerScript::declareSymbols.
 // It creates a placeholder symbol if needed.
 static void declareSymbol(SymbolAssignment *Cmd) {
   if (!shouldDefineSym(Cmd))
     return;
 
   // We can't calculate final value right now.
   Symbol *Sym;
   uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
   std::tie(Sym, std::ignore) = Symtab->insert(Cmd->Name, /*Type*/ 0, Visibility,
                                               /*CanOmitFromDynSym*/ false,
                                               /*File*/ nullptr);
-  replaceSymbol<Defined>(Sym, nullptr, Cmd->Name, STB_GLOBAL, Visibility,
-                         STT_NOTYPE, 0, 0, nullptr);
+  replaceSymbol<Global>(Sym, nullptr, Cmd->Name, STB_GLOBAL, Visibility,
   Cmd->Sym = cast<Defined>(Sym);
   Cmd->Provide = false;
 }
 
 // This method is used to handle INSERT AFTER statement. Here we rebuild
 // the list of script commands to mix sections inserted into.
 void LinkerScript::processInsertCommands() {
   std::vector<BaseCommand *> V;

ELF/Relocations.cpp

if (isRelExprOneOf<R_ABS, R_TLSLD, R_TLSLD_PC>(Expr) && !Config->Shared) {
     return 1;
   }
 
   if (isRelExprOneOf<R_TLSDESC, R_TLSDESC_PAGE, R_TLSDESC_CALL, R_TLSGD,
                      R_TLSGD_PC>(Expr)) {
     if (Config->Shared) {
       if (InX::Got->addDynTlsEntry(Sym)) {
         uint64_t Off = InX::Got->getGlobalDynOffset(Sym);
-        InX::RelaDyn->addReloc(Target->TlsModuleIndexRel, InX::Got, Off, &Sym);
+        InX::RelaDyn->addReloc(Target->TlsModuleIndexRel, InX::Got, Off,
+                               Sym.IsPreemptible ? &Sym : nullptr);
 
         // If the symbol is preemptible we need the dynamic linker to write
         // the offset too.
         uint64_t OffsetOff = Off + Config->Wordsize;
         if (Sym.IsPreemptible)
           InX::RelaDyn->addReloc(Target->TlsOffsetRel, InX::Got, OffsetOff,
                                  &Sym);
         else

ELF/SymbolTable.cpp

if (Cmp < 0)
     return S;
 
   if (Cmp > 0) {
     auto *Bss = make<BssSection>("COMMON", Size, Alignment);
     Bss->File = &File;
     Bss->Live = !Config->GcSections;
     InputSections.push_back(Bss);
 
-    replaceSymbol<Defined>(S, &File, N, Binding, StOther, Type, 0, Size, Bss);
+    replaceSymbol<Global>(S, &File, N, Binding, StOther, Type, 0, Size, Bss);
     return S;
   }
 
   auto *D = cast<Defined>(S);
   auto *Bss = dyn_cast_or_null<BssSection>(D->Section);
   if (!Bss) {
     // Non-common symbols take precedence over common symbols.
     if (Config->WarnCommon)
Symbol *SymbolTable::addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
                                 SectionBase *Section, InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, Type, getVisibility(StOther),
                                     /*CanOmitFromDynSym*/ false, File);
   int Cmp = compareDefinedNonCommon(S, WasInserted, Binding, Section == nullptr,
                                     Value, Name);
   if (Cmp > 0)
-    replaceSymbol<Defined>(S, File, Name, Binding, StOther, Type, Value, Size,
-                           Section);
+    replaceSymbol<Global>(S, File, Name, Binding, StOther, Type, Value, Size,
   else if (Cmp == 0)
     reportDuplicate(S, File, dyn_cast_or_null<InputSectionBase>(Section),
                     Value);
   return S;
 }
 
 template <typename ELFT>
 void SymbolTable::addShared(StringRef Name, SharedFile<ELFT> &File,

ELF/Symbols.h

 struct StringRefZ {
   StringRefZ(const char *S) : Data(S), Size(-1) {}
   StringRefZ(StringRef S) : Data(S.data()), Size(S.size()) {}
 
   const char *Data;
   const uint32_t Size;
 };
 
+struct GlobalInfo {
+  uint32_t PltIndex = -1;
+  uint32_t GotPltIndex = -1;
+  uint32_t DynsymIndex = 0;
+  bool isInPlt() const { return PltIndex != -1U; }
+
+  uint64_t getGotPltOffset() const;
+};
+
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedKind,
+    GlobalKind,
     SharedKind,
     UndefinedKind,
     LazyArchiveKind,
     LazyObjectKind,
   };
 
   Kind kind() const { return static_cast<Kind>(SymbolKind); }
 
   // The file from which this symbol was created.
   InputFile *File;
 
 protected:
   const char *NameData;
   mutable uint32_t NameSize;
 
 public:
-  uint32_t DynsymIndex = 0;
   uint32_t GotIndex = -1;
-  uint32_t GotPltIndex = -1;
-  uint32_t PltIndex = -1;
   uint32_t GlobalDynIndex = -1;
 
   // Version definition index.
   uint16_t VersionId;
 
   // Symbol binding. This is not overwritten by replaceSymbol to track
   // changes during resolution. In particular:
   //  - An undefined weak is still weak when it resolves to a shared library.
public:
   // True if this symbol is specified by --trace-symbol option.
   unsigned Traced : 1;
 
   bool includeInDynsym() const;
   uint8_t computeBinding() const;
   bool isWeak() const { return Binding == llvm::ELF::STB_WEAK; }
 
   bool isUndefined() const { return SymbolKind == UndefinedKind; }
-  bool isDefined() const { return SymbolKind == DefinedKind; }
+  bool isDefined() const {
+    return SymbolKind == DefinedKind || SymbolKind == GlobalKind;
+  }
   bool isShared() const { return SymbolKind == SharedKind; }
   bool isLocal() const { return Binding == llvm::ELF::STB_LOCAL; }
 
   bool isLazy() const {
     return SymbolKind == LazyArchiveKind || SymbolKind == LazyObjectKind;
   }
 
   // True if this is an undefined weak symbol.
   bool isUndefWeak() const { return isWeak() && isUndefined(); }
 
   StringRef getName() const {
     if (NameSize == (uint32_t)-1)
       NameSize = strlen(NameData);
     return {NameData, NameSize};
   }
 
   void parseSymbolVersion();
 
   bool isInGot() const { return GotIndex != -1U; }
-  bool isInPlt() const { return PltIndex != -1U; }
+  bool isInPlt() const;
 
   uint64_t getVA(int64_t Addend = 0) const;
 
   uint64_t getGotOffset() const;
   uint64_t getGotVA() const;
   uint64_t getGotPltOffset() const;
   uint64_t getGotPltVA() const;
   uint64_t getPltVA() const;
   uint64_t getSize() const;
   OutputSection *getOutputSection() const;
+  GlobalInfo *getGlobalInfo();
+  const GlobalInfo *getGlobalInfo() const {
+    return const_cast<Symbol *>(this)->getGlobalInfo();
+  }
 
 protected:
   Symbol(Kind K, InputFile *File, StringRefZ Name, uint8_t Binding,
          uint8_t StOther, uint8_t Type)
       : File(File), NameData(Name.Data), NameSize(Name.Size), Binding(Binding),
         Type(Type), StOther(StOther), SymbolKind(K), NeedsPltAddr(false),
         IsInGlobalMipsGot(false), Is32BitMipsGot(false), IsInIplt(false),
         IsInIgot(false), IsPreemptible(false), Used(!Config->GcSections) {}
public:
   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; }
 };
 
 // Represents a symbol that is defined in the current output file.
 class Defined : public Symbol {
 public:
+  Defined(Kind K, InputFile *File, StringRefZ Name, uint8_t Binding,
+          uint8_t StOther, uint8_t Type, uint64_t Value, uint64_t Size,
+          SectionBase *Section)
+      : Symbol(K, File, Name, Binding, StOther, Type), Value(Value), Size(Size),
+        Section(Section) {}
+
   Defined(InputFile *File, StringRefZ Name, uint8_t Binding, uint8_t StOther,
           uint8_t Type, uint64_t Value, uint64_t Size, SectionBase *Section)
-      : Symbol(DefinedKind, File, Name, Binding, StOther, Type), Value(Value),
-        Size(Size), Section(Section) {}
+      : Defined(DefinedKind, File, Name, Binding, StOther, Type, Value, Size,
+                Section) {}
 
   static bool classof(const Symbol *S) { return S->isDefined(); }
 
   uint64_t Value;
   uint64_t Size;
   SectionBase *Section;
 };
 
+class Global : public Defined {
+public:
+  Global(InputFile *File, StringRefZ Name, uint8_t Binding, uint8_t StOther,
+         uint8_t Type, uint64_t Value, uint64_t Size, SectionBase *Section)
+      : Defined(GlobalKind, File, Name, Binding, StOther, Type, Value, Size,
+                Section) {}
+
+  static bool classof(const Symbol *S) { return S->kind() == GlobalKind; }
+
+  GlobalInfo Info;
+};
+
 class Undefined : public Symbol {
 public:
   Undefined(InputFile *File, StringRefZ Name, uint8_t Binding, uint8_t StOther,
             uint8_t Type)
       : Symbol(UndefinedKind, File, Name, Binding, StOther, Type) {}
 
+  GlobalInfo Info;
+
   static bool classof(const Symbol *S) { return S->kind() == UndefinedKind; }
 };
 
 class SharedSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) { return S->kind() == SharedKind; }
 
   SharedSymbol(InputFile &File, StringRef Name, uint8_t Binding,
SharedSymbol(InputFile &File, StringRef Name, uint8_t Binding,
     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);
   }
 
+  GlobalInfo Info;
+
   // 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;

ELF/Symbols.cpp

 Defined *ElfSym::End1;
 Defined *ElfSym::End2;
 Defined *ElfSym::GlobalOffsetTable;
 Defined *ElfSym::MipsGp;
 Defined *ElfSym::MipsGpDisp;
 Defined *ElfSym::MipsLocalGp;
 Defined *ElfSym::RelaIpltEnd;
 
+GlobalInfo *Symbol::getGlobalInfo() {
+  if (auto *U = dyn_cast<Undefined>(this))
+    return &U->Info;
+  if (auto *SS = dyn_cast<SharedSymbol>(this))
+    return &SS->Info;
+  if (auto *G = dyn_cast<Global>(this))
+    return &G->Info;
+  return nullptr;
+}
+
+uint64_t GlobalInfo::getGotPltOffset() const {
+  return GotPltIndex * Target->GotPltEntrySize;
+}
+
 static uint64_t getSymVA(const Symbol &Sym, int64_t &Addend) {
   switch (Sym.kind()) {
+  case Symbol::GlobalKind:
   case Symbol::DefinedKind: {
     auto &D = cast<Defined>(Sym);
     SectionBase *IS = D.Section;
 
     // According to the ELF spec reference to a local symbol from outside
     // the group are not allowed. Unfortunately .eh_frame breaks that rule
     // and must be treated specially. For now we just replace the symbol with
     // 0.

 
 uint64_t Symbol::getGotPltVA() const {
   if (this->IsInIgot)
     return InX::IgotPlt->getVA() + getGotPltOffset();
   return InX::GotPlt->getVA() + getGotPltOffset();
 }
 
 uint64_t Symbol::getGotPltOffset() const {
-  return GotPltIndex * Target->GotPltEntrySize;
+  return getGlobalInfo()->getGotPltOffset();
 }
 
 uint64_t Symbol::getPltVA() const {
-  if (this->IsInIplt)
+  uint32_t PltIndex = getGlobalInfo()->PltIndex;
+  if (IsInIplt)
     return InX::Iplt->getVA() + PltIndex * Target->PltEntrySize;
   return InX::Plt->getVA() + Target->getPltEntryOffset(PltIndex);
 }
 
+bool Symbol::isInPlt() const {
+  if (const GlobalInfo *Info = getGlobalInfo())
+    return Info->isInPlt();
+  return false;
+}
+
 uint64_t Symbol::getSize() const {
   if (const auto *DR = dyn_cast<Defined>(this))
     return DR->Size;
   if (const auto *S = dyn_cast<SharedSymbol>(this))
     return S->Size;
   return 0;
 }
 

ELF/SyntheticSections.cpp

void MipsGotSection::writeTo(uint8_t *Buf) {
   }
 }
 
 GotPltSection::GotPltSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                        Target->GotPltEntrySize, ".got.plt") {}
 
 void GotPltSection::addEntry(Symbol &Sym) {
-  Sym.GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size();
+  Sym.getGlobalInfo()->GotPltIndex =
+      Target->GotPltHeaderEntriesNum + Entries.size();
   Entries.push_back(&Sym);
 }
 
 size_t GotPltSection::getSize() const {
   return (Target->GotPltHeaderEntriesNum + Entries.size()) *
          Target->GotPltEntrySize;
 }
 

 // part of the .got.plt
 IgotPltSection::IgotPltSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                        Target->GotPltEntrySize,
                        Config->EMachine == EM_ARM ? ".got" : ".got.plt") {}
 
 void IgotPltSection::addEntry(Symbol &Sym) {
   Sym.IsInIgot = true;
-  Sym.GotPltIndex = Entries.size();
+  Sym.getGlobalInfo()->GotPltIndex = Entries.size();
   Entries.push_back(&Sym);
 }
 
 size_t IgotPltSection::getSize() const {
   return Entries.size() * Target->GotPltEntrySize;
 }
 
 void IgotPltSection::writeTo(uint8_t *Buf) {
if (Config->EMachine == EM_MIPS) {
     addInt(DT_MIPS_RLD_VERSION, 1);
     addInt(DT_MIPS_FLAGS, RHF_NOTPOT);
     addInt(DT_MIPS_BASE_ADDRESS, Target->getImageBase());
     addInt(DT_MIPS_SYMTABNO, InX::DynSymTab->getNumSymbols());
 
     add(DT_MIPS_LOCAL_GOTNO, [] { return InX::MipsGot->getLocalEntriesNum(); });
 
     if (const Symbol *B = InX::MipsGot->getFirstGlobalEntry())
-      addInt(DT_MIPS_GOTSYM, B->DynsymIndex);
+      addInt(DT_MIPS_GOTSYM, B->getGlobalInfo()->DynsymIndex);
     else
       addInt(DT_MIPS_GOTSYM, InX::DynSymTab->getNumSymbols());
     addInSec(DT_PLTGOT, InX::MipsGot);
     if (InX::MipsRldMap) {
       if (!Config->Pie)
         addInSec(DT_MIPS_RLD_MAP, InX::MipsRldMap);
       // Store the offset to the .rld_map section
       // relative to the address of the tag.

 int64_t DynamicReloc::computeAddend() const {
   if (UseSymVA)
     return Sym->getVA(Addend);
   return Addend;
 }
 
 uint32_t DynamicReloc::getSymIndex() const {
   if (Sym && !UseSymVA)
-    return Sym->DynsymIndex;
+    return Sym->getGlobalInfo()->DynsymIndex;
   return 0;
 }
 
 RelocationBaseSection::RelocationBaseSection(StringRef Name, uint32_t Type,
                                              int32_t DynamicTag,
                                              int32_t SizeDynamicTag)
     : SyntheticSection(SHF_ALLOC, Type, Config->Wordsize, Name),
       DynamicTag(DynamicTag), SizeDynamicTag(SizeDynamicTag) {}
if (InX::GnuHashTab) {
     // NB: It also sorts Symbols to meet the GNU hash table requirements.
     InX::GnuHashTab->addSymbols(Symbols);
   } else if (Config->EMachine == EM_MIPS) {
     std::stable_sort(Symbols.begin(), Symbols.end(), sortMipsSymbols);
   }
 
   size_t I = 0;
   for (const SymbolTableEntry &S : Symbols)
-    S.Sym->DynsymIndex = ++I;
+    S.Sym->getGlobalInfo()->DynsymIndex = ++I;
 }
 
 // The ELF spec requires that all local symbols precede global symbols, so we
 // sort symbol entries in this function. (For .dynsym, we don't do that because
 // symbols for dynamic linking are inherently all globals.)
 //
 // Aside from above, we put local symbols in groups starting with the STT_FILE
 // symbol. That is convenient for purpose of identifying where are local symbols
for (auto I = Symbols.begin(), E = Symbols.end(); I != E; ++I) {
     bool IsLastInChain = (I + 1) == E || I->BucketIdx != (I + 1)->BucketIdx;
     Hash = IsLastInChain ? Hash | 1 : Hash & ~1;
     write32(Values++, Hash);
 
     if (I->BucketIdx == OldBucket)
       continue;
     // Write a hash bucket. Hash buckets contain indices in the following hash
     // value table.
-    write32(Buckets + I->BucketIdx, I->Sym->DynsymIndex);
+    write32(Buckets + I->BucketIdx, I->Sym->getGlobalInfo()->DynsymIndex);
     OldBucket = I->BucketIdx;
   }
 }
 
 static uint32_t hashGnu(StringRef Name) {
   uint32_t H = 5381;
   for (uint8_t C : Name)
     H = (H << 5) + H + C;
void HashTableSection::writeTo(uint8_t *Buf) {
   write32(P++, NumSymbols); // nchain
 
   uint32_t *Buckets = P;
   uint32_t *Chains = P + NumSymbols;
 
   for (const SymbolTableEntry &S : InX::DynSymTab->getSymbols()) {
     Symbol *Sym = S.Sym;
     StringRef Name = Sym->getName();
-    unsigned I = Sym->DynsymIndex;
+    unsigned I = Sym->getGlobalInfo()->DynsymIndex;
     uint32_t Hash = hashSysV(Name) % NumSymbols;
     Chains[I] = Buckets[Hash];
     write32(Buckets + Hash, I);
   }
 }
 
 PltSection::PltSection(bool IsIplt)
     : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 16, ".plt"),
void PltSection::writeTo(uint8_t *Buf) {
   // The IPlt is immediately after the Plt, account for this in RelOff
   unsigned PltOff = getPltRelocOff();
 
   for (auto &I : Entries) {
     const Symbol *B = I.first;
     unsigned RelOff = I.second + PltOff;
     uint64_t Got = B->getGotPltVA();
     uint64_t Plt = this->getVA() + Off;
-    Target->writePlt(Buf + Off, Got, Plt, B->PltIndex, RelOff);
+    Target->writePlt(Buf + Off, Got, Plt, B->getGlobalInfo()->PltIndex, RelOff);
     Off += Target->PltEntrySize;
   }
 }
 
 template <class ELFT> void PltSection::addEntry(Symbol &Sym) {
-  Sym.PltIndex = Entries.size();
+  Sym.getGlobalInfo()->PltIndex = Entries.size();
   RelocationBaseSection *PltRelocSection = InX::RelaPlt;
   if (IsIplt) {
     PltRelocSection = InX::RelaIplt;
     Sym.IsInIplt = true;
   }
   unsigned RelOff =
       static_cast<RelocationSection<ELFT> *>(PltRelocSection)->getRelocOffset();
   Entries.push_back(std::make_pair(&Sym, RelOff));