Store an ArrayRef for Data in InputSectionData

[• rafael]

Summary

This is the followup to https://reviews.llvm.org/D24342

[ruiu]

ELF/InputSection.cpp

34

Can File be null?

35

return {};

[ruiu]

LGTM

[• rafael]

r281210

ELF/ICF.cpp

if (RA->sh_type == SHT_RELA) {
         return false;
     } else {
       if (!relocationEq(FileA.rels(RA), FileB.rels(RB)))
         return false;
     }
   }
 
   return A->getSectionHdr()->sh_flags == B->getSectionHdr()->sh_flags &&
-         A->getSize() == B->getSize() &&
-         A->getSectionData() == B->getSectionData();
+         A->getSize() == B->getSize() && A->Data == B->Data;
 }
 
 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, bool Compressed, bool Live)
+  InputSectionData(Kind SectionKind, StringRef Name, ArrayRef<uint8_t> Data,
+                   bool Compressed, bool Live)
       : SectionKind(SectionKind), Live(Live), Compressed(Compressed),
-        Name(Name) {}
+        Name(Name), Data(Data) {}
 
 private:
   unsigned SectionKind : 3;
 
 public:
   Kind kind() const { return (Kind)SectionKind; }
 
   // Used for garbage collection.
   unsigned Live : 1;
 
   unsigned Compressed : 1;
 
   uint32_t Alignment;
 
   StringRef Name;
 
+  ArrayRef<uint8_t> Data;
+
   // If a section is compressed, this has the uncompressed section data.
   std::unique_ptr<char[]> UncompressedData;
-  size_t UncompressedDataSize = 0;
 
   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;
 
 public:
   InputSectionBase()
-      : InputSectionData(Regular, "", false, false), Repl(this) {}
+      : InputSectionData(Regular, "", ArrayRef<uint8_t>(), false, false),
+        Repl(this) {}
 
   InputSectionBase(ObjectFile<ELFT> *File, const Elf_Shdr *Header,
                    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,
public:
   const Elf_Shdr *getSectionHdr() const { return Header; }
   ObjectFile<ELFT> *getFile() const { return File; }
   uintX_t getOffset(const DefinedRegular<ELFT> &Sym) const;
 
   // Translate an offset in the input section to an offset in the output
   // section.
   uintX_t getOffset(uintX_t Offset) const;
 
-  ArrayRef<uint8_t> getSectionData() const;
-
   void uncompress();
 
   void relocate(uint8_t *Buf, uint8_t *BufEnd);
 };
 
 template <class ELFT> InputSectionBase<ELFT> InputSectionBase<ELFT>::Discarded;
 
 // SectionPiece represents a piece of splittable section contents.

ELF/InputSection.cpp

 using namespace llvm::ELF;
 using namespace llvm::object;
 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) {
+  if (!File || Hdr->sh_type == SHT_NOBITS)
+    return {};
+  return check(File->getObj().getSectionContents(Hdr));
+}
+
+template <class ELFT>
 InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
                                          const Elf_Shdr *Hdr, StringRef Name,
                                          Kind SectionKind)
-    : InputSectionData(SectionKind, Name, Hdr->sh_flags & SHF_COMPRESSED,
-                       !Config->GcSections),
+    : InputSectionData(SectionKind, Name, getSectionContents(File, Hdr),
+                       Hdr->sh_flags & SHF_COMPRESSED, !Config->GcSections),
       Header(Hdr), File(File), Repl(this) {
   // The ELF spec states that a value of 0 means the section has
   // no alignment constraits.
   Alignment = std::max<uintX_t>(Header->sh_addralign, 1);
 }
 
 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;
 }
 
-template <class ELFT>
-ArrayRef<uint8_t> InputSectionBase<ELFT>::getSectionData() const {
-  if (Compressed)
-    return ArrayRef<uint8_t>((const uint8_t *)UncompressedData.get(),
-                             UncompressedDataSize);
-  return check(this->File->getObj().getSectionContents(this->Header));
-}
-
 // 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>
 typename ELFT::uint InputSectionBase<ELFT>::getOffset(uintX_t Offset) const {
   switch (kind()) {

 
 template <class ELFT> void InputSectionBase<ELFT>::uncompress() {
   if (!zlib::isAvailable())
     fatal(getName(this) +
           ": build lld with zlib to enable compressed sections support");
 
   // A compressed section consists of a header of Elf_Chdr type
   // followed by compressed data.
-  ArrayRef<uint8_t> Data =
-      check(this->File->getObj().getSectionContents(this->Header));
   if (Data.size() < sizeof(Elf_Chdr))
     fatal("corrupt compressed section");
 
   auto *Hdr = reinterpret_cast<const Elf_Chdr *>(Data.data());
   Data = Data.slice(sizeof(Elf_Chdr));
 
   if (Hdr->ch_type != ELFCOMPRESS_ZLIB)
     fatal(getName(this) + ": unsupported compression type");
 
   StringRef Buf((const char *)Data.data(), Data.size());
-  UncompressedDataSize = Hdr->ch_size;
+  size_t UncompressedDataSize = Hdr->ch_size;
   UncompressedData.reset(new char[UncompressedDataSize]);
   if (zlib::uncompress(Buf, UncompressedData.get(), UncompressedDataSize) !=
       zlib::StatusOK)
     fatal(getName(this) + ": error uncompressing section");
+  Data = ArrayRef<uint8_t>((uint8_t *)UncompressedData.get(),
+                           UncompressedDataSize);
 }
 
 template <class ELFT>
 typename ELFT::uint
 InputSectionBase<ELFT>::getOffset(const DefinedRegular<ELFT> &Sym) const {
   return getOffset(Sym.Value);
 }
 
if (this->Header->sh_type == SHT_RELA) {
     return;
   }
   if (this->Header->sh_type == SHT_REL) {
     copyRelocations(Buf + OutSecOff, EObj.rels(this->Header));
     return;
   }
 
   // Copy section contents from source object file to output file.
-  ArrayRef<uint8_t> Data = this->getSectionData();
+  ArrayRef<uint8_t> Data = this->Data;
   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->getSectionData();
+  ArrayRef<uint8_t> Data = this->Data;
   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;

 
 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->getSectionData();
+  ArrayRef<uint8_t> Data = this->Data;
   uintX_t EntSize = this->Header->sh_entsize;
   if (this->Header->sh_flags & SHF_STRINGS)
     this->Pieces = splitStrings(Data, EntSize);
   else
     this->Pieces = splitNonStrings(Data, EntSize);
 
   if (Config->GcSections)
     for (uintX_t Off : LiveOffsets)

 SectionPiece *MergeInputSection<ELFT>::getSectionPiece(uintX_t Offset) {
   auto *This = static_cast<const MergeInputSection<ELFT> *>(this);
   return const_cast<SectionPiece *>(This->getSectionPiece(Offset));
 }
 
 template <class ELFT>
 const SectionPiece *
 MergeInputSection<ELFT>::getSectionPiece(uintX_t Offset) const {
-  ArrayRef<uint8_t> D = this->getSectionData();
-  StringRef Data((const char *)D.data(), D.size());
-  uintX_t Size = Data.size();
+  uintX_t Size = this->Data.size();
   if (Offset >= Size)
     fatal(getName(this) + ": entry is past the end of the section");
 
   // Find the element this offset points to.
   auto I = std::upper_bound(
       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;
   // Initialize this->Reginfo.
-  ArrayRef<uint8_t> D = this->getSectionData();
-  if (D.size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
+  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> *>(D.data());
+  Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Data.data());
 }
 
 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->getSectionData();
+  ArrayRef<uint8_t> D = this->Data;
   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> D = this->getSectionData();
-  if (D.size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
+  ArrayRef<uint8_t> Data = this->Data;
+  if (Data.size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
     error("invalid size of .MIPS.abiflags section");
     return;
   }
-  Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(D.data());
+  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>

ELF/MarkLive.cpp

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.getSectionData().begin(),
+  return Target->getImplicitAddend(Sec.Data.begin(),
                                    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/Relocations.cpp

static void scanRelocs(InputSectionBase<ELFT> &C, ArrayRef<RelTy> Rels) {
 
   bool IsWrite = C.getSectionHdr()->sh_flags & 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.getSectionData();
+  ArrayRef<uint8_t> SectionData = C.Data;
   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();