Read section headers upfront

[• rafael]

Summary

Instead of storing a pointer, store the members we need.

The reason for doing this is that it makes it far easier to create synthetic sections. It also avoids reading data from files multiple times., which might help with cross endian linking and host architectures with slow unaligned access.

There are obvious compacting opportunities, but this already has mixed results even on native x86_64 linking.

There is also the possibility of better refactoring the code for handling common symbols, but this already shows that a custom class is not necessary.

In summary, I would like to commit this an iterate if you guys are OK with it.

The perf number I got on native x86_64 are

firefox

master 7.309622414
patch  7.285605127 1.00329653976x faster

firefox-gc

master 7.510372903
patch  7.485952007 1.00326222984x faster

chromium

master 5.310620915
patch  5.269296067 1.0078425747x faster

chromium fast

master 2.062932807
patch  2.080311297 1.00842416677x slower

the gold plugin

master 0.356284971
patch  0.356714755 1.00120629281x slower

clang

master 0.602845631
patch  0.604443573 1.00265066531x slower

llvm-as

master 0.034642356
patch  0.034852631 1.00606988162x slower

the gold plugin fsds

master 0.3861195
patch  0.388452457 1.00604205952x slower

clang fsds

master 0.688210298
patch  0.689806352 1.00231913705x slower

llvm-as fsds

master 0.0320734
patch  0.032240692 1.005215911x slower

scylla

master 3.249120693
patch  3.246897164 1.00068481658x faster

I am building lld on a big endian power8 and will try to bencmark a cross link of an x86_64 binary.

[• rafael]

added llvm-commits

[• rafael]

I just benchmarked on ppc64. Unfortunately I don't have root in the machine, so I am getting over 1% variation in each run and so this patch is in the noise there.

[davide]

If you plan to iterate on this, probably it's fine, but my reaction when I see your number is that the performance effect of the change is pretty much neutral. Sure, you have some slowdowns and some improvements, but they vary roughly between 0.1% and 0.5% , which, no matter how controlled the enviroment on which we're running tests, could be caused by other factors.

[ruiu]

Thank you for doing this. I agree that it should make things easier to create linker-synthesized input sections.

ELF/InputSection.cpp

35–36

What is this change for?

846

Is it a common practice to create an ArrayRef with non-zero size and a nullptr? It seems odd to me.

ELF/InputSection.h

93

Please add a comment to note that they correspond to Elf_Shdr.

124–129

Do you still need these accessors?

285–286

Please update the comment becasue "this class" no longer exists.

[• rafael]

Address review comments

[ruiu]

LGTM.

So now that I'm not sure if I liked the separation of data and size. If you want to revert it, please do it.

[• rafael]

Avoid creating an ArrayRef with nullptr.

[• espindola]

285148

ELF/ICF.cpp

if (RA->sh_type == SHT_RELA) {
         return false;
     } else {
       if (!relocationEq(FileA.rels(RA), FileB.rels(RB)))
         return false;
     }
   }
 
   return A->getFlags() == B->getFlags() && A->getSize() == B->getSize() &&
-         A->Data == B->Data;
+         A->getData() == B->getData();
 }
 
 template <class ELFT>
 template <class RelTy>
 bool ICF<ELFT>::variableEq(const InputSection<ELFT> *A,
                            const InputSection<ELFT> *B, ArrayRef<RelTy> RelsA,
                            ArrayRef<RelTy> RelsB) {
   const RelTy *IA = RelsA.begin();

ELF/InputSection.h

 // if symbol should be placed at the very beginning of the output
 // section
 class InputSectionData {
 public:
   enum Kind { Regular, EHFrame, Merge, MipsReginfo, MipsOptions, MipsAbiFlags };
 
   // The garbage collector sets sections' Live bits.
   // If GC is disabled, all sections are considered live by default.
-  InputSectionData(Kind SectionKind, StringRef Name, ArrayRef<uint8_t> Data,
-                   bool Compressed, bool Live)
+  InputSectionData(Kind SectionKind, StringRef Name, const uint8_t *Data,
+                   size_t Size, bool Compressed, bool Live)
       : SectionKind(SectionKind), Live(Live), Compressed(Compressed),
-        Name(Name), Data(Data) {}
+        Name(Name), Data(Data), Size(Size) {}
 
 private:
   unsigned SectionKind : 3;
 
 public:
   Kind kind() const { return (Kind)SectionKind; }
 
   unsigned Live : 1; // for garbage collection
   unsigned Compressed : 1;
   uint32_t Alignment;
   StringRef Name;
-  ArrayRef<uint8_t> Data;
+
+  const uint8_t *Data;
+  size_t Size;
+
+  llvm::ArrayRef<uint8_t> getData() const {
+    return llvm::makeArrayRef(Data, Size);
+  }
+
+  template <typename T> llvm::ArrayRef<T> getDataAs() const {
+    assert(Size % sizeof(T) == 0);
+    return llvm::makeArrayRef<T>((const T *)Data, Size / sizeof(T));
+  }
 
   // If a section is compressed, this has the uncompressed section data.
   std::unique_ptr<uint8_t[]> UncompressedData;
 
   std::vector<Relocation> Relocations;
 };
 
 // This corresponds to a section of an input file.
 template <class ELFT> class InputSectionBase : public InputSectionData {
 protected:
   typedef typename ELFT::Chdr Elf_Chdr;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::uint uintX_t;
-  const Elf_Shdr *Header;
 
   // The file this section is from.
   ObjectFile<ELFT> *File;
 
+  // These corresponds to the fields in Elf_Shdr.
+  uintX_t Flags;
+  uintX_t Entsize;
+  uint32_t Type;
+  uint32_t Link;
+  uint32_t Info;
+
 public:
   InputSectionBase()
-      : InputSectionData(Regular, "", ArrayRef<uint8_t>(), false, false),
-        Repl(this) {}
+      : InputSectionData(Regular, "", nullptr, 0, false, false), Repl(this) {}
 
   InputSectionBase(ObjectFile<ELFT> *File, const Elf_Shdr *Header,
                    StringRef Name, Kind SectionKind);
+  InputSectionBase(ObjectFile<ELFT> *File, uintX_t Flags, uint32_t Type,
+                   uintX_t Entsize, uint32_t Link, uint32_t Info,
+                   uintX_t Addralign, const uint8_t *Data, size_t Size,
+                   StringRef Name, Kind SectionKind);
   OutputSectionBase<ELFT> *OutSec = nullptr;
 
   // This pointer points to the "real" instance of this instance.
   // Usually Repl == this. However, if ICF merges two sections,
   // Repl pointer of one section points to another section. So,
   // if you need to get a pointer to this instance, do not use
   // this but instead this->Repl.
   InputSectionBase<ELFT> *Repl;
 
   // Returns the size of this section (even if this is a common or BSS.)
   size_t getSize() const;
 
   static InputSectionBase<ELFT> Discarded;
 
-  uintX_t getFlags() const { return Header->sh_flags; }
-  uint32_t getType() const { return Header->sh_type; }
-  uintX_t getEntsize() const { return Header->sh_entsize; }
-  uint32_t getLink() const { return Header->sh_link; }
-  uint32_t getInfo() const { return Header->sh_info; }
+  uintX_t getFlags() const { return Flags; }
+  uint32_t getType() const { return Type; }
+  uintX_t getEntsize() const { return Entsize; }
+  uint32_t getLink() const { return Link; }
+  uint32_t getInfo() const { return Info; }
   ObjectFile<ELFT> *getFile() const { return File; }
   uintX_t getOffset(const DefinedRegular<ELFT> &Sym) const;
   InputSectionBase *getLinkOrderDep() const;
   // Translate an offset in the input section to an offset in the output
   // section.
   uintX_t getOffset(uintX_t Offset) const;
 
   void uncompress();
 
template <class ELFT> class InputSection : public InputSectionBase<ELFT> {
   typedef InputSectionBase<ELFT> Base;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::uint uintX_t;
 
 public:
+  InputSection(uintX_t Flags, uint32_t Type, uintX_t Addralign,
+               const uint8_t *Data, size_t Size);
   InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header, StringRef Name);
 
   // Write this section to a mmap'ed file, assuming Buf is pointing to
   // beginning of the output section.
   void writeTo(uint8_t *Buf);
 
   // Relocation sections that refer to this one.
   llvm::TinyPtrVector<const Elf_Shdr *> RelocSections;
public:
   uint64_t getThunkOff() const;
 
   // Size of chunk with thunks code.
   uint64_t getThunksSize() const;
 
   template <class RelTy>
   void relocateNonAlloc(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
 
+  // Common symbols don't belong to any section. But it is easier for us
+  // to handle them as if they belong to some input section. So we defined
+  // this section that "contains" all common symbols.
+  static InputSection<ELFT> *CommonInputSection;
+
+  static InputSection<ELFT>
+  createCommonInputSection(std::vector<DefinedCommon *> Syms);
+
 private:
   template <class RelTy>
   void copyRelocations(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
 
   // Called by ICF to merge two input sections.
   void replace(InputSection<ELFT> *Other);
 
   // Used by ICF.
   uint64_t GroupId = 0;
 
   llvm::TinyPtrVector<const Thunk<ELFT> *> Thunks;
 };
 
+template <class ELFT>
+InputSection<ELFT> *InputSection<ELFT>::CommonInputSection;
+
 // MIPS .reginfo section provides information on the registers used by the code
 // in the object file. Linker should collect this information and write a single
 // .reginfo section in the output file. The output section contains a union of
 // used registers masks taken from input .reginfo sections and final value
 // of the `_gp` symbol.  For details: Chapter 4 / "Register Information" at
 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
 template <class ELFT>
 class MipsReginfoInputSection : public InputSectionBase<ELFT> {

 public:
   MipsAbiFlagsInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Hdr,
                            StringRef Name);
   static bool classof(const InputSectionBase<ELFT> *S);
 
   const llvm::object::Elf_Mips_ABIFlags<ELFT> *Flags = nullptr;
 };
 
-// Common symbols don't belong to any section. But it is easier for us
-// to handle them as if they belong to some input section. So we defined
-// this class. CommonInputSection is a virtual singleton class that
-// "contains" all common symbols.
-template <class ELFT> class CommonInputSection : public InputSection<ELFT> {
-  typedef typename ELFT::uint uintX_t;
-
-public:
-  CommonInputSection(std::vector<DefinedCommon *> Syms);
-
-  // The singleton instance of this class.
-  static CommonInputSection<ELFT> *X;
-
-private:
-  static typename ELFT::Shdr Hdr;
-};
-
-template <class ELFT> CommonInputSection<ELFT> *CommonInputSection<ELFT>::X;
-template <class ELFT> typename ELFT::Shdr CommonInputSection<ELFT>::Hdr;
-
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/InputSection.cpp

 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
 
 template <class ELFT>
-static ArrayRef<uint8_t> getSectionContents(elf::ObjectFile<ELFT> *File,
-                                            const typename ELFT::Shdr *Hdr) {
+static const uint8_t *getSectionContents(elf::ObjectFile<ELFT> *File,
   if (!File || Hdr->sh_type == SHT_NOBITS)
-    return {};
-  return check(File->getObj().getSectionContents(Hdr));
+    return nullptr;
+  return check(File->getObj().getSectionContents(Hdr)).data();
 }
 
 // ELF supports ZLIB-compressed section. Returns true if the section
 // is compressed.
 template <class ELFT>
-static bool isCompressed(const typename ELFT::Shdr *Hdr, StringRef Name) {
-  return (Hdr->sh_flags & SHF_COMPRESSED) || Name.startswith(".zdebug");
+static bool isCompressed(typename ELFT::uint Flags, StringRef Name) {
+  return (Flags & SHF_COMPRESSED) || Name.startswith(".zdebug");
 }
 
 template <class ELFT>
 InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
-                                         const Elf_Shdr *Hdr, StringRef Name,
-                                         Kind SectionKind)
-    : InputSectionData(SectionKind, Name, getSectionContents(File, Hdr),
-                       isCompressed<ELFT>(Hdr, Name),
-                       !Config->GcSections || !(Hdr->sh_flags & SHF_ALLOC)),
-      Header(Hdr), File(File), Repl(this) {
+                                         uintX_t Flags, uint32_t Type,
+                                         uintX_t Entsize, uint32_t Link,
+                                         uint32_t Info, uintX_t Addralign,
+                                         const uint8_t *Data, size_t Size,
+                                         StringRef Name, Kind SectionKind)
+    : InputSectionData(SectionKind, Name, Data, Size,
+                       isCompressed<ELFT>(Flags, Name),
+                       !Config->GcSections || !(Flags & SHF_ALLOC)),
+      File(File), Flags(Flags), Entsize(Entsize), Type(Type), Link(Link),
+      Info(Info), Repl(this) {
   // The ELF spec states that a value of 0 means the section has
   // no alignment constraits.
-  uint64_t V = std::max<uint64_t>(Hdr->sh_addralign, 1);
+  uint64_t V = std::max<uint64_t>(Addralign, 1);
   if (!isPowerOf2_64(V))
     fatal(getFilename(File) + ": section sh_addralign is not a power of 2");
 
   // We reject object files having insanely large alignments even though
   // they are allowed by the spec. I think 4GB is a reasonable limitation.
   // We might want to relax this in the future.
   if (V > UINT32_MAX)
     fatal(getFilename(File) + ": section sh_addralign is too large");
   Alignment = V;
 }
 
+template <class ELFT>
+InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
+                                         const Elf_Shdr *Hdr, StringRef Name,
+                                         Kind SectionKind)
+    : InputSectionBase(File, Hdr->sh_flags, Hdr->sh_type, Hdr->sh_entsize,
+                       Hdr->sh_link, Hdr->sh_info, Hdr->sh_addralign,
+                       getSectionContents(File, Hdr), Hdr->sh_size, Name,
+                       SectionKind) {}
+
 template <class ELFT> size_t InputSectionBase<ELFT>::getSize() const {
   if (auto *D = dyn_cast<InputSection<ELFT>>(this))
     if (D->getThunksSize() > 0)
       return D->getThunkOff() + D->getThunksSize();
-  return Header->sh_size;
+  return Size;
 }
 
 // Returns a string for an error message.
 template <class SectionT> static std::string getName(SectionT *Sec) {
   return (Sec->getFile()->getName() + "(" + Sec->Name + ")").str();
 }
 
 template <class ELFT>
template <class ELFT> void InputSectionBase<ELFT>::uncompress() {
   // compressed sections have SHF_COMPRESSED bit and their contents
   // start with headers of Elf_Chdr type. However, sections whose
   // names start with ".zdebug_" don't have the bit and contains a raw
   // ZLIB-compressed data (which is a bad thing because section names
   // shouldn't be significant in ELF.) We need to be able to read both.
   ArrayRef<uint8_t> Buf; // Compressed data
   size_t Size;           // Uncompressed size
   if (getFlags() & SHF_COMPRESSED)
-    std::tie(Buf, Size) = getElfCompressedData(Data);
+    std::tie(Buf, Size) = getElfCompressedData(getData());
   else
-    std::tie(Buf, Size) = getRawCompressedData(Data);
+    std::tie(Buf, Size) = getRawCompressedData(getData());
 
   // Uncompress Buf.
   UncompressedData.reset(new uint8_t[Size]);
   if (zlib::uncompress(toStringRef(Buf), (char *)UncompressedData.get(),
                        Size) != zlib::StatusOK)
     fatal(getName(this) + ": error while uncompressing section");
-  Data = ArrayRef<uint8_t>(UncompressedData.get(), Size);
+  Data = UncompressedData.get();
+  this->Size = Size;
 }
 
 template <class ELFT>
 typename ELFT::uint
 InputSectionBase<ELFT>::getOffset(const DefinedRegular<ELFT> &Sym) const {
   return getOffset(Sym.Value);
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *InputSectionBase<ELFT>::getLinkOrderDep() const {
   if ((getFlags() & SHF_LINK_ORDER) && getLink() != 0)
     return getFile()->getSections()[getLink()];
   return nullptr;
 }
 
 template <class ELFT>
+InputSection<ELFT>::InputSection(uintX_t Flags, uint32_t Type,
+                                 uintX_t Addralign, const uint8_t *Data,
+                                 size_t Size)
+    : InputSectionBase<ELFT>(nullptr, Flags, Type,
+                             /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Addralign,
+                             Data, Size, "", Base::Regular) {}
+
+template <class ELFT>
 InputSection<ELFT>::InputSection(elf::ObjectFile<ELFT> *F,
                                  const Elf_Shdr *Header, StringRef Name)
     : InputSectionBase<ELFT>(F, Header, Name, Base::Regular) {}
 
 template <class ELFT>
 bool InputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->kind() == Base::Regular;
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *InputSection<ELFT>::getRelocatedSection() {
   assert(this->getType() == SHT_RELA || this->getType() == SHT_REL);
   ArrayRef<InputSectionBase<ELFT> *> Sections = this->File->getSections();
   return Sections[this->getInfo()];
 }
 
 template <class ELFT> void InputSection<ELFT>::addThunk(const Thunk<ELFT> *T) {
   Thunks.push_back(T);
 }
 
 template <class ELFT> uint64_t InputSection<ELFT>::getThunkOff() const {
-  return this->Header->sh_size;
+  return this->Size;
 }
 
 template <class ELFT> uint64_t InputSection<ELFT>::getThunksSize() const {
   uint64_t Total = 0;
   for (const Thunk<ELFT> *T : Thunks)
     Total += T->size();
   return Total;
 }
default:
       break;
     }
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->getType() == SHT_NOBITS)
     return;
-  ELFFile<ELFT> &EObj = this->File->getObj();
 
   // If -r is given, then an InputSection may be a relocation section.
   if (this->getType() == SHT_RELA) {
-    copyRelocations(Buf + OutSecOff, EObj.relas(this->Header));
+    copyRelocations(Buf + OutSecOff, this->template getDataAs<Elf_Rela>());
     return;
   }
   if (this->getType() == SHT_REL) {
-    copyRelocations(Buf + OutSecOff, EObj.rels(this->Header));
+    copyRelocations(Buf + OutSecOff, this->template getDataAs<Elf_Rel>());
     return;
   }
 
   // Copy section contents from source object file to output file.
-  ArrayRef<uint8_t> Data = this->Data;
+  ArrayRef<uint8_t> Data = this->getData();
   memcpy(Buf + OutSecOff, Data.data(), Data.size());
 
   // Iterate over all relocation sections that apply to this section.
   uint8_t *BufEnd = Buf + OutSecOff + Data.size();
   this->relocate(Buf, BufEnd);
 
   // The section might have a data/code generated by the linker and need
   // to be written after the section. Usually these are thunks - small piece
if (RelocSection) {
     return;
   }
   split(makeArrayRef<typename ELFT::Rela>(nullptr, nullptr));
 }
 
 template <class ELFT>
 template <class RelTy>
 void EhInputSection<ELFT>::split(ArrayRef<RelTy> Rels) {
-  ArrayRef<uint8_t> Data = this->Data;
+  ArrayRef<uint8_t> Data = this->getData();
   unsigned RelI = 0;
   for (size_t Off = 0, End = Data.size(); Off != End;) {
     size_t Size = readEhRecordSize<ELFT>(Data.slice(Off));
     this->Pieces.emplace_back(Off, Data.slice(Off, Size),
                               getReloc(Off, Size, Rels, RelI));
     // The empty record is the end marker.
     if (Size == 4)
       break;
MergeInputSection<ELFT>::splitStrings(ArrayRef<uint8_t> Data, size_t EntSize) {
   }
   return V;
 }
 
 template <class ELFT>
 ArrayRef<uint8_t> MergeInputSection<ELFT>::getData(
     std::vector<SectionPiece>::const_iterator I) const {
   auto Next = I + 1;
-  size_t End = Next == Pieces.end() ? this->Data.size() : Next->InputOff;
-  return this->Data.slice(I->InputOff, End - I->InputOff);
+  size_t End = Next == Pieces.end() ? this->Size : Next->InputOff;
+  return InputSectionData::getData().slice(I->InputOff, End - I->InputOff);
 }
 
 // Split non-SHF_STRINGS section. Such section is a sequence of
 // fixed size records.
 template <class ELFT>
 std::vector<SectionPiece>
 MergeInputSection<ELFT>::splitNonStrings(ArrayRef<uint8_t> Data,
                                          size_t EntSize) {

 
 template <class ELFT>
 MergeInputSection<ELFT>::MergeInputSection(elf::ObjectFile<ELFT> *F,
                                            const Elf_Shdr *Header,
                                            StringRef Name)
     : InputSectionBase<ELFT>(F, Header, Name, InputSectionBase<ELFT>::Merge) {}
 
 template <class ELFT> void MergeInputSection<ELFT>::splitIntoPieces() {
-  ArrayRef<uint8_t> Data = this->Data;
+  ArrayRef<uint8_t> Data = InputSectionData::getData();
   uintX_t EntSize = this->getEntsize();
   if (this->getFlags() & SHF_STRINGS)
     this->Pieces = splitStrings(Data, EntSize);
   else
     this->Pieces = splitNonStrings(Data, EntSize);
 
   if (Config->GcSections && (this->getFlags() & SHF_ALLOC))
     for (uintX_t Off : LiveOffsets)
while (Size != 1) {
     First = Comp(Value, *MI) ? First : First + H;
   }
   return Comp(Value, *First) ? First : First + 1;
 }
 
 template <class ELFT>
 const SectionPiece *
 MergeInputSection<ELFT>::getSectionPiece(uintX_t Offset) const {
-  uintX_t Size = this->Data.size();
+  uintX_t Size = this->Size;
   if (Offset >= Size)
     fatal(getName(this) + ": entry is past the end of the section");
 
   // Find the element this offset points to.
   auto I = fastUpperBound(
       Pieces.begin(), Pieces.end(), Offset,
       [](const uintX_t &A, const SectionPiece &B) { return A < B.InputOff; });
   --I;

 }
 
 template <class ELFT>
 MipsReginfoInputSection<ELFT>::MipsReginfoInputSection(elf::ObjectFile<ELFT> *F,
                                                        const Elf_Shdr *Hdr,
                                                        StringRef Name)
     : InputSectionBase<ELFT>(F, Hdr, Name,
                              InputSectionBase<ELFT>::MipsReginfo) {
-  ArrayRef<uint8_t> Data = this->Data;
+  ArrayRef<uint8_t> Data = this->getData();
   // Initialize this->Reginfo.
   if (Data.size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
     error(getName(this) + ": invalid size of .reginfo section");
     return;
   }
   Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Data.data());
   if (Config->Relocatable && Reginfo->ri_gp_value)
     error(getName(this) + ": unsupported non-zero ri_gp_value");
 }
 
 template <class ELFT>
 bool MipsReginfoInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->kind() == InputSectionBase<ELFT>::MipsReginfo;
 }
 
 template <class ELFT>
 MipsOptionsInputSection<ELFT>::MipsOptionsInputSection(elf::ObjectFile<ELFT> *F,
                                                        const Elf_Shdr *Hdr,
                                                        StringRef Name)
     : InputSectionBase<ELFT>(F, Hdr, Name,
                              InputSectionBase<ELFT>::MipsOptions) {
   // Find ODK_REGINFO option in the section's content.
-  ArrayRef<uint8_t> D = this->Data;
+  ArrayRef<uint8_t> D = this->getData();
   while (!D.empty()) {
     if (D.size() < sizeof(Elf_Mips_Options<ELFT>)) {
       error(getName(this) + ": invalid size of .MIPS.options section");
       break;
     }
     auto *O = reinterpret_cast<const Elf_Mips_Options<ELFT> *>(D.data());
     if (O->kind == ODK_REGINFO) {
       Reginfo = &O->getRegInfo();

 }
 
 template <class ELFT>
 MipsAbiFlagsInputSection<ELFT>::MipsAbiFlagsInputSection(
     elf::ObjectFile<ELFT> *F, const Elf_Shdr *Hdr, StringRef Name)
     : InputSectionBase<ELFT>(F, Hdr, Name,
                              InputSectionBase<ELFT>::MipsAbiFlags) {
   // Initialize this->Flags.
-  ArrayRef<uint8_t> Data = this->Data;
+  ArrayRef<uint8_t> Data = this->getData();
   if (Data.size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
     error("invalid size of .MIPS.abiflags section");
     return;
   }
   Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Data.data());
 }
 
 template <class ELFT>
 bool MipsAbiFlagsInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->kind() == InputSectionBase<ELFT>::MipsAbiFlags;
 }
 
 template <class ELFT>
-CommonInputSection<ELFT>::CommonInputSection(std::vector<DefinedCommon *> Syms)
-    : InputSection<ELFT>(nullptr, &Hdr, "") {
-  Hdr.sh_size = 0;
-  Hdr.sh_type = SHT_NOBITS;
-  Hdr.sh_flags = SHF_ALLOC | SHF_WRITE;
-  this->Live = true;
-
+InputSection<ELFT> InputSection<ELFT>::createCommonInputSection(
+    std::vector<DefinedCommon *> Syms) {
   // Sort the common symbols by alignment as an heuristic to pack them better.
   std::stable_sort(Syms.begin(), Syms.end(),
                    [](const DefinedCommon *A, const DefinedCommon *B) {
                      return A->Alignment > B->Alignment;
                    });
 
+  size_t Size = 0;
+  uintX_t Alignment = 1;
   for (DefinedCommon *Sym : Syms) {
-    this->Alignment = std::max<uintX_t>(this->Alignment, Sym->Alignment);
-    Hdr.sh_size = alignTo(Hdr.sh_size, Sym->Alignment);
+    Alignment = std::max<uintX_t>(Alignment, Sym->Alignment);
+    Size = alignTo(Size, Sym->Alignment);
 
     // Compute symbol offset relative to beginning of input section.
-    Sym->Offset = Hdr.sh_size;
-    Hdr.sh_size += Sym->Size;
+    Sym->Offset = Size;
+    Size += Sym->Size;
   }
+
+  InputSection Ret(SHF_ALLOC | SHF_WRITE, SHT_NOBITS, Alignment, nullptr, Size);
+  Ret.Live = true;
+  return Ret;
 }
 
 template class elf::InputSectionBase<ELF32LE>;
 template class elf::InputSectionBase<ELF32BE>;
 template class elf::InputSectionBase<ELF64LE>;
 template class elf::InputSectionBase<ELF64BE>;
 
 template class elf::InputSection<ELF32LE>;

 template class elf::MipsOptionsInputSection<ELF32BE>;
 template class elf::MipsOptionsInputSection<ELF64LE>;
 template class elf::MipsOptionsInputSection<ELF64BE>;
 
 template class elf::MipsAbiFlagsInputSection<ELF32LE>;
 template class elf::MipsAbiFlagsInputSection<ELF32BE>;
 template class elf::MipsAbiFlagsInputSection<ELF64LE>;
 template class elf::MipsAbiFlagsInputSection<ELF64BE>;
-
-template class elf::CommonInputSection<ELF32LE>;
-template class elf::CommonInputSection<ELF32BE>;
-template class elf::CommonInputSection<ELF64LE>;
-template class elf::CommonInputSection<ELF64BE>;

ELF/LinkerScript.cpp

for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
       StringRef Filename = sys::path::filename(F->getName());
       if (!I->FileRe.match(Filename) || Pat.ExcludedFileRe.match(Filename))
         continue;
 
       for (InputSectionBase<ELFT> *S : F->getSections())
         if (!isDiscarded(S) && !S->OutSec && Pat.SectionRe.match(S->Name))
           I->Sections.push_back(S);
       if (Pat.SectionRe.match("COMMON"))
-        I->Sections.push_back(CommonInputSection<ELFT>::X);
+        I->Sections.push_back(InputSection<ELFT>::CommonInputSection);
     }
 
     // Sort sections as instructed by SORT-family commands and --sort-section
     // option. Because SORT-family commands can be nested at most two depth
     // (e.g. SORT_BY_NAME(SORT_BY_ALIGNMENT(.text.*))) and because the command
     // line option is respected even if a SORT command is given, the exact
     // behavior we have here is a bit complicated. Here are the rules.
     //

ELF/MarkLive.cpp

template <class ELFT> struct ResolvedReloc {
   InputSectionBase<ELFT> *Sec;
   typename ELFT::uint Offset;
 };
 } // end anonymous namespace
 
 template <class ELFT>
 static typename ELFT::uint getAddend(InputSectionBase<ELFT> &Sec,
                                      const typename ELFT::Rel &Rel) {
-  return Target->getImplicitAddend(Sec.Data.begin() + Rel.r_offset,
+  return Target->getImplicitAddend(Sec.Data + Rel.r_offset,
                                    Rel.getType(Config->Mips64EL));
 }
 
 template <class ELFT>
 static typename ELFT::uint getAddend(InputSectionBase<ELFT> &Sec,
                                      const typename ELFT::Rela &Rel) {
   return Rel.r_addend;
 }

ELF/OutputSections.cpp

case SymbolBody::DefinedSyntheticKind:
     return cast<DefinedSynthetic<ELFT>>(Sym)->Section;
   case SymbolBody::DefinedRegularKind: {
     auto &D = cast<DefinedRegular<ELFT>>(*Sym);
     if (D.Section)
       return D.Section->OutSec;
     break;
   }
   case SymbolBody::DefinedCommonKind:
-    return CommonInputSection<ELFT>::X->OutSec;
+    return InputSection<ELFT>::CommonInputSection->OutSec;
   case SymbolBody::SharedKind:
     if (cast<SharedSymbol<ELFT>>(Sym)->needsCopy())
       return Out<ELFT>::Bss;
     break;
   case SymbolBody::UndefinedKind:
   case SymbolBody::LazyArchiveKind:
   case SymbolBody::LazyObjectKind:
     break;

ELF/Relocations.cpp

static void scanRelocs(InputSectionBase<ELFT> &C, ArrayRef<RelTy> Rels) {
 
   bool IsWrite = C.getFlags() & SHF_WRITE;
 
   auto AddDyn = [=](const DynamicReloc<ELFT> &Reloc) {
     Out<ELFT>::RelaDyn->addReloc(Reloc);
   };
 
   const elf::ObjectFile<ELFT> &File = *C.getFile();
-  ArrayRef<uint8_t> SectionData = C.Data;
+  ArrayRef<uint8_t> SectionData = C.getData();
   const uint8_t *Buf = SectionData.begin();
 
   ArrayRef<EhSectionPiece> Pieces;
   if (auto *Eh = dyn_cast<EhInputSection<ELFT>>(&C))
     Pieces = Eh->Pieces;
 
   ArrayRef<EhSectionPiece>::iterator PieceI = Pieces.begin();
   ArrayRef<EhSectionPiece>::iterator PieceE = Pieces.end();

ELF/Symbols.cpp

if (D.isTls() && !Config->Relocatable) {
       if (!Out<ELFT>::TlsPhdr)
         fatal(getFilename(D.File) +
               " has a STT_TLS symbol but doesn't have a PT_TLS section");
       return VA - Out<ELFT>::TlsPhdr->p_vaddr;
     }
     return VA;
   }
   case SymbolBody::DefinedCommonKind:
-    return CommonInputSection<ELFT>::X->OutSec->getVA() +
-           CommonInputSection<ELFT>::X->OutSecOff +
+    return InputSection<ELFT>::CommonInputSection->OutSec->getVA() +
+           InputSection<ELFT>::CommonInputSection->OutSecOff +
            cast<DefinedCommon>(Body).Offset;
   case SymbolBody::SharedKind: {
     auto &SS = cast<SharedSymbol<ELFT>>(Body);
     if (!SS.NeedsCopyOrPltAddr)
       return 0;
     if (SS.isFunc())
       return Body.getPltVA<ELFT>();
     return Out<ELFT>::Bss->getVA() + SS.OffsetInBss;

ELF/Writer.cpp

 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   addReservedSymbols();
 
   if (Target->NeedsThunks)
     forEachRelSec(createThunks<ELFT>);
 
-  CommonInputSection<ELFT> Common(getCommonSymbols<ELFT>());
-  CommonInputSection<ELFT>::X = &Common;
+  InputSection<ELFT> Common =
+      InputSection<ELFT>::createCommonInputSection(getCommonSymbols<ELFT>());
+  InputSection<ELFT>::CommonInputSection = &Common;
 
   Script<ELFT>::X->OutputSections = &OutputSections;
   if (ScriptConfig->HasSections) {
     Script<ELFT>::X->createSections(Factory);
   } else {
     createSections();
     Script<ELFT>::X->processCommands(Factory);
   }
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   }
 
   // Do not proceed if there was an undefined symbol.
   if (HasError)
     return;
 
   // If linker script processor hasn't added common symbol section yet,
   // then add it to .bss now.
-  if (!CommonInputSection<ELFT>::X->OutSec) {
-    Out<ELFT>::Bss->addSection(CommonInputSection<ELFT>::X);
+  if (!InputSection<ELFT>::CommonInputSection->OutSec) {
+    Out<ELFT>::Bss->addSection(InputSection<ELFT>::CommonInputSection);
     Out<ELFT>::Bss->assignOffsets();
   }
 
   // So far we have added sections from input object files.
   // This function adds linker-created Out<ELFT>::* sections.
   addPredefinedSections();
 
   sortSections();