[ELF] Implement LLVM-style casting for OutputSectionBase<ELFT> derived classes

[evgeny777]

Summary

This will be useful for linker script symbol processing, because symbols inside OutputSection, MergeOutputSection and EhOutputSection should be process in different ways.

[grimar]

ELF/OutputSections.h

73

Unsorted.

108

Do you need this ?

[evgeny777]

Addressed review comments

[ruiu]

LGTM

ELF/OutputSections.h

52

I don't think we need Base because all OutputSectionBases are of Base class. You'll never need to do cast<OutputSectionBase<ELFT>>(P).

138

We usually pass a Kind to the base class's ctor, but this way seems OK because we already have virtual member functions.

[evgeny777]

ELF/OutputSections.h

52

Out<ELFT>::ProgramHeaders are of type OutputSectionBase<ELFT>, so I can't make getKind() pure virtual in this class.

ELF/OutputSections.h

 // Different sub classes represent different types of sections. Some contain
 // input sections, others are created by the linker.
 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
 template <class ELFT> class OutputSectionBase {
 public:
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Shdr Elf_Shdr;
+  enum Kind {
+    Base,
+    BuildId,
+    Dynamic,
+    EHFrame,
+    EHFrameHdr,
+    GnuHashTable,
+    Got,
+    GotPlt,
+    HashTable,
+    Interp,
+    Merge,
+    MipsReginfo,
+    MipsOptions,
+    Plt,
+    Regular,
+    Reloc,
+    StrTable,
+    SymTable,
+    VersDef,
+    VersNeed,
+    VersTable
+  };
 
   OutputSectionBase(StringRef Name, uint32_t Type, uintX_t Flags);
   void setVA(uintX_t VA) { Header.sh_addr = VA; }
   uintX_t getVA() const { return Header.sh_addr; }
   void setFileOffset(uintX_t Off) { Header.sh_offset = Off; }
   void setSHName(unsigned Val) { Header.sh_name = Val; }
   void writeHeaderTo(Elf_Shdr *SHdr);
   StringRef getName() { return Name; }
 
   virtual void addSection(InputSectionBase<ELFT> *C) {}
+  virtual Kind getKind() const { return Base; }
+  static bool classof(const OutputSectionBase<ELFT> *B) {
+    return B->getKind() == Base;
+  }
 
   unsigned SectionIndex;
 
   // Returns the size of the section in the output file.
   uintX_t getSize() const { return Header.sh_size; }
   void setSize(uintX_t Val) { Header.sh_size = Val; }
   uintX_t getFlags() const { return Header.sh_flags; }
   uint32_t getPhdrFlags() const;
   uintX_t getFileOff() const { return Header.sh_offset; }
   uintX_t getAlignment() const { return Header.sh_addralign; }
   uint32_t getType() const { return Header.sh_type; }
 
   void updateAlignment(uintX_t Alignment) {
     if (Alignment > Header.sh_addralign)
       Header.sh_addralign = Alignment;
   }
 
   // If true, this section will be page aligned on disk.
   // Typically the first section of each PT_LOAD segment has this flag.
   bool PageAlign = false;
 
   virtual void finalize() {}
   virtual void finalizePieces() {}
   virtual void assignOffsets() {}
   virtual void writeTo(uint8_t *Buf) {}
   virtual ~OutputSectionBase() = default;
 
 protected:
   StringRef Name;
public:
   bool addDynTlsEntry(SymbolBody &Sym);
   bool addTlsIndex();
   bool empty() const { return MipsPageEntries == 0 && Entries.empty(); }
   uintX_t getMipsLocalPageOffset(uintX_t Addr);
   uintX_t getMipsGotOffset(const SymbolBody &B, uintX_t Addend) const;
   uintX_t getGlobalDynAddr(const SymbolBody &B) const;
   uintX_t getGlobalDynOffset(const SymbolBody &B) const;
   uintX_t getNumEntries() const { return Entries.size(); }
+  typename Base::Kind getKind() const override { return Base::Got; }
+  static bool classof(const Base *B) { return B->getKind() == Base::Got; }
 
   // Returns the symbol which corresponds to the first entry of the global part
   // of GOT on MIPS platform. It is required to fill up MIPS-specific dynamic
   // table properties.
   // Returns nullptr if the global part is empty.
   const SymbolBody *getMipsFirstGlobalEntry() const;
 
   // Returns the number of entries in the local part of GOT including
private:
 
   // Write MIPS-specific parts of the GOT.
   void writeMipsGot(uint8_t *&Buf);
 };
 
 template <class ELFT>
 class GotPltSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::uint uintX_t;
+  typedef OutputSectionBase<ELFT> Base;
 
 public:
   GotPltSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody &Sym);
   bool empty() const;
+  typename Base::Kind getKind() const override { return Base::GotPlt; }
+  static bool classof(const Base *B) { return B->getKind() == Base::GotPlt; }
 
 private:
   std::vector<const SymbolBody *> Entries;
 };
 
 template <class ELFT> class PltSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename ELFT::uint uintX_t;
 
 public:
   PltSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody &Sym);
   bool empty() const { return Entries.empty(); }
+  typename Base::Kind getKind() const override { return Base::Plt; }
+  static bool classof(const Base *B) { return B->getKind() == Base::Plt; }
 
 private:
   std::vector<std::pair<const SymbolBody *, unsigned>> Entries;
 };
 
 template <class ELFT> class DynamicReloc {
   typedef typename ELFT::uint uintX_t;
 
private:
   const OutputSectionBase<ELFT> *OutputSec = nullptr;
   uintX_t OffsetInSec;
   bool UseSymVA;
   uintX_t Addend;
 };
 
 template <class ELFT>
 class SymbolTableSection final : public OutputSectionBase<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
+
 public:
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::SymRange Elf_Sym_Range;
   typedef typename ELFT::uint uintX_t;
   SymbolTableSection(StringTableSection<ELFT> &StrTabSec);
 
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addSymbol(SymbolBody *Body);
   StringTableSection<ELFT> &getStrTabSec() const { return StrTabSec; }
   unsigned getNumSymbols() const { return NumLocals + Symbols.size() + 1; }
+  typename Base::Kind getKind() const override { return Base::SymTable; }
+  static bool classof(const Base *B) { return B->getKind() == Base::SymTable; }
 
   ArrayRef<std::pair<SymbolBody *, size_t>> getSymbols() const {
     return Symbols;
   }
 
   unsigned NumLocals = 0;
   StringTableSection<ELFT> &StrTabSec;
 

 // contain symbol version definitions. The number of entries in this section
 // shall be contained in the DT_VERDEFNUM entry of the .dynamic section.
 // The section shall contain an array of Elf_Verdef structures, optionally
 // followed by an array of Elf_Verdaux structures.
 template <class ELFT>
 class VersionDefinitionSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Verdaux Elf_Verdaux;
+  typedef OutputSectionBase<ELFT> Base;
 
 public:
   VersionDefinitionSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
+  typename Base::Kind getKind() const override { return Base::VersDef; }
+  static bool classof(const Base *B) { return B->getKind() == Base::VersDef; }
 
 private:
   void writeOne(uint8_t *Buf, uint32_t Index, StringRef Name, size_t NameOff);
 
   unsigned FileDefNameOff;
 };
 
 // The .gnu.version section specifies the required version of each symbol in the
 // dynamic symbol table. It contains one Elf_Versym for each dynamic symbol
 // table entry. An Elf_Versym is just a 16-bit integer that refers to a version
 // identifier defined in the either .gnu.version_r or .gnu.version_d section.
 // The values 0 and 1 are reserved. All other values are used for versions in
 // the own object or in any of the dependencies.
 template <class ELFT>
 class VersionTableSection final : public OutputSectionBase<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
   typedef typename ELFT::Versym Elf_Versym;
 
 public:
   VersionTableSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
+  typename Base::Kind getKind() const override { return Base::VersTable; }
+  static bool classof(const Base *B) { return B->getKind() == Base::VersTable; }
 };
 
 // The .gnu.version_r section defines the version identifiers used by
 // .gnu.version. It contains a linked list of Elf_Verneed data structures. Each
 // Elf_Verneed specifies the version requirements for a single DSO, and contains
 // a reference to a linked list of Elf_Vernaux data structures which define the
 // mapping from version identifiers to version names.
 template <class ELFT>
 class VersionNeedSection final : public OutputSectionBase<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
   typedef typename ELFT::Verneed Elf_Verneed;
   typedef typename ELFT::Vernaux Elf_Vernaux;
 
   // A vector of shared files that need Elf_Verneed data structures and the
   // string table offsets of their sonames.
   std::vector<std::pair<SharedFile<ELFT> *, size_t>> Needed;
 
   // The next available version identifier.
   unsigned NextIndex;
 
 public:
   VersionNeedSection();
   void addSymbol(SharedSymbol<ELFT> *SS);
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getNeedNum() const { return Needed.size(); }
+  typename Base::Kind getKind() const override { return Base::VersNeed; }
+  static bool classof(const Base *B) { return B->getKind() == Base::VersNeed; }
 };
 
 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;
+  typedef OutputSectionBase<ELFT> Base;
 
 public:
   RelocationSection(StringRef Name, bool Sort);
   void addReloc(const DynamicReloc<ELFT> &Reloc);
   unsigned getRelocOffset();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   bool hasRelocs() const { return !Relocs.empty(); }
+  typename Base::Kind getKind() const override { return Base::Reloc; }
+  static bool classof(const Base *B) { return B->getKind() == Base::Reloc; }
 
 private:
   bool Sort;
   std::vector<DynamicReloc<ELFT>> Relocs;
 };
 
 template <class ELFT>
 class OutputSection final : public OutputSectionBase<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
+
 public:
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::uint uintX_t;
   OutputSection(StringRef Name, uint32_t Type, uintX_t Flags);
   void addSection(InputSectionBase<ELFT> *C) override;
   void sortInitFini();
   void sortCtorsDtors();
   void writeTo(uint8_t *Buf) override;
   void finalize() override;
   void assignOffsets() override;
+  typename Base::Kind getKind() const override { return Base::Regular; }
+  static bool classof(const Base *B) { return B->getKind() == Base::Regular; }
   std::vector<InputSection<ELFT> *> Sections;
 };
 
 template <class ELFT>
 class MergeOutputSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::uint uintX_t;
+  typedef OutputSectionBase<ELFT> Base;
 
 public:
   MergeOutputSection(StringRef Name, uint32_t Type, uintX_t Flags,
                      uintX_t Alignment);
   void addSection(InputSectionBase<ELFT> *S) override;
   void writeTo(uint8_t *Buf) override;
   unsigned getOffset(StringRef Val);
   void finalize() override;
   void finalizePieces() override;
   bool shouldTailMerge() const;
+  typename Base::Kind getKind() const override { return Base::Merge; }
+  static bool classof(const Base *B) { return B->getKind() == Base::Merge; }
 
 private:
   llvm::StringTableBuilder Builder;
   std::vector<MergeInputSection<ELFT> *> Sections;
 };
 
 struct CieRecord {
   EhSectionPiece *Piece = nullptr;
   std::vector<EhSectionPiece *> FdePieces;
 };
 
 // Output section for .eh_frame.
 template <class ELFT>
 class EhOutputSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
+  typedef OutputSectionBase<ELFT> Base;
 
 public:
   EhOutputSection();
   void writeTo(uint8_t *Buf) override;
   void finalize() override;
   bool empty() const { return Sections.empty(); }
 
   void addSection(InputSectionBase<ELFT> *S) override;
+  typename Base::Kind getKind() const override { return Base::EHFrame; }
+  static bool classof(const Base *B) { return B->getKind() == Base::EHFrame; }
 
   size_t NumFdes = 0;
 
 private:
   template <class RelTy>
   void addSectionAux(EhInputSection<ELFT> *S, llvm::ArrayRef<RelTy> Rels);
 
   template <class RelTy>
private:
   std::vector<CieRecord *> Cies;
 
   // CIE records are uniquified by their contents and personality functions.
   llvm::DenseMap<std::pair<ArrayRef<uint8_t>, SymbolBody *>, CieRecord> CieMap;
 };
 
 template <class ELFT>
 class InterpSection final : public OutputSectionBase<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
+
 public:
   InterpSection();
   void writeTo(uint8_t *Buf) override;
+  typename Base::Kind getKind() const override { return Base::Interp; }
+  static bool classof(const Base *B) { return B->getKind() == Base::Interp; }
 };
 
 template <class ELFT>
 class StringTableSection final : public OutputSectionBase<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
+
 public:
   typedef typename ELFT::uint uintX_t;
   StringTableSection(StringRef Name, bool Dynamic);
   unsigned addString(StringRef S, bool HashIt = true);
   void writeTo(uint8_t *Buf) override;
   unsigned getSize() const { return Size; }
   void finalize() override { this->Header.sh_size = getSize(); }
   bool isDynamic() const { return Dynamic; }
+  typename Base::Kind getKind() const override { return Base::StrTable; }
+  static bool classof(const Base *B) { return B->getKind() == Base::StrTable; }
 
 private:
   const bool Dynamic;
   llvm::DenseMap<StringRef, unsigned> StringMap;
   std::vector<StringRef> Strings;
   unsigned Size = 1; // ELF string tables start with a NUL byte, so 1.
 };
 
 template <class ELFT>
 class HashTableSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::Word Elf_Word;
+  typedef OutputSectionBase<ELFT> Base;
 
 public:
   HashTableSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
+  typename Base::Kind getKind() const override { return Base::HashTable; }
+  static bool classof(const Base *B) { return B->getKind() == Base::HashTable; }
 };
 
 // Outputs GNU Hash section. For detailed explanation see:
 // https://blogs.oracle.com/ali/entry/gnu_hash_elf_sections
 template <class ELFT>
 class GnuHashTableSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::Off Elf_Off;
   typedef typename ELFT::Word Elf_Word;
   typedef typename ELFT::uint uintX_t;
+  typedef OutputSectionBase<ELFT> Base;
 
 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);
+  typename Base::Kind getKind() const override { return Base::GnuHashTable; }
+  static bool classof(const Base *B) {
+    return B->getKind() == Base::GnuHashTable;
+  }
 
 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);
class DynamicSection final : public OutputSectionBase<ELFT> {
   // cannot directly create final section contents because when the
   // function is called, symbol or section addresses are not fixed yet.
   std::vector<Entry> Entries;
 
 public:
   explicit DynamicSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
+  typename Base::Kind getKind() const override { return Base::Dynamic; }
+  static bool classof(const Base *B) { return B->getKind() == Base::Dynamic; }
 };
 
 template <class ELFT>
 class MipsReginfoOutputSection final : public OutputSectionBase<ELFT> {
   typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
+  typedef OutputSectionBase<ELFT> Base;
 
 public:
   MipsReginfoOutputSection();
   void writeTo(uint8_t *Buf) override;
   void addSection(InputSectionBase<ELFT> *S) override;
+  typename Base::Kind getKind() const override { return Base::MipsReginfo; }
+  static bool classof(const Base *B) {
+    return B->getKind() == Base::MipsReginfo;
+  }
 
 private:
   uint32_t GprMask = 0;
 };
 
 template <class ELFT>
 class MipsOptionsOutputSection final : public OutputSectionBase<ELFT> {
   typedef llvm::object::Elf_Mips_Options<ELFT> Elf_Mips_Options;
   typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
+  typedef OutputSectionBase<ELFT> Base;
 
 public:
   MipsOptionsOutputSection();
   void writeTo(uint8_t *Buf) override;
   void addSection(InputSectionBase<ELFT> *S) override;
+  typename Base::Kind getKind() const override { return Base::MipsOptions; }
+  static bool classof(const Base *B) {
+    return B->getKind() == Base::MipsOptions;
+  }
 
 private:
   uint32_t GprMask = 0;
 };
 
 // --eh-frame-hdr option tells linker to construct a header for all the
 // .eh_frame sections. This header is placed to a section named .eh_frame_hdr
 // and also to a PT_GNU_EH_FRAME segment.
 // At runtime the unwinder then can find all the PT_GNU_EH_FRAME segments by
 // calling dl_iterate_phdr.
 // This section contains a lookup table for quick binary search of FDEs.
 // Detailed info about internals can be found in Ian Lance Taylor's blog:
 // http://www.airs.com/blog/archives/460 (".eh_frame")
 // http://www.airs.com/blog/archives/462 (".eh_frame_hdr")
 template <class ELFT>
 class EhFrameHeader final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::uint uintX_t;
+  typedef OutputSectionBase<ELFT> Base;
 
 public:
   EhFrameHeader();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addFde(uint32_t Pc, uint32_t FdeVA);
+  typename Base::Kind getKind() const override { return Base::EHFrameHdr; }
+  static bool classof(const Base *B) {
+    return B->getKind() == Base::EHFrameHdr;
+  }
 
 private:
   struct FdeData {
     uint32_t Pc;
     uint32_t FdeVA;
   };
 
   std::vector<FdeData> Fdes;
 };
 
 template <class ELFT> class BuildIdSection : public OutputSectionBase<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
+
 public:
   void writeTo(uint8_t *Buf) override;
   virtual void writeBuildId(ArrayRef<ArrayRef<uint8_t>> Bufs) = 0;
+  typename Base::Kind getKind() const override { return Base::BuildId; }
+  static bool classof(const Base *B) { return B->getKind() == Base::BuildId; }
 
 protected:
   BuildIdSection(size_t HashSize);
   size_t HashSize;
   uint8_t *HashBuf = nullptr;
 };
 
 template <class ELFT> class BuildIdFnv1 final : public BuildIdSection<ELFT> {