Split Defined and DefinedElf

[• rafael]

Summary

This is similar to what was done for Undefined and opens the way for having a symbol defined in bitcode

[ruiu]

LGTM with a few nits.

ELF/Symbols.h

63–64

Why did you change the order?

140

elf -> ELF

152

Ah, so you changed the order for this. But this maybe too subtle? I'd define DefinedElfLast enum and do S->kind() <= DefinedElfLast here.

[grimar]

ELF/Symbols.h

152

I strongly agree here.

[Eugene.Zelenko]

Committed in r256354.

ELF/InputSection.cpp

for (const auto &RI : Rels) {
     return Buf + Offset;
   }
   return nullptr;
 }
 
 template <class ELFT>
 static typename llvm::object::ELFFile<ELFT>::uintX_t
 getSymSize(SymbolBody &Body) {
-  if (auto *SS = dyn_cast<Defined<ELFT>>(&Body))
+  if (auto *SS = dyn_cast<DefinedElf<ELFT>>(&Body))
     return SS->Sym.st_size;
   return 0;
 }
 
 template <class ELFT>
 template <bool isRela>
 void InputSectionBase<ELFT>::relocate(uint8_t *Buf, uint8_t *BufEnd,
                                       RelIteratorRange<isRela> Rels) {

ELF/OutputSections.cpp

void OutputSection<ELFT>::addSection(InputSection<ELFT> *C) {
   this->Header.sh_size = Off;
 }
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
   switch (S.kind()) {
   case SymbolBody::DefinedSyntheticKind: {
     auto &D = cast<DefinedSynthetic<ELFT>>(S);
-    return D.Section.getVA() + D.Sym.st_value;
+    return D.Section.getVA() + D.Value;
   }
   case SymbolBody::DefinedAbsoluteKind:
     return cast<DefinedAbsolute<ELFT>>(S).Sym.st_value;
   case SymbolBody::DefinedRegularKind: {
     const auto &DR = cast<DefinedRegular<ELFT>>(S);
     InputSectionBase<ELFT> &SC = DR.Section;
     if (DR.Sym.getType() == STT_TLS)
       return SC.OutSec->getVA() + SC.getOffset(DR.Sym) -
for (const Elf_Sym &Sym : Syms) {
       Buf += sizeof(*ESym);
     }
   }
 }
 
 template <class ELFT>
 static const typename llvm::object::ELFFile<ELFT>::Elf_Sym *
 getElfSym(SymbolBody &Body) {
-  if (auto *EBody = dyn_cast<Defined<ELFT>>(&Body))
+  if (auto *EBody = dyn_cast<DefinedElf<ELFT>>(&Body))
     return &EBody->Sym;
   if (auto *EBody = dyn_cast<UndefinedElf<ELFT>>(&Body))
     return &EBody->Sym;
   return nullptr;
 }
 
 template <class ELFT>
 void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {

 
 template <class ELFT>
 uint8_t SymbolTableSection<ELFT>::getSymbolBinding(SymbolBody *Body) {
   uint8_t Visibility = Body->getVisibility();
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return STB_LOCAL;
   if (const Elf_Sym *ESym = getElfSym<ELFT>(*Body))
     return ESym->getBinding();
+  if (isa<DefinedSynthetic<ELFT>>(Body))
+    return STB_LOCAL;
   return Body->isWeak() ? STB_WEAK : STB_GLOBAL;
 }
 
 template <class ELFT>
 MipsReginfoOutputSection<ELFT>::MipsReginfoOutputSection()
     : OutputSectionBase<ELFT>(".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC) {
   this->Header.sh_addralign = 4;
   this->Header.sh_entsize = sizeof(Elf_Mips_RegInfo);

ELF/SymbolTable.cpp

void SymbolTable<ELFT>::addAbsolute(StringRef Name,
                                     typename ELFFile<ELFT>::Elf_Sym &ESym) {
   resolve(new (Alloc) DefinedAbsolute<ELFT>(Name, ESym));
 }
 
 template <class ELFT>
 void SymbolTable<ELFT>::addSynthetic(StringRef Name,
                                      OutputSectionBase<ELFT> &Section,
                                      typename ELFFile<ELFT>::uintX_t Value) {
-  typedef typename DefinedSynthetic<ELFT>::Elf_Sym Elf_Sym;
-  auto *ESym = new (Alloc) Elf_Sym;
-  memset(ESym, 0, sizeof(Elf_Sym));
-  ESym->st_value = Value;
-  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, *ESym, Section);
+  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, Value, Section);
   resolve(Sym);
 }
 
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addIgnored(StringRef Name) {
   auto *Sym = new (Alloc)
       DefinedAbsolute<ELFT>(Name, DefinedAbsolute<ELFT>::IgnoreUndef);
   resolve(Sym);

ELF/Symbols.h

 // The base class for real symbol classes.
 class SymbolBody {
 public:
   enum Kind {
     DefinedFirst,
     DefinedRegularKind = DefinedFirst,
     DefinedAbsoluteKind,
     DefinedCommonKind,
-    DefinedSyntheticKind,
     SharedKind,
-    DefinedLast = SharedKind,
+    DefinedSyntheticKind,
+    DefinedLast = DefinedSyntheticKind,
     UndefinedElfKind,
     UndefinedKind,
     LazyKind
   };
 
   Kind kind() const { return static_cast<Kind>(SymbolKind); }
 
   bool isWeak() const { return IsWeak; }
protected:
   unsigned IsUsedInRegularObj : 1;
   unsigned IsUsedInDynamicReloc : 1;
   unsigned IsTls : 1;
   StringRef Name;
   Symbol *Backref = nullptr;
 };
 
 // The base class for any defined symbols, including absolute symbols, etc.
-template <class ELFT> class Defined : public SymbolBody {
+class Defined : public SymbolBody {
+public:
+  Defined(Kind K, StringRef Name, bool IsWeak, uint8_t Visibility, bool IsTls);
+  static bool classof(const SymbolBody *S) { return S->isDefined(); }
+};
+
+// Any defined symbol from an elf file.
+template <class ELFT> class DefinedElf : public Defined {
 protected:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
 
 public:
-  Defined(Kind K, StringRef N, const Elf_Sym &Sym)
-      : SymbolBody(K, N, Sym.getBinding() == llvm::ELF::STB_WEAK,
-                   Sym.getVisibility(), Sym.getType() == llvm::ELF::STT_TLS),
+  DefinedElf(Kind K, StringRef N, const Elf_Sym &Sym)
+      : Defined(K, N, Sym.getBinding() == llvm::ELF::STB_WEAK,
         Sym(Sym) {}
 
   const Elf_Sym &Sym;
-  static bool classof(const SymbolBody *S) { return S->isDefined(); }
+  static bool classof(const SymbolBody *S) { return S->kind() <= SharedKind; }
 };
 
-template <class ELFT> class DefinedAbsolute : public Defined<ELFT> {
+template <class ELFT> class DefinedAbsolute : public DefinedElf<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
 
 public:
   static Elf_Sym IgnoreUndef;
 
   // The following symbols must be added early to reserve their places
   // in symbol tables. The value of the symbols are set when all sections
   // are finalized and their addresses are determined.
 
   // The content for _end and end symbols.
   static Elf_Sym End;
 
   // The content for _gp symbol for MIPS target.
   static Elf_Sym MipsGp;
 
   // __rel_iplt_start/__rel_iplt_end for signaling
   // where R_[*]_IRELATIVE relocations do live.
   static Elf_Sym RelaIpltStart;
   static Elf_Sym RelaIpltEnd;
 
   DefinedAbsolute(StringRef N, const Elf_Sym &Sym)
-      : Defined<ELFT>(SymbolBody::DefinedAbsoluteKind, N, Sym) {}
+      : DefinedElf<ELFT>(SymbolBody::DefinedAbsoluteKind, N, Sym) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedAbsoluteKind;
   }
 };
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::IgnoreUndef;
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::End;
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::MipsGp;
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::RelaIpltStart;
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::RelaIpltEnd;
 
-template <class ELFT> class DefinedCommon : public Defined<ELFT> {
+template <class ELFT> class DefinedCommon : public DefinedElf<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
 
 public:
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   DefinedCommon(StringRef N, const Elf_Sym &Sym)
-      : Defined<ELFT>(SymbolBody::DefinedCommonKind, N, Sym) {
+      : DefinedElf<ELFT>(SymbolBody::DefinedCommonKind, N, Sym) {
     MaxAlignment = Sym.st_value;
   }
 
   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.
   uintX_t OffsetInBSS;
 
   // The maximum alignment we have seen for this symbol.
   uintX_t MaxAlignment;
 };
 
 // Regular defined symbols read from object file symbol tables.
-template <class ELFT> class DefinedRegular : public Defined<ELFT> {
+template <class ELFT> class DefinedRegular : public DefinedElf<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
 
 public:
   DefinedRegular(StringRef N, const Elf_Sym &Sym,
                  InputSectionBase<ELFT> &Section)
-      : Defined<ELFT>(SymbolBody::DefinedRegularKind, N, Sym),
+      : DefinedElf<ELFT>(SymbolBody::DefinedRegularKind, N, Sym),
         Section(Section) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedRegularKind;
   }
 
   InputSectionBase<ELFT> &Section;
 };
 
 // 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<ELFT> {
+template <class ELFT> class DefinedSynthetic : public Defined {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
-  DefinedSynthetic(StringRef N, const Elf_Sym &Sym,
-                   OutputSectionBase<ELFT> &Section)
-      : Defined<ELFT>(SymbolBody::DefinedSyntheticKind, N, Sym),
-        Section(Section) {}
+  typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
+  DefinedSynthetic(StringRef N, uintX_t Value,
+                   OutputSectionBase<ELFT> &Section);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedSyntheticKind;
   }
 
+  uintX_t Value;
   const OutputSectionBase<ELFT> &Section;
 };
 
 // Undefined symbol.
 class Undefined : public SymbolBody {
   typedef SymbolBody::Kind Kind;
   bool CanKeepUndefined;
 
public:
   UndefinedElf(StringRef N, const Elf_Sym &Sym);
   const Elf_Sym &Sym;
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::UndefinedElfKind;
   }
 };
 
-template <class ELFT> class SharedSymbol : public Defined<ELFT> {
+template <class ELFT> class SharedSymbol : public DefinedElf<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t 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<ELFT>(SymbolBody::SharedKind, Name, Sym), File(F) {}
+      : DefinedElf<ELFT>(SymbolBody::SharedKind, Name, Sym), File(F) {}
 
   SharedFile<ELFT> *File;
 
   // True if the linker has to generate a copy relocation for this shared
   // symbol. OffsetInBSS is significant only when NeedsCopy is true.
   bool NeedsCopy = false;
   uintX_t OffsetInBSS = 0;
 };

ELF/Symbols.cpp

if (isCommon()) {
     OtherC->MaxAlignment = Align;
     return -1;
   }
   if (Other->isCommon())
     return 1;
   return 0;
 }
 
+Defined::Defined(Kind K, StringRef Name, bool IsWeak, uint8_t Visibility,
+                 bool IsTls)
+    : SymbolBody(K, Name, IsWeak, Visibility, IsTls) {}
+
 Undefined::Undefined(SymbolBody::Kind K, StringRef N, bool IsWeak,
                      uint8_t Visibility, bool IsTls)
     : SymbolBody(K, N, IsWeak, Visibility, IsTls), CanKeepUndefined(false) {}
 
 Undefined::Undefined(StringRef N, bool IsWeak, uint8_t Visibility,
                      bool CanKeepUndefined)
     : Undefined(SymbolBody::UndefinedKind, N, IsWeak, Visibility,
                 /*IsTls*/ false) {
   this->CanKeepUndefined = CanKeepUndefined;
 }
 
 template <typename ELFT>
 UndefinedElf<ELFT>::UndefinedElf(StringRef N, const Elf_Sym &Sym)
     : Undefined(SymbolBody::UndefinedElfKind, N,
                 Sym.getBinding() == llvm::ELF::STB_WEAK, Sym.getVisibility(),
                 Sym.getType() == llvm::ELF::STT_TLS),
       Sym(Sym) {}
 
+template <typename ELFT>
+DefinedSynthetic<ELFT>::DefinedSynthetic(StringRef N, uintX_t Value,
+                                         OutputSectionBase<ELFT> &Section)
+    : Defined(SymbolBody::DefinedSyntheticKind, N, false, STV_DEFAULT, false),
+      Value(Value), Section(Section) {}
+
 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())
     return std::unique_ptr<InputFile>(nullptr);
 

 template int SymbolBody::compare<ELF32BE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF64LE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF64BE>(SymbolBody *Other);
 
 template class lld::elf2::UndefinedElf<ELF32LE>;
 template class lld::elf2::UndefinedElf<ELF32BE>;
 template class lld::elf2::UndefinedElf<ELF64LE>;
 template class lld::elf2::UndefinedElf<ELF64BE>;
+
+template class lld::elf2::DefinedSynthetic<ELF32LE>;
+template class lld::elf2::DefinedSynthetic<ELF32BE>;
+template class lld::elf2::DefinedSynthetic<ELF64LE>;
+template class lld::elf2::DefinedSynthetic<ELF64BE>;

ELF/Target.cpp

 template <unsigned N> static void checkAlignment(uint64_t V, uint32_t Type) {
   if ((V & (N - 1)) == 0)
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
   error("Improper alignment for relocation " + S);
 }
 
 template <class ELFT> bool isGnuIFunc(const SymbolBody &S) {
-  if (auto *SS = dyn_cast<Defined<ELFT>>(&S))
+  if (auto *SS = dyn_cast<DefinedElf<ELFT>>(&S))
     return SS->Sym.getType() == STT_GNU_IFUNC;
   return false;
 }
 
 template bool isGnuIFunc<ELF32LE>(const SymbolBody &S);
 template bool isGnuIFunc<ELF32BE>(const SymbolBody &S);
 template bool isGnuIFunc<ELF64LE>(const SymbolBody &S);
 template bool isGnuIFunc<ELF64BE>(const SymbolBody &S);