[ELF] Replace InputBaseSection::{areRelocsRela,firstRelocation,numRelocation} with relSecIdx

[MaskRay]

Summary

For InputSection .foo, its InputBaseSection::{areRelocsRela,firstRelocation,numRelocation} basically
encode the information of .rel[a].foo. However, one uint32_t (the relocation section index)
suffices. See the implementation of relsOrRelas.

This change decreases sizeof(InputSection) from 184 to 176 on 64-bit Linux.

The maximum resident set size linking a large application (1.2G output) decreases by 0.39%.

[arichardson]

Nice and easy size reduction :) It seems unlikely that the calls to relsOrRelas() add noticeable overhead compared to looking at the cached values. Would prefer a named struct over std::pair though.

lld/ELF/InputSection.cpp

163

I would define a struct for the two arrays instead of using std::pair since it's not obvious what .first/.second is accessing in the rest of the patch.

[MaskRay]

Add struct RelsOrRelas<ELFT>

[peter.smith]

Only a small suggestion, no objections from me.

lld/ELF/InputSection.h

38

May be worth a member function like bool areRelocsRel() const { return rels.size(); } that could be used instead of if (rels.rels.size()) not a strong opinion, may not be worth the change.

[MaskRay]

Add RelsOrRelas::areRelocsRel()

[MaskRay]

I will do minor adjustment and push this.

[MaskRay]

use more areRelocsRel()

lld/ELF/Arch/PPC64.cpp

void elf::addPPC64SaveRestore() {
   // Tail: blr
   writeSequence(savegpr1, "_savegpr1_", 14, 0xf9ccff70, {blr});
 }
 
 // Find the R_PPC64_ADDR64 in .rela.toc with matching offset.
 template <typename ELFT>
 static std::pair<Defined *, int64_t>
 getRelaTocSymAndAddend(InputSectionBase *tocSec, uint64_t offset) {
-  if (tocSec->numRelocations == 0)
-    return {};
-
   // .rela.toc contains exclusively R_PPC64_ADDR64 relocations sorted by
   // r_offset: 0, 8, 16, etc. For a given Offset, Offset / 8 gives us the
   // relocation index in most cases.
   //
   // In rare cases a TOC entry may store a constant that doesn't need an
   // R_PPC64_ADDR64, the corresponding r_offset is therefore missing. Offset / 8
   // points to a relocation with larger r_offset. Do a linear probe then.
   // Constants are extremely uncommon in .toc and the extra number of array
   // accesses can be seen as a small constant.
-  ArrayRef<typename ELFT::Rela> relas = tocSec->template relas<ELFT>();
+  ArrayRef<typename ELFT::Rela> relas =
+      tocSec->template relsOrRelas<ELFT>().second;
+  if (relas.empty())
+    return {};
   uint64_t index = std::min<uint64_t>(offset / 8, relas.size() - 1);
   for (;;) {
     if (relas[index].r_offset == offset) {
       Symbol &sym = tocSec->getFile<ELFT>()->getRelocTargetSym(relas[index]);
       return {dyn_cast<Defined>(&sym), getAddend<ELFT>(relas[index])};
     }
     if (relas[index].r_offset < offset || index == 0)
       break;

lld/ELF/DWARF.cpp

return RelocAddrEntry{secIndex, RelocationRef(d, nullptr),
                         val,      Optional<object::RelocationRef>(),
                         0,        LLDRelocationResolver<RelTy>::resolve};
 }
 
 template <class ELFT>
 Optional<RelocAddrEntry> LLDDwarfObj<ELFT>::find(const llvm::DWARFSection &s,
                                                  uint64_t pos) const {
   auto &sec = static_cast<const LLDDWARFSection &>(s);
-  if (sec.sec->areRelocsRela)
-    return findAux(*sec.sec, pos, sec.sec->template relas<ELFT>());
-  return findAux(*sec.sec, pos, sec.sec->template rels<ELFT>());
+  const auto rels = sec.sec->template relsOrRelas<ELFT>();
+  if (rels.first.size())
+    return findAux(*sec.sec, pos, rels.first);
+  return findAux(*sec.sec, pos, rels.second);
 }
 
 template class elf::LLDDwarfObj<ELF32LE>;
 template class elf::LLDDwarfObj<ELF32BE>;
 template class elf::LLDDwarfObj<ELF64LE>;
 template class elf::LLDDwarfObj<ELF64BE>;

lld/ELF/Driver.cpp

 
 // This function reads a symbol partition specification section. These sections
 // are used to control which partition a symbol is allocated to. See
 // https://lld.llvm.org/Partitions.html for more details on partitions.
 template <typename ELFT>
 static void readSymbolPartitionSection(InputSectionBase *s) {
   // Read the relocation that refers to the partition's entry point symbol.
   Symbol *sym;
-  if (s->areRelocsRela)
-    sym = &s->getFile<ELFT>()->getRelocTargetSym(s->template relas<ELFT>()[0]);
+  const auto rels = s->template relsOrRelas<ELFT>();
+  if (rels.first.size())
+    sym = &s->getFile<ELFT>()->getRelocTargetSym(rels.first[0]);
   else
-    sym = &s->getFile<ELFT>()->getRelocTargetSym(s->template rels<ELFT>()[0]);
+    sym = &s->getFile<ELFT>()->getRelocTargetSym(rels.second[0]);
   if (!isa<Defined>(sym) || !sym->includeInDynsym())
     return;
 
   StringRef partName = reinterpret_cast<const char *>(s->data().data());
   for (Partition &part : partitions) {
     if (part.name == partName) {
       sym->partition = part.getNumber();
       return;

lld/ELF/ICF.cpp

void ICF<ELFT>::segregate(size_t begin, size_t end, uint32_t eqClassBase,
   }
 }
 
 // Compare two lists of relocations.
 template <class ELFT>
 template <class RelTy>
 bool ICF<ELFT>::constantEq(const InputSection *secA, ArrayRef<RelTy> ra,
                            const InputSection *secB, ArrayRef<RelTy> rb) {
+  if (ra.size() != rb.size())
+    return false;
   for (size_t i = 0; i < ra.size(); ++i) {
     if (ra[i].r_offset != rb[i].r_offset ||
         ra[i].getType(config->isMips64EL) != rb[i].getType(config->isMips64EL))
       return false;
 
     uint64_t addA = getAddend<ELFT>(ra[i]);
     uint64_t addB = getAddend<ELFT>(rb[i]);
 
bool ICF<ELFT>::constantEq(const InputSection *secA, ArrayRef<RelTy> ra,
 
   return true;
 }
 
 // Compare "non-moving" part of two InputSections, namely everything
 // except relocation targets.
 template <class ELFT>
 bool ICF<ELFT>::equalsConstant(const InputSection *a, const InputSection *b) {
-  if (a->numRelocations != b->numRelocations || a->flags != b->flags ||
-      a->getSize() != b->getSize() || a->data() != b->data())
+  if (a->flags != b->flags || a->getSize() != b->getSize() ||
+      a->data() != b->data())
     return false;
 
   // If two sections have different output sections, we cannot merge them.
   assert(a->getParent() && b->getParent());
   if (a->getParent() != b->getParent())
     return false;
 
-  if (a->areRelocsRela)
-    return constantEq(a, a->template relas<ELFT>(), b,
-                      b->template relas<ELFT>());
-  return constantEq(a, a->template rels<ELFT>(), b, b->template rels<ELFT>());
+  const auto ra = a->template relsOrRelas<ELFT>();
+  const auto rb = b->template relsOrRelas<ELFT>();
+  if (ra.first.size())
+    return constantEq(a, ra.first, b, rb.first);
+  return constantEq(a, ra.second, b, rb.second);
 }
 
 // Compare two lists of relocations. Returns true if all pairs of
 // relocations point to the same section in terms of ICF.
 template <class ELFT>
 template <class RelTy>
 bool ICF<ELFT>::variableEq(const InputSection *secA, ArrayRef<RelTy> ra,
                            const InputSection *secB, ArrayRef<RelTy> rb) {
bool ICF<ELFT>::variableEq(const InputSection *secA, ArrayRef<RelTy> ra,
   };
 
   return true;
 }
 
 // Compare "moving" part of two InputSections, namely relocation targets.
 template <class ELFT>
 bool ICF<ELFT>::equalsVariable(const InputSection *a, const InputSection *b) {
-  if (a->areRelocsRela)
-    return variableEq(a, a->template relas<ELFT>(), b,
-                      b->template relas<ELFT>());
-  return variableEq(a, a->template rels<ELFT>(), b, b->template rels<ELFT>());
+  const auto ra = a->template relsOrRelas<ELFT>();
+  const auto rb = b->template relsOrRelas<ELFT>();
+  if (ra.first.size())
+    return variableEq(a, ra.first, b, rb.first);
+  return variableEq(a, ra.second, b, rb.second);
 }
 
 template <class ELFT> size_t ICF<ELFT>::findBoundary(size_t begin, size_t end) {
   uint32_t eqClass = sections[begin]->eqClass[current];
   for (size_t i = begin + 1; i < end; ++i)
     if (eqClass != sections[i]->eqClass[current])
       return i;
   return end;
parallelForEach(sections, [&](InputSection *s) {
     s->eqClass[0] = xxHash64(s->data()) | (1U << 31);
   });
 
   // Perform 2 rounds of relocation hash propagation. 2 is an empirical value to
   // reduce the average sizes of equivalence classes, i.e. segregate() which has
   // a large time complexity will have less work to do.
   for (unsigned cnt = 0; cnt != 2; ++cnt) {
     parallelForEach(sections, [&](InputSection *s) {
-      if (s->areRelocsRela)
-        combineRelocHashes<ELFT>(cnt, s, s->template relas<ELFT>());
+      const auto rels = s->template relsOrRelas<ELFT>();
+      if (rels.first.size())
+        combineRelocHashes<ELFT>(cnt, s, rels.first);
       else
-        combineRelocHashes<ELFT>(cnt, s, s->template rels<ELFT>());
+        combineRelocHashes<ELFT>(cnt, s, rels.second);
     });
   }
 
   // From now on, sections in Sections vector are ordered so that sections
   // in the same equivalence class are consecutive in the vector.
   llvm::stable_sort(sections, [](const InputSection *a, const InputSection *b) {
     return a->eqClass[0] < b->eqClass[0];
   });

lld/ELF/InputFiles.h

public:
   DWARFCache *getDwarf();
 
 private:
   void initializeSections(bool ignoreComdats);
   void initializeSymbols();
   void initializeJustSymbols();
 
   InputSectionBase *getRelocTarget(const Elf_Shdr &sec);
-  InputSectionBase *createInputSection(const Elf_Shdr &sec, StringRef shstrtab);
+  InputSectionBase *createInputSection(uint32_t idx, const Elf_Shdr &sec,
+                                       StringRef shstrtab);
 
   bool shouldMerge(const Elf_Shdr &sec, StringRef name);
 
   // Each ELF symbol contains a section index which the symbol belongs to.
   // However, because the number of bits dedicated for that is limited, a
   // symbol can directly point to a section only when the section index is
   // equal to or smaller than 65280.
   //

lld/ELF/InputFiles.cpp

case SHT_GROUP: {
         fatal(toString(this) + ": unsupported SHT_GROUP format");
 
       bool keepGroup =
           (flag & GRP_COMDAT) == 0 || ignoreComdats ||
           symtab->comdatGroups.try_emplace(CachedHashStringRef(signature), this)
               .second;
       if (keepGroup) {
         if (config->relocatable)
-          this->sections[i] = createInputSection(sec, shstrtab);
+          this->sections[i] = createInputSection(i, sec, shstrtab);
         selectedGroups.push_back(entries);
         continue;
       }
 
       // Otherwise, discard group members.
       for (uint32_t secIndex : entries.slice(1)) {
         if (secIndex >= size)
           fatal(toString(this) +
                 ": invalid section index in group: " + Twine(secIndex));
         this->sections[secIndex] = &InputSection::discarded;
       }
       break;
     }
     case SHT_SYMTAB_SHNDX:
       shndxTable = CHECK(obj.getSHNDXTable(sec, objSections), this);
       break;
     case SHT_SYMTAB:
     case SHT_STRTAB:
     case SHT_REL:
     case SHT_RELA:
     case SHT_NULL:
       break;
     default:
-      this->sections[i] = createInputSection(sec, shstrtab);
+      this->sections[i] = createInputSection(i, sec, shstrtab);
     }
   }
 
   // We have a second loop. It is used to:
   // 1) handle SHF_LINK_ORDER sections.
   // 2) create SHT_REL[A] sections. In some cases the section header index of a
   //    relocation section may be smaller than that of the relocated section. In
   //    such cases, the relocation section would attempt to reference a target
   //    section that has not yet been created. For simplicity, delay creation of
   //    relocation sections until now.
   for (size_t i = 0, e = objSections.size(); i < e; ++i) {
     if (this->sections[i] == &InputSection::discarded)
       continue;
     const Elf_Shdr &sec = objSections[i];
 
     if (sec.sh_type == SHT_REL || sec.sh_type == SHT_RELA)
-      this->sections[i] = createInputSection(sec, shstrtab);
+      this->sections[i] = createInputSection(i, sec, shstrtab);
 
     // A SHF_LINK_ORDER section with sh_link=0 is handled as if it did not have
     // the flag.
     if (!(sec.sh_flags & SHF_LINK_ORDER) || !sec.sh_link)
       continue;
 
     InputSectionBase *linkSec = nullptr;
     if (sec.sh_link < this->sections.size())

 // Create a regular InputSection class that has the same contents
 // as a given section.
 static InputSection *toRegularSection(MergeInputSection *sec) {
   return make<InputSection>(sec->file, sec->flags, sec->type, sec->alignment,
                             sec->data(), sec->name);
 }
 
 template <class ELFT>
-InputSectionBase *ObjFile<ELFT>::createInputSection(const Elf_Shdr &sec,
+InputSectionBase *ObjFile<ELFT>::createInputSection(uint32_t idx,
+                                                    const Elf_Shdr &sec,
                                                     StringRef shstrtab) {
   StringRef name = CHECK(getObj().getSectionName(sec, shstrtab), this);
 
   if (config->emachine == EM_ARM && sec.sh_type == SHT_ARM_ATTRIBUTES) {
     ARMAttributeParser attributes;
     ArrayRef<uint8_t> contents = check(this->getObj().getSectionContents(sec));
     if (Error e = attributes.parse(contents, config->ekind == ELF32LEKind
                                                  ? support::little
case SHT_REL: {
     // because applying relocations at end of linking changes section
     // contents. So, we simply handle such sections as non-mergeable ones.
     // Degrading like this is acceptable because section merging is optional.
     if (auto *ms = dyn_cast<MergeInputSection>(target)) {
       target = toRegularSection(ms);
       this->sections[sec.sh_info] = target;
     }
 
-    if (target->firstRelocation)
+    if (target->relSecIdx != 0)
       fatal(toString(this) +
             ": multiple relocation sections to one section are not supported");
-
-    if (sec.sh_type == SHT_RELA) {
-      ArrayRef<Elf_Rela> rels = CHECK(getObj().relas(sec), this);
-      target->firstRelocation = rels.begin();
-      target->numRelocations = rels.size();
-      target->areRelocsRela = true;
-    } else {
-      ArrayRef<Elf_Rel> rels = CHECK(getObj().rels(sec), this);
-      target->firstRelocation = rels.begin();
-      target->numRelocations = rels.size();
-      target->areRelocsRela = false;
-    }
-    assert(isUInt<31>(target->numRelocations));
+    target->relSecIdx = idx;
 
     // Relocation sections are usually removed from the output, so return
     // `nullptr` for the normal case. However, if -r or --emit-relocs is
     // specified, we need to copy them to the output. (Some post link analysis
     // tools specify --emit-relocs to obtain the information.)
     if (!config->relocatable && !config->emitRelocs)
       return nullptr;
     InputSection *relocSec = make<InputSection>(*this, sec, name);

lld/ELF/InputSection.h

 class MergeSyntheticSection;
 template <class ELFT> class ObjFile;
 class OutputSection;
 
 extern std::vector<Partition> partitions;
 
 // This is the base class of all sections that lld handles. Some are sections in
 // input files, some are sections in the produced output file and some exist
 // just as a convenience for implementing special ways of combining some
 // sections.
 class SectionBase {
 public:
   enum Kind { Regular, EHFrame, Merge, Synthetic, Output };
 
   Kind kind() const { return (Kind)sectionKind; }
 
   StringRef name;
public:
 
   InputSectionBase(InputFile *file, uint64_t flags, uint32_t type,
                    uint64_t entsize, uint32_t link, uint32_t info,
                    uint32_t alignment, ArrayRef<uint8_t> data, StringRef name,
                    Kind sectionKind);
 
   static bool classof(const SectionBase *s) { return s->kind() != Output; }
 
-  // Relocations that refer to this section.
-  unsigned numRelocations : 31;
-  unsigned areRelocsRela : 1;
-  const void *firstRelocation = nullptr;
+  // Section index of the relocation section if exists.
+  uint32_t relSecIdx = 0;
 
   // The file which contains this section. Its dynamic type is always
   // ObjFile<ELFT>, but in order to avoid ELFT, we use InputFile as
   // its static type.
   InputFile *file;
 
   template <class ELFT> ObjFile<ELFT> *getFile() const {
     return cast_or_null<ObjFile<ELFT>>(file);
public:
   // synthetic section that is then added to an output section. In all
   // cases this points one level up.
   SectionBase *parent = nullptr;
 
   // The next member in the section group if this section is in a group. This is
   // used by --gc-sections.
   InputSectionBase *nextInSectionGroup = nullptr;
 
-  template <class ELFT> ArrayRef<typename ELFT::Rel> rels() const {
-    assert(!areRelocsRela);
-    return llvm::makeArrayRef(
-        static_cast<const typename ELFT::Rel *>(firstRelocation),
-        numRelocations);
-  }
-
-  template <class ELFT> ArrayRef<typename ELFT::Rela> relas() const {
-    assert(areRelocsRela);
-    return llvm::makeArrayRef(
-        static_cast<const typename ELFT::Rela *>(firstRelocation),
-        numRelocations);
-  }
+  template <class ELFT>
+  std::pair<ArrayRef<typename ELFT::Rel>, ArrayRef<typename ELFT::Rela>>
+  relsOrRelas() const;
 
   // InputSections that are dependent on us (reverse dependency for GC)
   llvm::TinyPtrVector<InputSection *> dependentSections;
 
   // Returns the size of this section (even if this is a common or BSS.)
   size_t getSize() const;
 
   InputSection *getLinkOrderDep() const;

 private:
   template <class ELFT, class RelTy>
   void copyRelocations(uint8_t *buf, llvm::ArrayRef<RelTy> rels);
 
   template <class ELFT> void copyShtGroup(uint8_t *buf);
 };
 
 #ifdef _WIN32
-static_assert(sizeof(InputSection) <= 192, "InputSection is too big");
-#else
 static_assert(sizeof(InputSection) <= 184, "InputSection is too big");
+#else
+static_assert(sizeof(InputSection) <= 176, "InputSection is too big");
 #endif
 
 inline bool isDebugSection(const InputSectionBase &sec) {
   return (sec.flags & llvm::ELF::SHF_ALLOC) == 0 &&
          (sec.name.startswith(".debug") || sec.name.startswith(".zdebug"));
 }
 
 // The list of all input sections.

lld/ELF/InputSection.cpp

: SectionBase(sectionKind, name, flags, entsize, alignment, type, info,
                   link),
       file(file), rawData(data) {
   // In order to reduce memory allocation, we assume that mergeable
   // sections are smaller than 4 GiB, which is not an unreasonable
   // assumption as of 2017.
   if (sectionKind == SectionBase::Merge && rawData.size() > UINT32_MAX)
     error(toString(this) + ": section too large");
 
-  numRelocations = 0;
-  areRelocsRela = false;
-
   // The ELF spec states that a value of 0 means the section has
   // no alignment constraints.
   uint32_t v = std::max<uint32_t>(alignment, 1);
   if (!isPowerOf2_64(v))
     fatal(toString(this) + ": sh_addralign is not a power of 2");
   this->alignment = v;
 
   // In ELF, each section can be compressed by zlib, and if compressed,

 }
 
 uint64_t InputSectionBase::getOffsetInFile() const {
   const uint8_t *fileStart = (const uint8_t *)file->mb.getBufferStart();
   const uint8_t *secStart = data().begin();
   return secStart - fileStart;
 }
 
+template <class ELFT>
+std::pair<ArrayRef<typename ELFT::Rel>, ArrayRef<typename ELFT::Rela>>
+InputSectionBase::relsOrRelas() const {
+  if (relSecIdx == 0)
+    return {};
+  std::pair<ArrayRef<typename ELFT::Rel>, ArrayRef<typename ELFT::Rela>> ret;
+  const ELFFile<ELFT> obj = cast<ELFFileBase>(file)->getObj<ELFT>();
+  typename ELFT::Shdr shdr = cantFail(obj.sections())[relSecIdx];
+  if (shdr.sh_type == SHT_REL) {
+    ret.first = makeArrayRef(reinterpret_cast<const typename ELFT::Rel *>(
+                                 obj.base() + shdr.sh_offset),
+                             shdr.sh_size / sizeof(typename ELFT::Rel));
+  } else {
+    assert(shdr.sh_type == SHT_RELA);
+    ret.second = makeArrayRef(reinterpret_cast<const typename ELFT::Rela *>(
+                                  obj.base() + shdr.sh_offset),
+                              shdr.sh_size / sizeof(typename ELFT::Rela));
+  }
+  return ret;
+}
+
 uint64_t SectionBase::getOffset(uint64_t offset) const {
   switch (kind()) {
   case Output: {
     auto *os = cast<OutputSection>(this);
     // For output sections we treat offset -1 as the end of the section.
     return offset == uint64_t(-1) ? os->size : offset;
   }
   case Regular:
if (flags & SHF_EXECINSTR)
     adjustSplitStackFunctionPrologues<ELFT>(buf, bufEnd);
 
   if (flags & SHF_ALLOC) {
     relocateAlloc(buf, bufEnd);
     return;
   }
 
   auto *sec = cast<InputSection>(this);
-  if (config->relocatable)
+  if (config->relocatable) {
     relocateNonAllocForRelocatable(sec, buf);
-  else if (sec->areRelocsRela)
-    sec->relocateNonAlloc<ELFT>(buf, sec->template relas<ELFT>());
-  else
-    sec->relocateNonAlloc<ELFT>(buf, sec->template rels<ELFT>());
+  } else {
+    auto rels = sec->template relsOrRelas<ELFT>();
+    sec->relocateNonAlloc<ELFT>(buf, rels.first);
+    sec->relocateNonAlloc<ELFT>(buf, rels.second);
+  }
 }
 
 void InputSectionBase::relocateAlloc(uint8_t *buf, uint8_t *bufEnd) {
   assert(flags & SHF_ALLOC);
   const unsigned bits = config->wordsize * 8;
   uint64_t lastPPCRelaxedRelocOff = UINT64_C(-1);
 
   for (const Relocation &rel : relocations) {
for (unsigned n = rels.size(); relocI < n; ++relocI) {
     return -1;
   }
   return -1;
 }
 
 // .eh_frame is a sequence of CIE or FDE records.
 // This function splits an input section into records and returns them.
 template <class ELFT> void EhInputSection::split() {
-  if (areRelocsRela)
-    split<ELFT>(relas<ELFT>());
+  auto rels = relsOrRelas<ELFT>();
+  if (rels.first.size())
+    split<ELFT>(rels.first);
   else
-    split<ELFT>(rels<ELFT>());
+    split<ELFT>(rels.second);
 }
 
 template <class ELFT, class RelTy>
 void EhInputSection::split(ArrayRef<RelTy> rels) {
   // getReloc expects the relocations to be sorted by r_offset. See the comment
   // in scanRelocs.
   SmallVector<RelTy, 0> storage;
   rels = sortRels(rels, storage);

 template std::string InputSectionBase::getLocation<ELF64LE>(uint64_t);
 template std::string InputSectionBase::getLocation<ELF64BE>(uint64_t);
 
 template void InputSection::writeTo<ELF32LE>(uint8_t *);
 template void InputSection::writeTo<ELF32BE>(uint8_t *);
 template void InputSection::writeTo<ELF64LE>(uint8_t *);
 template void InputSection::writeTo<ELF64BE>(uint8_t *);
 
+template std::pair<ArrayRef<typename ELF32LE::Rel>,
+                   ArrayRef<typename ELF32LE::Rela>>
+InputSectionBase::relsOrRelas<ELF32LE>() const;
+template std::pair<ArrayRef<typename ELF32BE::Rel>,
+                   ArrayRef<typename ELF32BE::Rela>>
+InputSectionBase::relsOrRelas<ELF32BE>() const;
+template std::pair<ArrayRef<typename ELF64LE::Rel>,
+                   ArrayRef<typename ELF64LE::Rela>>
+InputSectionBase::relsOrRelas<ELF64LE>() const;
+template std::pair<ArrayRef<typename ELF64BE::Rel>,
+                   ArrayRef<typename ELF64BE::Rela>>
+InputSectionBase::relsOrRelas<ELF64BE>() const;
+
 template MergeInputSection::MergeInputSection(ObjFile<ELF32LE> &,
                                               const ELF32LE::Shdr &, StringRef);
 template MergeInputSection::MergeInputSection(ObjFile<ELF32BE> &,
                                               const ELF32BE::Shdr &, StringRef);
 template MergeInputSection::MergeInputSection(ObjFile<ELF64LE> &,
                                               const ELF64LE::Shdr &, StringRef);
 template MergeInputSection::MergeInputSection(ObjFile<ELF64BE> &,
                                               const ELF64BE::Shdr &, StringRef);

lld/ELF/MarkLive.cpp

template <class ELFT> void MarkLive<ELFT>::run() {
   // script KEEP command.
   for (InputSectionBase *sec : inputSections) {
     // Mark .eh_frame sections as live because there are usually no relocations
     // that point to .eh_frames. Otherwise, the garbage collector would drop
     // all of them. We also want to preserve personality routines and LSDA
     // referenced by .eh_frame sections, so we scan them for that here.
     if (auto *eh = dyn_cast<EhInputSection>(sec)) {
       eh->markLive();
-      if (!eh->numRelocations)
-        continue;
 
-      if (eh->areRelocsRela)
-        scanEhFrameSection(*eh, eh->template relas<ELFT>());
-      else
-        scanEhFrameSection(*eh, eh->template rels<ELFT>());
+      const auto rels = eh->template relsOrRelas<ELFT>();
+      if (rels.first.size())
+        scanEhFrameSection(*eh, rels.first);
+      else if (rels.second.size())
+        scanEhFrameSection(*eh, rels.second);
     }
 
     if (sec->flags & SHF_GNU_RETAIN) {
       enqueue(sec, 0);
       continue;
     }
     if (sec->flags & SHF_LINK_ORDER)
       continue;
template <class ELFT> void MarkLive<ELFT>::run() {
   mark();
 }
 
 template <class ELFT> void MarkLive<ELFT>::mark() {
   // Mark all reachable sections.
   while (!queue.empty()) {
     InputSectionBase &sec = *queue.pop_back_val();
 
-    if (sec.areRelocsRela) {
-      for (const typename ELFT::Rela &rel : sec.template relas<ELFT>())
-        resolveReloc(sec, rel, false);
-    } else {
-      for (const typename ELFT::Rel &rel : sec.template rels<ELFT>())
-        resolveReloc(sec, rel, false);
-    }
+    const auto rels = sec.template relsOrRelas<ELFT>();
+    for (const typename ELFT::Rel &rel : rels.first)
+    for (const typename ELFT::Rela &rel : rels.second)
 
     for (InputSectionBase *isec : sec.dependentSections)
       enqueue(isec, 0);
 
     // Mark the next group member.
     if (sec.nextInSectionGroup)
       enqueue(sec.nextInSectionGroup, 0);
   }

lld/ELF/Relocations.cpp

if (config->emachine == EM_RISCV ||
       (config->emachine == EM_PPC64 && sec.name == ".toc"))
     llvm::stable_sort(sec.relocations,
                       [](const Relocation &lhs, const Relocation &rhs) {
                         return lhs.offset < rhs.offset;
                       });
 }
 
 template <class ELFT> void elf::scanRelocations(InputSectionBase &s) {
-  if (s.areRelocsRela)
-    scanRelocs<ELFT>(s, s.relas<ELFT>());
+  const auto rels = s.template relsOrRelas<ELFT>();
+  if (rels.first.size())
+    scanRelocs<ELFT>(s, rels.first);
   else
-    scanRelocs<ELFT>(s, s.rels<ELFT>());
+    scanRelocs<ELFT>(s, rels.second);
 }
 
 static bool mergeCmp(const InputSection *a, const InputSection *b) {
   // std::merge requires a strict weak ordering.
   if (a->outSecOff < b->outSecOff)
     return true;
 
   if (a->outSecOff == b->outSecOff) {

lld/ELF/SyntheticSections.cpp

for (EhSectionPiece &piece : sec->pieces) {
     numFdes++;
   }
 }
 
 template <class ELFT>
 void EhFrameSection::addSectionAux(EhInputSection *sec) {
   if (!sec->isLive())
     return;
-  if (sec->areRelocsRela)
-    addRecords<ELFT>(sec, sec->template relas<ELFT>());
+  const auto rels = sec->template relsOrRelas<ELFT>();
+  if (rels.first.size())
+    addRecords<ELFT>(sec, rels.first);
   else
-    addRecords<ELFT>(sec, sec->template rels<ELFT>());
+    addRecords<ELFT>(sec, rels.second);
 }
 
 void EhFrameSection::addSection(EhInputSection *sec) {
   sec->parent = this;
 
   alignment = std::max(alignment, sec->alignment);
   sections.push_back(sec);
 

 }
 
 template <class ELFT>
 void EhFrameSection::iterateFDEWithLSDA(
     llvm::function_ref<void(InputSection &)> fn) {
   DenseSet<size_t> ciesWithLSDA;
   for (EhInputSection *sec : sections) {
     ciesWithLSDA.clear();
-    if (sec->areRelocsRela)
-      iterateFDEWithLSDAAux<ELFT>(*sec, sec->template relas<ELFT>(),
-                                  ciesWithLSDA, fn);
+    const auto rels = sec->template relsOrRelas<ELFT>();
+    if (rels.first.size())
+      iterateFDEWithLSDAAux<ELFT>(*sec, rels.first, ciesWithLSDA, fn);
     else
-      iterateFDEWithLSDAAux<ELFT>(*sec, sec->template rels<ELFT>(),
-                                  ciesWithLSDA, fn);
+      iterateFDEWithLSDAAux<ELFT>(*sec, rels.second, ciesWithLSDA, fn);
   }
 }
 
 static void writeCieFde(uint8_t *buf, ArrayRef<uint8_t> d) {
   memcpy(buf, d.data(), d.size());
 
   size_t aligned = alignTo(d.size(), config->wordsize);