[ELF] - Attempt to simplify the relocations relaxation code

[grimar]

Summary

This patch introduces the next changes:

1. During Writer<ELFT>::scanRelocs() marks and remembers for each relocation if it can be optimized(relaxed) or not.
2. In following code remembered values are used. (RelocationSection<ELFT>::writeTo() is not covered yet, it is possible to make it use remembered values also, If this patch will be ok, I`ll do that).
3. InputSectionBase<ELFT>::relocate() is split to relocateNotOptimized and relocateOptimized. So relaxations are handled separately what also simplified the code.

All above allowed to significantly reduce amount excessive isTlsOptimized calls (after fixing p2 which has one, the only places will be in Target class, what is fine and expected I believe).
I introduced

struct RelocData {
   bool Optimized = false;
 };

struct for each relocation data, but It looks single boolean is enough now and I can replace the struct with single bool. Not sure will we need to remember any other data for relocations ?

[ruiu]

ELF/InputSection.h

85–87

Why do you need a struct that has only one member?

91

Is this a bitmap where each bit at position n represents whether or not n'th relocation in Sec needs a TLS optimization? If so, I doesn't feel like a clean design. Having side data is somewhat confusing. I'm sorry that I don't have a counter suggestion here, but it feels like this change is somewhat neutral from the readability point of view.

ELF/Writer.cpp

243–245

Please keep this code here. If you can eliminate data early in a process, do early there rather than later.

[grimar]

I will wait to see better solution. I am sure it exist.

ELF/InputSection.h

85–87

Please read patch notes, I am not sure will we need any additional data or not. So it is easy to replace it with single bool.

[grimar]

ELF/InputSection.h

91

Yes it was such a bitmap. In current situation it helps to avoid multiple isTlsOptimized calls what IMO makes situation better overall.
I dont like idea to keep additional data but I also dont feel it very bad. We also can probably add more fields there to calculate it only one time during first scan, like needsGot flag for example.
So I abandoned it for now but if there is something I can do with it to land it please let me know.

[• rafael]

So, I like the general idea of saving info during reloc scan that is
then used for reloc application and/or writing dynamic relocations. It
is a bit similar to what I did for .dynamic.

I do have the same concerns as Rui for the current patch. Out of
curiosity, have you tried going all the way and just storing *all* the
information needed to perform a relocation?

Cheers,
Rafael

[grimar]

In D16468#336607, @rafael wrote:

So, I like the general idea of saving info during reloc scan that is
then used for reloc application and/or writing dynamic relocations. It
is a bit similar to what I did for .dynamic.

I do have the same concerns as Rui for the current patch. Out of
curiosity, have you tried going all the way and just storing *all* the
information needed to perform a relocation?

Cheers,
Rafael

No, I didn't try to store anything except "Optimized" field yet. To do that it would probably better to perform additional pass/write separate function to get all information in one special place. It sounds as a change to current design and I think at first we should decide do we find the idea to store such amount of additional data acceptable or not.
Personally I would be happy to resurrect this patch and try to do that.

ELF/InputFiles.cpp

case SHT_REL: {
       uint32_t RelocatedSectionIndex = Sec.sh_info;
       if (RelocatedSectionIndex >= Size)
         error("Invalid relocated section index");
       InputSectionBase<ELFT> *RelocatedSection =
           Sections[RelocatedSectionIndex];
       if (!RelocatedSection)
         error("Unsupported relocation reference");
       if (auto *S = dyn_cast<InputSection<ELFT>>(RelocatedSection)) {
-        S->RelocSections.push_back(&Sec);
+        S->RelocSections.emplace_back(InputSection<ELFT>::RelocSec(S, &Sec));
       } else if (auto *S = dyn_cast<EHInputSection<ELFT>>(RelocatedSection)) {
         if (S->RelocSection)
           error("Multiple relocation sections to .eh_frame are not supported");
-        S->RelocSection = &Sec;
+        S->RelocSection.reset(new InputSection<ELFT>::RelocSec(S, &Sec));
       } else {
         error("Relocations pointing to SHF_MERGE are not supported");
       }
       break;
     }
     default:
       Sections[I] = createInputSection(Sec);
     }

ELF/InputSection.h

 //===- InputSection.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_INPUT_SECTION_H
 #define LLD_ELF_INPUT_SECTION_H
 
 #include "Config.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/Object/ELF.h"
 
+#include <list>
+#include <vector>
+
 namespace lld {
 namespace elf2 {
 
 template <class ELFT> class ObjectFile;
 template <class ELFT> class OutputSection;
 template <class ELFT> class OutputSectionBase;
 
 // This corresponds to a section of an input file.
public:
   // Returns a section that Rel is pointing to. Used by the garbage collector.
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Rel &Rel);
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Rela &Rel);
 
   template <bool isRela>
   using RelIteratorRange =
       llvm::iterator_range<const llvm::object::Elf_Rel_Impl<ELFT, isRela> *>;
 
+  struct RelocData {
+    bool Optimized = false;
+  };
+  struct RelocSec {
+    RelocSec(InputSectionBase<ELFT> *B, const Elf_Shdr *Sec);
+    const Elf_Shdr *Sec = nullptr;
+    std::vector<RelocData> Relocs;
+  };
+
   template <bool isRela>
-  void relocate(uint8_t *Buf, uint8_t *BufEnd, RelIteratorRange<isRela> Rels);
+  void relocate(uint8_t *Buf, uint8_t *BufEnd, RelIteratorRange<isRela> Rels,
+                const RelocSec &Sec);
 
 private:
   template <bool isRela>
+  void relocateNotOptimized(uint8_t *Buf, uint8_t *BufEnd,
+                            RelIteratorRange<isRela> Rels, const RelocSec &Sec);
+
+  template <bool isRela>
+  void relocateOptimized(uint8_t *Buf, uint8_t *BufEnd,
+                         RelIteratorRange<isRela> Rels, const RelocSec &Sec);
+
+  template <bool isRela>
   uint8_t *findMipsPairedReloc(uint8_t *Buf, uint32_t SymIndex, uint32_t Type,
                                RelIteratorRange<isRela> Rels);
 };
 
 template <class ELFT>
 InputSectionBase<ELFT>
     InputSectionBase<ELFT>::Discarded(nullptr, nullptr,
                                       InputSectionBase<ELFT>::Regular);
public:
   EHInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
   static bool classof(const InputSectionBase<ELFT> *S);
 
   // Translate an offset in the input section to an offset in the output
   // section.
   uintX_t getOffset(uintX_t Offset);
 
   // Relocation section that refer to this one.
-  const Elf_Shdr *RelocSection = nullptr;
+  std::unique_ptr<RelocSec> RelocSection;
 };
 
 // This corresponds to a non SHF_MERGE section of an input file.
 template <class ELFT> class InputSection : public InputSectionBase<ELFT> {
   typedef InputSectionBase<ELFT> Base;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
 public:
   InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
 
   // 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.
-  SmallVector<const Elf_Shdr *, 1> RelocSections;
-
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutSecOff = 0;
 
   static bool classof(const InputSectionBase<ELFT> *S);
+
+  // Relocation sections that refer to this one.
+  std::list<RelocSec> RelocSections;
 };
 
 // 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

ELF/InputSection.cpp

 
 template <class ELFT>
 InputSectionBase<ELFT> *
 InputSectionBase<ELFT>::getRelocTarget(const Elf_Rela &Rel) {
   return getRelocTarget(reinterpret_cast<const Elf_Rel &>(Rel));
 }
 
 template <class ELFT>
+InputSectionBase<ELFT>::RelocSec::RelocSec(InputSectionBase<ELFT> *B,
+                                           const Elf_Shdr *Sec)
+    : Sec(Sec) {
+  ELFFile<ELFT> &EObj = B->File->getObj();
+  if (Sec->sh_type == SHT_RELA) {
+    RelIteratorRange<true> Rels = EObj.relas(Sec);
+    Relocs.resize(Rels.end() - Rels.begin());
+  } else {
+    RelIteratorRange<false> Rels = EObj.rels(Sec);
+    Relocs.resize(Rels.end() - Rels.begin());
+  }
+}
+
+template <class ELFT>
 InputSection<ELFT>::InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header)
     : InputSectionBase<ELFT>(F, Header, Base::Regular) {}
 
 template <class ELFT>
 bool InputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->SectionKind == Base::Regular;
 }
 

 getSymSize(SymbolBody &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) {
+void InputSectionBase<ELFT>::relocateNotOptimized(uint8_t *Buf, uint8_t *BufEnd,
+                                                  RelIteratorRange<isRela> Rels,
+                                                  const RelocSec &Sec) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   size_t Num = Rels.end() - Rels.begin();
   for (size_t I = 0; I < Num; ++I) {
     const RelType &RI = *(Rels.begin() + I);
-    uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
-    uint32_t Type = RI.getType(Config->Mips64EL);
+    const RelocData &RelData = *(Sec.Relocs.begin() + I);
     uintX_t Offset = getOffset(RI.r_offset);
-    if (Offset == (uintX_t)-1)
+    if (Offset == (uintX_t)-1 || RelData.Optimized)
       continue;
 
+    uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
+    uint32_t Type = RI.getType(Config->Mips64EL);
     uint8_t *BufLoc = Buf + Offset;
     uintX_t AddrLoc = OutSec->getVA() + Offset;
     auto NextRelocs = llvm::make_range(&RI, Rels.end());
 
-    if (Target->isTlsLocalDynamicReloc(Type) &&
-        !Target->isTlsOptimized(Type, nullptr)) {
+    if (Target->isTlsLocalDynamicReloc(Type)) {
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getLocalTlsIndexVA() +
                               getAddend<ELFT>(RI));
       continue;
     }
 
     const Elf_Shdr *SymTab = File->getSymbolTable();
     SymbolBody *Body = nullptr;
     if (SymIndex >= SymTab->sh_info)
       Body = File->getSymbolBody(SymIndex)->repl();
 
-    if (Target->isTlsOptimized(Type, Body)) {
-      uintX_t SymVA;
-      if (!Body)
-        SymVA = getLocalRelTarget(*File, RI, 0);
-      else if (Target->relocNeedsGot(Type, *Body))
-        SymVA = Out<ELFT>::Got->getEntryAddr(*Body);
-      else
-        SymVA = getSymVA<ELFT>(*Body);
-      // By optimizing TLS relocations, it is sometimes needed to skip
-      // relocations that immediately follow TLS relocations. This function
-      // knows how many slots we need to skip.
-      I += Target->relocateTlsOptimize(BufLoc, BufEnd, Type, AddrLoc, SymVA,
-                                       *Body);
-      continue;
-    }
-
     // Handle relocations for local symbols -- they never get
     // resolved so we don't allocate a SymbolBody.
     uintX_t A = getAddend<ELFT>(RI);
     if (!Body) {
       uintX_t SymVA = getLocalRelTarget(*File, RI, A);
       if (Config->EMachine == EM_MIPS) {
         if (Type == R_MIPS_GPREL16 || Type == R_MIPS_GPREL32)
           // We need to adjust SymVA value in case of R_MIPS_GPREL16/32
           // relocations because they use the following expression to calculate
           // the relocation's result for local symbol: S + A + GP0 - G.
           SymVA += File->getMipsGp0();
         else if (Type == R_MIPS_GOT16)
           // R_MIPS_GOT16 relocation against local symbol requires index of
           // a local GOT entry which contains page address corresponds
           // to the symbol address.
           SymVA = Out<ELFT>::Got->getMipsLocalPageAddr(SymVA);
       }
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA, 0,
                           findMipsPairedReloc(Buf, SymIndex, Type, NextRelocs));
       continue;
     }
 
-    if (Target->isTlsGlobalDynamicReloc(Type) &&
-        !Target->isTlsOptimized(Type, Body)) {
+    if (Target->isTlsGlobalDynamicReloc(Type)) {
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getGlobalDynAddr(*Body) +
                               getAddend<ELFT>(RI));
       continue;
     }
 
     uintX_t SymVA = getSymVA<ELFT>(*Body);
     if (Target->relocNeedsPlt(Type, *Body)) {
if (Target->relocNeedsPlt(Type, *Body)) {
         SymVA = getMipsGpAddr<ELFT>() - AddrLoc + 4;
     }
     uintX_t Size = getSymSize<ELFT>(*Body);
     Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA + A, Size + A,
                         findMipsPairedReloc(Buf, SymIndex, Type, NextRelocs));
   }
 }
 
+template <class ELFT>
+template <bool isRela>
+void InputSectionBase<ELFT>::relocateOptimized(uint8_t *Buf, uint8_t *BufEnd,
+                                               RelIteratorRange<isRela> Rels,
+                                               const RelocSec &Sec) {
+  typedef Elf_Rel_Impl<ELFT, isRela> RelType;
+  size_t Num = Rels.end() - Rels.begin();
+  for (size_t I = 0; I < Num; ++I) {
+    const RelType &RI = *(Rels.begin() + I);
+    const RelocData &RelData = *(Sec.Relocs.begin() + I);
+    uintX_t Offset = getOffset(RI.r_offset);
+    if (Offset == (uintX_t)-1 || !RelData.Optimized)
+      continue;
+    uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
+    uint32_t Type = RI.getType(Config->Mips64EL);
+    const Elf_Shdr *SymTab = File->getSymbolTable();
+
+    SymbolBody *Body = nullptr;
+    if (SymIndex >= SymTab->sh_info)
+      Body = File->getSymbolBody(SymIndex)->repl();
+
+    uintX_t SymVA;
+    if (!Body)
+      SymVA = getLocalRelTarget(*File, RI, 0);
+    else if (Target->relocNeedsGot(Type, *Body))
+      SymVA = Out<ELFT>::Got->getEntryAddr(*Body);
+    else
+      SymVA = getSymVA<ELFT>(*Body);
+    // By optimizing TLS relocations, it is sometimes needed to skip
+    // relocations that immediately follow TLS relocations. This function
+    // knows how many slots we need to skip.
+    I += Target->relocateTlsOptimize(Buf + Offset, BufEnd, Type,
+                                     OutSec->getVA() + Offset, SymVA, *Body);
+  }
+}
+
+template <class ELFT>
+template <bool isRela>
+void InputSectionBase<ELFT>::relocate(uint8_t *Buf, uint8_t *BufEnd,
+                                      RelIteratorRange<isRela> Rels,
+                                      const RelocSec &Sec) {
+  relocateNotOptimized(Buf, BufEnd, Rels, Sec);
+  relocateOptimized(Buf, BufEnd, Rels, Sec);
+}
+
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> Data = this->getSectionData();
   memcpy(Buf + OutSecOff, Data.data(), Data.size());
 
   ELFFile<ELFT> &EObj = this->File->getObj();
   uint8_t *BufEnd = Buf + OutSecOff + Data.size();
   // Iterate over all relocation sections that apply to this section.
-  for (const Elf_Shdr *RelSec : this->RelocSections) {
-    if (RelSec->sh_type == SHT_RELA)
-      this->relocate(Buf, BufEnd, EObj.relas(RelSec));
+  for (const RelocSec &RelSec : this->RelocSections) {
+    if (RelSec.Sec->sh_type == SHT_RELA)
+      this->relocate(Buf, BufEnd, EObj.relas(RelSec.Sec), RelSec);
     else
-      this->relocate(Buf, BufEnd, EObj.rels(RelSec));
+      this->relocate(Buf, BufEnd, EObj.rels(RelSec.Sec), RelSec);
   }
 }
 
 template <class ELFT>
 SplitInputSection<ELFT>::SplitInputSection(
     ObjectFile<ELFT> *File, const Elf_Shdr *Header,
     typename InputSectionBase<ELFT>::Kind SectionKind)
     : InputSectionBase<ELFT>(File, Header, SectionKind) {}

ELF/MarkLive.cpp

 template <class ELFT>
 static void forEachSuccessor(InputSection<ELFT> *Sec,
                              std::function<void(InputSectionBase<ELFT> *)> Fn) {
   typedef typename ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
 
   ELFFile<ELFT> &Obj = Sec->getFile()->getObj();
-  for (const Elf_Shdr *RelSec : Sec->RelocSections) {
-    if (RelSec->sh_type == SHT_RELA) {
-      for (const Elf_Rela &RI : Obj.relas(RelSec))
+  for (const InputSectionBase<ELFT>::RelocSec &RelSec : Sec->RelocSections) {
+    if (RelSec.Sec->sh_type == SHT_RELA) {
+      for (const Elf_Rela &RI : Obj.relas(RelSec.Sec))
         if (InputSectionBase<ELFT> *Succ = Sec->getRelocTarget(RI))
           Fn(Succ);
     } else {
-      for (const Elf_Rel &RI : Obj.rels(RelSec))
+      for (const Elf_Rel &RI : Obj.rels(RelSec.Sec))
         if (InputSectionBase<ELFT> *Succ = Sec->getRelocTarget(RI))
           Fn(Succ);
     }
   }
 }
 
 // Sections listed below are special because they are used by the loader
 // just by being in an ELF file. They should not be garbage-collected.

ELF/OutputSections.cpp

EHOutputSection<ELFT>::readEntryLength(ArrayRef<uint8_t> D) {
   if (Len + 12 > D.size())
     error("CIE/FIE ends past the end of the section");
   return Len + 12;
 }
 
 template <class ELFT>
 void EHOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   auto *S = cast<EHInputSection<ELFT>>(C);
-  const Elf_Shdr *RelSec = S->RelocSection;
-  if (!RelSec)
+  if (!S->RelocSection)
     return addSectionAux(
         S, make_range((const Elf_Rela *)nullptr, (const Elf_Rela *)nullptr));
+  const Elf_Shdr *RelSec = S->RelocSection->Sec;
   ELFFile<ELFT> &Obj = S->getFile()->getObj();
   if (RelSec->sh_type == SHT_RELA)
     return addSectionAux(S, Obj.relas(RelSec));
   return addSectionAux(S, Obj.rels(RelSec));
 }
 
 template <class ELFT>
 static typename ELFFile<ELFT>::uintX_t writeAlignedCieOrFde(StringRef Data,
for (const EHRegion<ELFT> &F : C.Fdes) {
       write32<E>(Buf + Offset + 4, Offset + 4 - CieOffset); // Pointer
       F.S->Offsets[F.Index].second = Offset;
       Out<ELFT>::EhFrameHdr->addFde(C.FdeEncoding, Offset, Buf + Offset + 8);
       Offset += Len;
     }
   }
 
   for (EHInputSection<ELFT> *S : Sections) {
-    const Elf_Shdr *RelSec = S->RelocSection;
-    if (!RelSec)
+    if (!S->RelocSection)
       continue;
+    const Elf_Shdr *RelSec = S->RelocSection->Sec;
     ELFFile<ELFT> &EObj = S->getFile()->getObj();
     if (RelSec->sh_type == SHT_RELA)
-      S->relocate(Buf, nullptr, EObj.relas(RelSec));
+      S->relocate(Buf, nullptr, EObj.relas(RelSec), *S->RelocSection.get());
     else
-      S->relocate(Buf, nullptr, EObj.rels(RelSec));
+      S->relocate(Buf, nullptr, EObj.rels(RelSec), *S->RelocSection.get());
   }
 }
 
 template <class ELFT>
 MergeOutputSection<ELFT>::MergeOutputSection(StringRef Name, uint32_t Type,
                                              uintX_t Flags)
     : OutputSectionBase<ELFT>(Name, Type, Flags) {}
 

ELF/Writer.cpp

 public:
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
   typedef typename ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
   typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
+  typedef typename InputSectionBase<ELFT>::RelocSec RelocSec;
+  typedef typename InputSectionBase<ELFT>::RelocData RelocData;
   Writer(SymbolTable<ELFT> &S) : Symtab(S) {}
   void run();
 
 private:
   void copyLocalSymbols();
   void addReservedSymbols();
   void createSections();
   void addPredefinedSections();
 
   template <bool isRela>
   void scanRelocs(InputSectionBase<ELFT> &C,
-                  iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels);
+                  iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels,
+                  RelocSec &D);
 
   void scanRelocs(InputSection<ELFT> &C);
-  void scanRelocs(InputSectionBase<ELFT> &S, const Elf_Shdr &RelSec);
+  void scanRelocs(InputSectionBase<ELFT> &S, RelocSec &RelSec);
   void updateRelro(Elf_Phdr *Cur, Elf_Phdr *GnuRelroPhdr, uintX_t VA);
   void assignAddresses();
   void buildSectionMap();
   void fixAbsoluteSymbols();
   void openFile(StringRef OutputPath);
   void writeHeader();
   void writeSections();
   bool isDiscarded(InputSectionBase<ELFT> *IS) const;
static bool isEqual(const SectionKey<Is64Bits> &LHS,
     return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
            LHS.Type == RHS.Type && LHS.Flags == RHS.Flags &&
            LHS.EntSize == RHS.EntSize;
   }
 };
 }
 
 template <class ELFT, class RelT>
-static bool handleTlsRelocation(unsigned Type, SymbolBody *Body,
-                                InputSectionBase<ELFT> &C, RelT &RI) {
+static bool scanOptRelocation(unsigned Type, SymbolBody *Body,
+                                InputSectionBase<ELFT> &C, RelT &RI,
+                                typename Writer<ELFT>::RelocData &R) {
+  bool IsHint = Target->isHintReloc(Type);
+  R.Optimized = IsHint || Target->isTlsOptimized(Type, Body);
+  // Ignore "hint" relocation because it is for optional code optimization.
+  if (IsHint)
+    return true;
+
   if (Target->isTlsLocalDynamicReloc(Type)) {
-    if (Target->isTlsOptimized(Type, nullptr))
+    if (R.Optimized)
       return true;
     if (Out<ELFT>::Got->addCurrentModuleTlsIndex())
       Out<ELFT>::RelaDyn->addReloc({&C, &RI});
     return true;
   }
 
   if (!Body || !Body->isTls())
     return false;
 
   if (Target->isTlsGlobalDynamicReloc(Type)) {
-    bool Opt = Target->isTlsOptimized(Type, Body);
-    if (!Opt && Out<ELFT>::Got->addDynTlsEntry(Body)) {
+    if (!R.Optimized && Out<ELFT>::Got->addDynTlsEntry(Body)) {
       Out<ELFT>::RelaDyn->addReloc({&C, &RI});
       Out<ELFT>::RelaDyn->addReloc({nullptr, nullptr});
       Body->setUsedInDynamicReloc();
       return true;
     }
     if (!canBePreempted(Body, true))
       return true;
   }
   return !Target->isTlsDynReloc(Type, *Body);
 }
 
 // The reason we have to do this early scan is as follows
 // * To mmap the output file, we need to know the size
 // * For that, we need to know how many dynamic relocs we will have.
 // It might be possible to avoid this by outputting the file with write:
 // * Write the allocated output sections, computing addresses.
 // * Apply relocations, recording which ones require a dynamic reloc.
 // * Write the dynamic relocations.
 // * Write the rest of the file.
 template <class ELFT>
 template <bool isRela>
 void Writer<ELFT>::scanRelocs(
     InputSectionBase<ELFT> &C,
-    iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels) {
+    iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels, RelocSec &D) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   const ObjectFile<ELFT> &File = *C.getFile();
-  for (const RelType &RI : Rels) {
+  size_t Num = Rels.end() - Rels.begin();
+  for (size_t I = 0; I < Num; ++I) {
+    const RelType &RI = *(Rels.begin() + I);
+    RelocData &RelData = *(D.Relocs.begin() + I);
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     SymbolBody *Body = File.getSymbolBody(SymIndex);
     uint32_t Type = RI.getType(Config->Mips64EL);
 
-    // Ignore "hint" relocation because it is for optional code optimization.
-    if (Target->isHintReloc(Type))
-      continue;
-
     if (Target->isGotRelative(Type))
       HasGotOffRel = true;
 
     // Set "used" bit for --as-needed.
     if (Body && Body->isUndefined() && !Body->isWeak())
       if (auto *S = dyn_cast<SharedSymbol<ELFT>>(Body->repl()))
         S->File->IsUsed = true;
 
     if (Body)
       Body = Body->repl();
 
-    if (handleTlsRelocation<ELFT>(Type, Body, C, RI))
+    if (scanOptRelocation<ELFT>(Type, Body, C, RI, RelData))
       continue;
 
     if (Target->relocNeedsDynRelative(Type)) {
       RelType *Rel = new (Alloc) RelType;
       Rel->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
       Rel->r_offset = RI.r_offset;
       Out<ELFT>::RelaDyn->addReloc({&C, Rel});
     }
else
       Out<ELFT>::RelaDyn->addReloc({&C, &RI});
   }
 }
 
 template <class ELFT> void Writer<ELFT>::scanRelocs(InputSection<ELFT> &C) {
   if (!(C.getSectionHdr()->sh_flags & SHF_ALLOC))
     return;
 
-  for (const Elf_Shdr *RelSec : C.RelocSections)
-    scanRelocs(C, *RelSec);
+  for (InputSectionBase<ELFT>::RelocSec &RelSec : C.RelocSections)
+    scanRelocs(C, RelSec);
 }
 
 template <class ELFT>
-void Writer<ELFT>::scanRelocs(InputSectionBase<ELFT> &S,
-                              const Elf_Shdr &RelSec) {
+void Writer<ELFT>::scanRelocs(InputSectionBase<ELFT> &S, RelocSec &RelSec) {
   ELFFile<ELFT> &EObj = S.getFile()->getObj();
-  if (RelSec.sh_type == SHT_RELA)
-    scanRelocs(S, EObj.relas(&RelSec));
+  if (RelSec.Sec->sh_type == SHT_RELA)
+    scanRelocs(S, EObj.relas(RelSec.Sec), RelSec);
   else
-    scanRelocs(S, EObj.rels(&RelSec));
+    scanRelocs(S, EObj.rels(RelSec.Sec), RelSec);
 }
 
 template <class ELFT>
 static void reportUndefined(SymbolTable<ELFT> &Symtab, SymbolBody *Sym) {
   if (Config->Shared && !Config->NoUndefined)
     return;
 
   std::string Msg = "undefined symbol: " + Sym->getName().str();
template <class ELFT> void Writer<ELFT>::createSections() {
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
     for (InputSectionBase<ELFT> *C : F->getSections()) {
       if (isDiscarded(C))
         continue;
       if (auto *S = dyn_cast<InputSection<ELFT>>(C))
         scanRelocs(*S);
       else if (auto *S = dyn_cast<EHInputSection<ELFT>>(C))
         if (S->RelocSection)
-          scanRelocs(*S, *S->RelocSection);
+          scanRelocs(*S, *S->RelocSection.get());
     }
   }
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
 
   // Now that we have defined all possible symbols including linker-
   // synthesized ones. Visit all symbols to give the finishing touches.