Compact EhSectionPiece from 32 bytes to 16 bytes.

[ruiu]

Summary

EhSectionPiece used to have a pointer to a section, but that pointer was
mostly redundant because we almost always know what the section is without
using that pointer. This patch removes the pointer from the struct.

This patch also use uint32_t/int32_t instead of size_t to represent
offsets that are hardly be larger than 4 GiB. At the moment, I think it is
OK even if we cannot handle .eh_frame sections larger than 4 GiB.

[ruiu]

Ping

[ruiu]

• Do not rename varaibles in this patch
• Rebase

[chapuni]

Reverted in rL313731.

See also;

• http://lab.llvm.org:8011/builders/clang-with-lto-ubuntu/builds/4896
• http://bb.pgr.jp/builders/bootstrap-clang-libcxx-lld-i686-linux/builds/194

Excuse me, I cannot reproduce it in my private tree.

lld/ELF/EhFrame.h

 //===- EhFrame.h ------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_EHFRAME_H
 #define LLD_ELF_EHFRAME_H
 
 #include "lld/Core/LLVM.h"
 
 namespace lld {
 namespace elf {
+class EhInputSection;
 class InputSectionBase;
 struct EhSectionPiece;
 
 template <class ELFT> size_t readEhRecordSize(InputSectionBase *S, size_t Off);
-template <class ELFT> uint8_t getFdeEncoding(EhSectionPiece *P);
+template <class ELFT>
+uint8_t getFdeEncoding(EhInputSection *, EhSectionPiece *);
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/EhFrame.cpp

template <class ELFT> void EhReader<ELFT>::skipAugP() {
   size_t Size = getAugPSize(Enc);
   if (Size == 0)
     failOn(D.data() - 1, "unknown FDE encoding");
   if (Size >= D.size())
     failOn(D.data() - 1, "corrupted CIE");
   D = D.slice(Size);
 }
 
-template <class ELFT> uint8_t elf::getFdeEncoding(EhSectionPiece *P) {
-  return EhReader<ELFT>(P->Sec, P->data()).getFdeEncoding();
+template <class ELFT>
+uint8_t elf::getFdeEncoding(EhInputSection *Sec, EhSectionPiece *Piece) {
+  return EhReader<ELFT>(Sec, Piece->data(Sec)).getFdeEncoding();
 }
 
 template <class ELFT> uint8_t EhReader<ELFT>::getFdeEncoding() {
   skipBytes(8);
   int Version = readByte();
   if (Version != 1 && Version != 3)
     failOn(D.data() - 1,
            "FDE version 1 or 3 expected, but got " + Twine(Version));
template <class ELFT> uint8_t EhReader<ELFT>::getFdeEncoding() {
   return DW_EH_PE_absptr;
 }
 
 template size_t elf::readEhRecordSize<ELF32LE>(InputSectionBase *S, size_t Off);
 template size_t elf::readEhRecordSize<ELF32BE>(InputSectionBase *S, size_t Off);
 template size_t elf::readEhRecordSize<ELF64LE>(InputSectionBase *S, size_t Off);
 template size_t elf::readEhRecordSize<ELF64BE>(InputSectionBase *S, size_t Off);
 
-template uint8_t elf::getFdeEncoding<ELF32LE>(EhSectionPiece *P);
-template uint8_t elf::getFdeEncoding<ELF32BE>(EhSectionPiece *P);
-template uint8_t elf::getFdeEncoding<ELF64LE>(EhSectionPiece *P);
-template uint8_t elf::getFdeEncoding<ELF64BE>(EhSectionPiece *P);
+template uint8_t elf::getFdeEncoding<ELF32LE>(EhInputSection *,
+                                              EhSectionPiece *);
+template uint8_t elf::getFdeEncoding<ELF32BE>(EhInputSection *,
+                                              EhSectionPiece *);
+template uint8_t elf::getFdeEncoding<ELF64LE>(EhInputSection *,
+                                              EhSectionPiece *);
+template uint8_t elf::getFdeEncoding<ELF64BE>(EhInputSection *,
+                                              EhSectionPiece *);

lld/ELF/InputSection.h

 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Threading.h"
 #include <mutex>
 
 namespace lld {
 namespace elf {
 
 class DefinedCommon;
+class EhInputSection;
 class SymbolBody;
 struct SectionPiece;
 
 class DefinedRegular;
 class SyntheticSection;
 template <class ELFT> class EhFrameSection;
 class MergeSyntheticSection;
 template <class ELFT> class ObjFile;
private:
 
   mutable llvm::DenseMap<uint64_t, uint64_t> OffsetMap;
   mutable llvm::once_flag InitOffsetMap;
 
   llvm::DenseSet<uint64_t> LiveOffsets;
 };
 
 struct EhSectionPiece {
-  EhSectionPiece(size_t Off, InputSectionBase *Sec, uint32_t Size,
-                 unsigned FirstRelocation)
-      : InputOff(Off), Sec(Sec), Size(Size), FirstRelocation(FirstRelocation) {}
-
-  ArrayRef<uint8_t> data() { return {Sec->Data.data() + this->InputOff, Size}; }
+  EhSectionPiece(size_t Off, uint32_t Size, unsigned FirstRelocation)
+      : InputOff(Off), Size(Size), FirstRelocation(FirstRelocation) {
+    assert(Off < UINT32_MAX && Size < UINT32_MAX);
+  }
 
-  size_t InputOff;
-  ssize_t OutputOff = -1;
-  InputSectionBase *Sec;
+  ArrayRef<uint8_t> data(EhInputSection *Sec);
+  uint32_t InputOff;
+  int32_t OutputOff = -1;
   uint32_t Size;
-  unsigned FirstRelocation;
+  uint32_t FirstRelocation;
 };
 
 // This corresponds to a .eh_frame section of an input file.
 class EhInputSection : public InputSectionBase {
 public:
   template <class ELFT>
   EhInputSection(ObjFile<ELFT> *F, const typename ELFT::Shdr *Header,
                  StringRef Name);
   static bool classof(const SectionBase *S);
   template <class ELFT> void split();
   template <class ELFT, class RelTy> void split(ArrayRef<RelTy> Rels);
 
   // Splittable sections are handled as a sequence of data
   // rather than a single large blob of data.
   std::vector<EhSectionPiece> Pieces;
 
   SyntheticSection *getParent() const;
 };
 
+inline ArrayRef<uint8_t> EhSectionPiece::data(EhInputSection *Sec) {
+  return {Sec->Data.data() + InputOff, Size};
+}
+
 // This is a section that is added directly to an output section
 // instead of needing special combination via a synthetic section. This
 // includes all input sections with the exceptions of SHF_MERGE and
 // .eh_frame. It also includes the synthetic sections themselves.
 class InputSection : public InputSectionBase {
 public:
   InputSection(uint64_t Flags, uint32_t Type, uint32_t Alignment,
                ArrayRef<uint8_t> Data, StringRef Name, Kind K = Regular);

lld/ELF/InputSection.cpp

 }
 
 template <class ELFT, class RelTy>
 void EhInputSection::split(ArrayRef<RelTy> Rels) {
   ArrayRef<uint8_t> Data = this->Data;
   unsigned RelI = 0;
   for (size_t Off = 0, End = Data.size(); Off != End;) {
     size_t Size = readEhRecordSize<ELFT>(this, Off);
-    this->Pieces.emplace_back(Off, this, Size, getReloc(Off, Size, Rels, RelI));
+    this->Pieces.emplace_back(Off, Size, getReloc(Off, Size, Rels, RelI));
     // The empty record is the end marker.
     if (Size == 4)
       break;
     Off += Size;
   }
 }
 
 static size_t findNull(ArrayRef<uint8_t> A, size_t EntSize) {

lld/ELF/MarkLive.cpp

scanEhFrameSection(EhInputSection &EH, ArrayRef<RelTy> Rels,
                    std::function<void(InputSectionBase *, uint64_t)> Fn) {
   const endianness E = ELFT::TargetEndianness;
 
   for (unsigned I = 0, N = EH.Pieces.size(); I < N; ++I) {
     EhSectionPiece &Piece = EH.Pieces[I];
     unsigned FirstRelI = Piece.FirstRelocation;
     if (FirstRelI == (unsigned)-1)
       continue;
-    if (read32<E>(Piece.data().data() + 4) == 0) {
+    if (read32<E>(Piece.data(&EH).data() + 4) == 0) {
       // This is a CIE, we only need to worry about the first relocation. It is
       // known to point to the personality function.
       resolveReloc<ELFT>(EH, Rels[FirstRelI], Fn);
       continue;
     }
     // This is a FDE. The relocations point to the described function or to
     // a LSDA. We only need to keep the LSDA alive, so ignore anything that
     // points to executable sections.

lld/ELF/SyntheticSections.h

public:
   uint64_t getVA() const;
 
   static bool classof(const SectionBase *D) {
     return D->kind() == InputSectionBase::Synthetic;
   }
 };
 
 struct CieRecord {
+  EhInputSection *Sec = nullptr;
   EhSectionPiece *Cie = nullptr;
   std::vector<EhSectionPiece *> Fdes;
 };
 
 // Section for .eh_frame.
 template <class ELFT> class EhFrameSection final : public SyntheticSection {
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Rel Elf_Rel;
public:
   std::vector<EhInputSection *> Sections;
 
 private:
   uint64_t Size = 0;
   template <class RelTy>
   void addSectionAux(EhInputSection *S, llvm::ArrayRef<RelTy> Rels);
 
   template <class RelTy>
-  CieRecord *addCie(EhSectionPiece &Piece, ArrayRef<RelTy> Rels);
+  CieRecord *addCie(EhInputSection *Sec, EhSectionPiece &Piece,
+                    ArrayRef<RelTy> Rels);
 
   template <class RelTy>
-  bool isFdeLive(EhSectionPiece &Piece, ArrayRef<RelTy> Rels);
+  bool isFdeLive(EhInputSection *Sec, EhSectionPiece &Piece,
+                 ArrayRef<RelTy> Rels);
 
   uint64_t getFdePc(uint8_t *Buf, size_t Off, uint8_t Enc);
 
   std::vector<CieRecord *> CieRecords;
 
   // CIE records are uniquified by their contents and personality functions.
   llvm::DenseMap<std::pair<ArrayRef<uint8_t>, SymbolBody *>, CieRecord> CieMap;
 };

lld/ELF/SyntheticSections.cpp

 EhFrameSection<ELFT>::EhFrameSection()
     : SyntheticSection(SHF_ALLOC, SHT_PROGBITS, 1, ".eh_frame") {}
 
 // Search for an existing CIE record or create a new one.
 // CIE records from input object files are uniquified by their contents
 // and where their relocations point to.
 template <class ELFT>
 template <class RelTy>
-CieRecord *EhFrameSection<ELFT>::addCie(EhSectionPiece &Cie,
+CieRecord *EhFrameSection<ELFT>::addCie(EhInputSection *Sec,
+                                        EhSectionPiece &Cie,
                                         ArrayRef<RelTy> Rels) {
-  auto *Sec = cast<EhInputSection>(Cie.Sec);
   const endianness E = ELFT::TargetEndianness;
-  if (read32<E>(Cie.data().data() + 4) != 0)
+  if (read32<E>(Cie.data(Sec).data() + 4) != 0)
     fatal(toString(Sec) + ": CIE expected at beginning of .eh_frame");
 
   SymbolBody *Personality = nullptr;
   unsigned FirstRelI = Cie.FirstRelocation;
   if (FirstRelI != (unsigned)-1)
     Personality =
         &Sec->template getFile<ELFT>()->getRelocTargetSym(Rels[FirstRelI]);
 
   // Search for an existing CIE by CIE contents/relocation target pair.
-  CieRecord *Rec = &CieMap[{Cie.data(), Personality}];
+  CieRecord *Rec = &CieMap[{Cie.data(Sec), Personality}];
 
   // If not found, create a new one.
-  if (Rec->Cie == nullptr) {
+  if (Rec->Sec == nullptr) {
+    Rec->Sec = Sec;
     Rec->Cie = &Cie;
     CieRecords.push_back(Rec);
   }
   return Rec;
 }
 
 // There is one FDE per function. Returns true if a given FDE
 // points to a live function.
 template <class ELFT>
 template <class RelTy>
-bool EhFrameSection<ELFT>::isFdeLive(EhSectionPiece &Fde,
+bool EhFrameSection<ELFT>::isFdeLive(EhInputSection *Sec, EhSectionPiece &Fde,
                                      ArrayRef<RelTy> Rels) {
-  auto *Sec = cast<EhInputSection>(Fde.Sec);
   unsigned FirstRelI = Fde.FirstRelocation;
 
   // An FDE should point to some function because FDEs are to describe
   // functions. That's however not always the case due to an issue of
   // ld.gold with -r. ld.gold may discard only functions and leave their
   // corresponding FDEs, which results in creating bad .eh_frame sections.
   // To deal with that, we ignore such FDEs.
   if (FirstRelI == (unsigned)-1)
void EhFrameSection<ELFT>::addSectionAux(EhInputSection *Sec,
 
   DenseMap<size_t, CieRecord *> OffsetToCie;
   for (EhSectionPiece &Piece : Sec->Pieces) {
     // The empty record is the end marker.
     if (Piece.Size == 4)
       return;
 
     size_t Offset = Piece.InputOff;
-    uint32_t ID = read32<E>(Piece.data().data() + 4);
+    uint32_t ID = read32<E>(Piece.data(Sec).data() + 4);
     if (ID == 0) {
-      OffsetToCie[Offset] = addCie(Piece, Rels);
+      OffsetToCie[Offset] = addCie(Sec, Piece, Rels);
       continue;
     }
 
     uint32_t CieOffset = Offset + 4 - ID;
     CieRecord *Rec = OffsetToCie[CieOffset];
     if (!Rec)
       fatal(toString(Sec) + ": invalid CIE reference");
 
-    if (!isFdeLive(Piece, Rels))
+    if (!isFdeLive(Sec, Piece, Rels))
       continue;
     Rec->Fdes.push_back(&Piece);
     NumFdes++;
   }
 }
 
 template <class ELFT>
 void EhFrameSection<ELFT>::addSection(InputSectionBase *C) {
if ((Enc & 0x70) == DW_EH_PE_pcrel)
     return Addr + getParent()->Addr + Off;
   fatal("unknown FDE size relative encoding");
 }
 
 template <class ELFT> void EhFrameSection<ELFT>::writeTo(uint8_t *Buf) {
   const endianness E = ELFT::TargetEndianness;
   for (CieRecord *Rec : CieRecords) {
     size_t CieOffset = Rec->Cie->OutputOff;
-    writeCieFde<ELFT>(Buf + CieOffset, Rec->Cie->data());
+    writeCieFde<ELFT>(Buf + CieOffset, Rec->Cie->data(Rec->Sec));
 
     for (EhSectionPiece *Fde : Rec->Fdes) {
       size_t Off = Fde->OutputOff;
-      writeCieFde<ELFT>(Buf + Off, Fde->data());
+      writeCieFde<ELFT>(Buf + Off, Fde->data(Rec->Sec));
 
       // FDE's second word should have the offset to an associated CIE.
       // Write it.
       write32<E>(Buf + Off + 4, Off + 4 - CieOffset);
     }
   }
 
   for (EhInputSection *S : Sections)
     S->relocateAlloc(Buf, nullptr);
 
   // Construct .eh_frame_hdr. .eh_frame_hdr is a binary search table
   // to get a FDE from an address to which FDE is applied. So here
   // we obtain two addresses and pass them to EhFrameHdr object.
   if (In<ELFT>::EhFrameHdr) {
     for (CieRecord *Rec : CieRecords) {
-      uint8_t Enc = getFdeEncoding<ELFT>(Rec->Cie);
+      uint8_t Enc = getFdeEncoding<ELFT>(Rec->Sec, Rec->Cie);
       for (EhSectionPiece *Fde : Rec->Fdes) {
         uint64_t Pc = getFdePc(Buf, Fde->OutputOff, Enc);
         uint64_t FdeVA = getParent()->Addr + Fde->OutputOff;
         In<ELFT>::EhFrameHdr->addFde(Pc, FdeVA);
       }
     }
   }
 }