[llvm-readobj] - Introduce `forEachRelocationDo` helper. NFCI.

[grimar]

Summary

Our printStackSize implementation currently uses
API like RelocationRef, object::symbol_iterator.
It is not ideal as it doesn't allow
to handle possible error conditions properly.

Some time ago I started rewriting it and this NFC patch is
a one more step toward to it. Here I am introducing the
forEachRelocationDo helper. With it it is possible to iterate
over all kinds of relocations, what is helpful for improving
the code it printStackSize and around.

I've made some progress in improving this area and going to post
other related follow-up patches really soon.

[MaskRay]

I don't get why RelRelaReloc is needed. Can you describe a bit about it?

llvm/tools/llvm-readobj/ELFDumper.cpp

817

It is slightly unfortunate that this cannot use function_ref because the variable used for initialization is local.

[grimar]

In D91530#2398695, @MaskRay wrote:

I don't get why RelRelaReloc is needed. Can you describe a bit about it?

Previously the Relocation was the struct which allowed to handle Rel/Rela relocations.
I've reworked it so that it how also is able to keep Relr relocations.
That way it allows to represent 3 types of relocations instead of previous 2 and have a common code for iterations over them.

RelRelaReloc is now a helper class that is used to represent Rel/Rela relocations.

[MaskRay]

In D91530#2398857, @grimar wrote:

In D91530#2398695, @MaskRay wrote:

I don't get why RelRelaReloc is needed. Can you describe a bit about it?

Previously the Relocation was the struct which allowed to handle Rel/Rela relocations.
I've reworked it so that it how also is able to keep Relr relocations.
That way it allows to represent 3 types of relocations instead of previous 2 and have a common code for iterations over them.

RelRelaReloc is now a helper class that is used to represent Rel/Rela relocations.

OK. Does this change make Relr easier to represent? Note that while REL/RELA type relocations are self-contained (the sh_offset is immediately known), RELR is not - it needs a context ((1) is it an address or a bitmap (2) for a bitmap, what is the starting address). Should it just be treated as a special case?

[grimar]

In D91530#2398871, @MaskRay wrote:

In D91530#2398857, @grimar wrote:

In D91530#2398695, @MaskRay wrote:

I don't get why RelRelaReloc is needed. Can you describe a bit about it?

Previously the Relocation was the struct which allowed to handle Rel/Rela relocations.
I've reworked it so that it how also is able to keep Relr relocations.
That way it allows to represent 3 types of relocations instead of previous 2 and have a common code for iterations over them.

RelRelaReloc is now a helper class that is used to represent Rel/Rela relocations.

OK. Does this change make Relr easier to represent? Note that while REL/RELA type relocations are self-contained (the sh_offset is immediately known), RELR is not - it needs a context ((1) is it an address or a bitmap (2) for a bitmap, what is the starting address). Should it just be treated as a special case?

Well. May be. I'll take a look on what can I do for it.

[grimar]

• Use special handling for Elf_Relr as suggested.

Seems looks indeed simpler.

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

5687

I don't really mind either way, but what's the motivation for passing in the RawRelr variable, rather than continuing to use opts::RawRelr?

[grimar]

llvm/tools/llvm-readobj/ELFDumper.cpp

5687

In my understanding, the opts::RawRelr option is related to relocation printing:
"Do not decode relocations in SHT_RELR section, display raw contents"

forEachRelocationDo is a more general API which can be used for other things as well.
Perhaps it is not ideal to use such flags inside.

[jhenderson]

Thanks for the answer, I think it makes sense. LGTM, but please wait for @MaskRay.

[MaskRay]

llvm/tools/llvm-readobj/ELFDumper.cpp

3809

this->printRelocationsHelper(Sec); has been expanded into

this->forEachRelocationDo(
        Sec, opts::RawRelr,
        [&](const Relocation<ELFT> &R, unsigned Ndx, const Elf_Shdr &Sec,
            const Elf_Shdr *SymTab) { printReloc(R, Ndx, Sec, SymTab); },
        [&](const Elf_Relr &R) { printRelrReloc(R); });

multiple times. Isn't the previous version clearer?

Can you elaborate on the claim in the description?

Our printStackSize implementation currently uses API like RelocationRef, object::symbol_iterator. It is not ideal as it doesn't allow to handle possible error conditions properly.

[grimar]

llvm/tools/llvm-readobj/ELFDumper.cpp

3809

Isn't the previous version clearer?

Do you compare with the original code or with the previous version of the patch?
Assuming that you compare with the original code: I am using this change in D91624. It allows to avoid
alot of duplication of error handling when iterating over relocations.

Can you elaborate on the claim in the description?

Yeah. I think that API is just totally broken when used for invalid objects. See the description of D91624
about how ELFObjectFile<ELFT>::symbol_end() "works". In the test case for D91624 I've improved one of the messages and
now it provides more details about an error.

One more example:

object::symbol_iterator RelocSym = Reloc.getSymbol();
if (RelocSym != ElfObj.symbol_end()) {

The underlying implementation of Reloc.getSymbol() is:

symbol_iterator
ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const {
  uint32_t symbolIdx;
  const Elf_Shdr *sec = getRelSection(Rel);
  if (sec->sh_type == ELF::SHT_REL)
    symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL());
  else
    symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL());
  if (!symbolIdx)
    return symbol_end();

  // FIXME: error check symbolIdx
  DataRefImpl SymbolData;
  SymbolData.d.a = sec->sh_link;
  SymbolData.d.b = symbolIdx;
  return symbol_iterator(SymbolRef(SymbolData, this));
}

It just doesn't check sec->sh_link or symbolIdx

Another example is that in the ELFObjectFile.h file, the implementation of ELFObjectFile<ELFT> methods
has 5 report_fatal_error calls. They not just doesn't propogate them to user, but also hide real errors behind the
error code messages I think. E.g.:

// Error check sh_link here so that getRelocationSymbol can just use it.
auto SymSecOrErr = EF.getSection(RelSec->sh_link);
if (!SymSecOrErr)
  report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message());

[grimar]

• Restored printRelocationsHelper to avoid forEachRelocationDo duplication.

llvm/tools/llvm-readobj/ELFDumper.cpp

3809

this->printRelocationsHelper(Sec); has been expanded into

this->forEachRelocationDo(
        Sec, opts::RawRelr,
        [&](const Relocation<ELFT> &R, unsigned Ndx, const Elf_Shdr &Sec,
            const Elf_Shdr *SymTab) { printReloc(R, Ndx, Sec, SymTab); },
        [&](const Elf_Relr &R) { printRelrReloc(R); });

If the concern is about duplicating of this call, then it is eaily solvable by introducing
a new method to isolate it. I've added the printRelocationsHelper method back,
it is now incapsulates this forEachRelocationDo call.

llvm/tools/llvm-readobj/ELFDumper.cpp

 
 struct NoteType {
   uint32_t ID;
   StringRef Name;
 };
 
 } // namespace
 
+template <class ELFT> struct RelRelaReloc {
+  uint32_t Type;
+  uint32_t Symbol;
+  typename ELFT::uint Offset;
+  typename ELFT::uint Info;
+  Optional<int64_t> Addend;
+};
+
 template <class ELFT> class Relocation {
 public:
-  Relocation(const typename ELFT::Rel &R, bool IsMips64EL)
-      : Type(R.getType(IsMips64EL)), Symbol(R.getSymbol(IsMips64EL)),
-        Offset(R.r_offset), Info(R.r_info) {}
+  Relocation(const typename ELFT::Rel &R, bool IsMips64EL) {
+    RelRela = {R.getType(IsMips64EL), R.getSymbol(IsMips64EL), R.r_offset,
+               R.r_info, None};
+  }
 
   Relocation(const typename ELFT::Rela &R, bool IsMips64EL)
       : Relocation((const typename ELFT::Rel &)R, IsMips64EL) {
-    Addend = R.r_addend;
+    RelRela->Addend = R.r_addend;
   }
 
-  uint32_t Type;
-  uint32_t Symbol;
-  typename ELFT::uint Offset;
-  typename ELFT::uint Info;
-  Optional<int64_t> Addend;
+  Relocation(const typename ELFT::Relr &R) : Relr(R) {}
+
+  Optional<RelRelaReloc<ELFT>> RelRela;
+  Optional<typename ELFT::Relr> Relr;
 };
 
 template <typename ELFT> class ELFDumper : public ObjDumper {
 public:
   ELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer);
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
public:
   Expected<ArrayRef<Elf_Versym>> getVersionTable(const Elf_Shdr &Sec,
                                                  ArrayRef<Elf_Sym> *SymTab,
                                                  StringRef *StrTab) const;
   Expected<std::vector<VerDef>>
   getVersionDefinitions(const Elf_Shdr &Sec) const;
   Expected<std::vector<VerNeed>>
   getVersionDependencies(const Elf_Shdr &Sec) const;
 
-  Expected<RelSymbol<ELFT>> getRelocationTarget(const Relocation<ELFT> &R,
+  Expected<RelSymbol<ELFT>> getRelocationTarget(const RelRelaReloc<ELFT> &R,
                                                 const Elf_Shdr *SymTab) const;
 
   std::function<Error(const Twine &Msg)> WarningHandler;
   void reportUniqueWarning(Error Err) const;
 };
 
 template <class ELFT>
 static std::string describe(const ELFFile<ELFT> &Obj,

 template <typename ELFT> class DumpStyle {
 public:
   TYPEDEF_ELF_TYPES(ELFT)
 
   DumpStyle(const ELFDumper<ELFT> &Dumper)
       : Obj(*Dumper.getElfObject().getELFFile()), ElfObj(Dumper.getElfObject()),
         Dumper(Dumper) {
     FileName = ElfObj.getFileName();
+
+    PrintRelocFn = [&](const Relocation<ELFT> &R, unsigned Ndx,
+                       const Elf_Shdr &Sec, const Elf_Shdr *SymTab) {
+      if (R.Relr)
+        printRelrReloc(*R.Relr);
+      else
+        printReloc(*R.RelRela, Ndx, Sec, SymTab);
+    };
   }
 
   virtual ~DumpStyle() = default;
 
   virtual void printFileHeaders() = 0;
   virtual void printGroupSections() = 0;
   virtual void printRelocations() = 0;
   virtual void printSectionHeaders() = 0;
public:
   virtual void printMipsABIFlags() = 0;
   const ELFDumper<ELFT> &dumper() const { return Dumper; }
 
 protected:
   void printDependentLibsHelper(
       function_ref<void(const Elf_Shdr &)> OnSectionStart,
       function_ref<void(StringRef, uint64_t)> OnSectionEntry);
 
-  virtual void printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+  virtual void printReloc(const RelRelaReloc<ELFT> &R, unsigned RelIndex,
                           const Elf_Shdr &Sec, const Elf_Shdr *SymTab) = 0;
   virtual void printRelrReloc(const Elf_Relr &R) = 0;
-  virtual void printDynamicReloc(const Relocation<ELFT> &R) = 0;
-  void printRelocationsHelper(const Elf_Shdr &Sec);
+  virtual void printDynamicReloc(const RelRelaReloc<ELFT> &R) = 0;
+  void forEachRelocationDo(
+      const Elf_Shdr &Sec, bool RawRelr,
+      llvm::function_ref<void(const Relocation<ELFT> &, unsigned,
+                              const Elf_Shdr &, const Elf_Shdr *)>
+          Fn);
   void printDynamicRelocationsHelper();
   virtual void printDynamicRelocHeader(unsigned Type, StringRef Name,
                                        const DynRegionInfo &Reg){};
 
   StringRef getPrintableSectionName(const Elf_Shdr &Sec) const;
 
   void reportUniqueWarning(Error Err) const;
 
   StringRef FileName;
   const ELFFile<ELFT> &Obj;
   const ELFObjectFile<ELFT> &ElfObj;
 
+  std::function<void(const Relocation<ELFT> &R, unsigned Ndx,
+                     const Elf_Shdr &Sec, const Elf_Shdr *Symtab)>
+      PrintRelocFn;
+
 private:
   const ELFDumper<ELFT> &Dumper;
 };
 
 template <typename ELFT> class GNUStyle : public DumpStyle<ELFT> {
   formatted_raw_ostream &OS;
 
 public:
formatted_raw_ostream &printField(struct Field F) {
     if (F.Column != 0)
       OS.PadToColumn(F.Column);
     OS << F.Str;
     OS.flush();
     return OS;
   }
   void printHashedSymbol(const Elf_Sym *Sym, unsigned SymIndex,
                          StringRef StrTable, uint32_t Bucket);
-  void printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+  void printReloc(const RelRelaReloc<ELFT> &R, unsigned RelIndex,
                   const Elf_Shdr &Sec, const Elf_Shdr *SymTab) override;
   void printRelrReloc(const Elf_Relr &R) override;
 
-  void printRelRelaReloc(const Relocation<ELFT> &R,
+  void printRelRelaReloc(const RelRelaReloc<ELFT> &R,
                          const RelSymbol<ELFT> &RelSym);
   void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool NonVisibilityBitsUsed) override;
   void printDynamicRelocHeader(unsigned Type, StringRef Name,
                                const DynRegionInfo &Reg) override;
-  void printDynamicReloc(const Relocation<ELFT> &R) override;
+  void printDynamicReloc(const RelRelaReloc<ELFT> &R) override;
 
   std::string getSymbolSectionNdx(const Elf_Sym &Symbol, unsigned SymIndex);
   void printProgramHeaders();
   void printSectionMapping();
   void printGNUVersionSectionProlog(const typename ELFT::Shdr *Sec,
                                     const Twine &Label, unsigned EntriesNum);
 };
 
public:
   void printELFLinkerOptions() override;
   void printStackSizes() override;
   void printStackSizeEntry(uint64_t Size, StringRef FuncName) override;
   void printMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
   void printMipsABIFlags() override;
 
 private:
-  void printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+  void printReloc(const RelRelaReloc<ELFT> &R, unsigned RelIndex,
                   const Elf_Shdr &Sec, const Elf_Shdr *SymTab) override;
   void printRelrReloc(const Elf_Relr &R) override;
-  void printDynamicReloc(const Relocation<ELFT> &R) override;
+  void printDynamicReloc(const RelRelaReloc<ELFT> &R) override;
 
-  void printRelRelaReloc(const Relocation<ELFT> &R, StringRef SymbolName);
+  void printRelRelaReloc(const RelRelaReloc<ELFT> &R, StringRef SymbolName);
   void printSymbols();
   void printDynamicSymbols();
   void printSymbolSection(const Elf_Sym &Symbol, unsigned SymIndex);
   void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool /*NonVisibilityBitsUsed*/) override;
   void printProgramHeaders();
   void printSectionMapping() {}
if (Expected<const Elf_Versym *> EntryOrErr =
           Obj.template getEntry<Elf_Versym>(*SymbolVersionSection, EntryIndex))
     return this->getSymbolVersionByIndex((*EntryOrErr)->vs_index, IsDefault);
   else
     return EntryOrErr.takeError();
 }
 
 template <typename ELFT>
 Expected<RelSymbol<ELFT>>
-ELFDumper<ELFT>::getRelocationTarget(const Relocation<ELFT> &R,
+ELFDumper<ELFT>::getRelocationTarget(const RelRelaReloc<ELFT> &R,
                                      const Elf_Shdr *SymTab) const {
   if (R.Symbol == 0)
     return RelSymbol<ELFT>(nullptr, "");
 
   Expected<const Elf_Sym *> SymOrErr =
       Obj.template getEntry<Elf_Sym>(*SymTab, R.Symbol);
   if (!SymOrErr)
     return SymOrErr.takeError();
for (const GroupSection &G : V) {
     }
   }
 
   if (V.empty())
     OS << "There are no section groups in this file.\n";
 }
 
 template <class ELFT>
-void GNUStyle<ELFT>::printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+void GNUStyle<ELFT>::printReloc(const RelRelaReloc<ELFT> &R, unsigned RelIndex,
                                 const Elf_Shdr &Sec, const Elf_Shdr *SymTab) {
   Expected<RelSymbol<ELFT>> Target =
       this->dumper().getRelocationTarget(R, SymTab);
   if (!Target)
     this->reportUniqueWarning(createError(
         "unable to print relocation " + Twine(RelIndex) + " in " +
         describe(this->Obj, Sec) + ": " + toString(Target.takeError())));
   else
     printRelRelaReloc(R, *Target);
 }
 
 template <class ELFT> void GNUStyle<ELFT>::printRelrReloc(const Elf_Relr &R) {
   OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8)) << "\n";
 }
 
 template <class ELFT>
-void GNUStyle<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R,
+void GNUStyle<ELFT>::printRelRelaReloc(const RelRelaReloc<ELFT> &R,
                                        const RelSymbol<ELFT> &RelSym) {
   // First two fields are bit width dependent. The rest of them are fixed width.
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
   Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias};
   unsigned Width = ELFT::Is64Bits ? 16 : 8;
 
   Fields[0].Str = to_string(format_hex_no_prefix(R.Offset, Width));
   Fields[1].Str = to_string(format_hex_no_prefix(R.Info, Width));
else
           describe(this->Obj, Sec) + ": " + toString(NumOrErr.takeError())));
 
     uintX_t Offset = Sec.sh_offset;
     StringRef Name = this->getPrintableSectionName(Sec);
     OS << "\nRelocation section '" << Name << "' at offset 0x"
        << to_hexString(Offset, false) << " contains " << EntriesNum
        << " entries:\n";
     printRelocHeaderFields<ELFT>(OS, Sec.sh_type);
-    this->printRelocationsHelper(Sec);
+    this->forEachRelocationDo(Sec, opts::RawRelr, this->PrintRelocFn);
   }
   if (!HasRelocSections)
     OS << "\nThere are no relocations in this file.\n";
 }
 
 // Print the offset of a particular section from anyone of the ranges:
 // [SHT_LOOS, SHT_HIOS], [SHT_LOPROC, SHT_HIPROC], [SHT_LOUSER, SHT_HIUSER].
 // If 'Type' does not fall within any of those ranges, then a string is
template <class ELFT> void GNUStyle<ELFT>::printSectionMapping() {
   }
 }
 
 namespace {
 
 template <class ELFT>
 RelSymbol<ELFT> getSymbolForReloc(const ELFFile<ELFT> &Obj, StringRef FileName,
                                   const ELFDumper<ELFT> &Dumper,
-                                  const Relocation<ELFT> &Reloc) {
+                                  const RelRelaReloc<ELFT> &Reloc) {
   using Elf_Sym = typename ELFT::Sym;
   auto WarnAndReturn = [&](const Elf_Sym *Sym,
                            const Twine &Reason) -> RelSymbol<ELFT> {
     reportWarning(
         createError("unable to get name of the dynamic symbol with index " +
                     Twine(Reloc.Symbol) + ": " + Reason),
         FileName);
     return {Sym, "<corrupt>"};
RelSymbol<ELFT> getSymbolForReloc(const ELFFile<ELFT> &Obj, StringRef FileName,
   if (!ErrOrName)
     return WarnAndReturn(Sym, toString(ErrOrName.takeError()));
 
   return {Sym == FirstSym ? nullptr : Sym, maybeDemangle(*ErrOrName)};
 }
 } // namespace
 
 template <class ELFT>
-void GNUStyle<ELFT>::printDynamicReloc(const Relocation<ELFT> &R) {
+void GNUStyle<ELFT>::printDynamicReloc(const RelRelaReloc<ELFT> &R) {
   printRelRelaReloc(
       R, getSymbolForReloc(this->Obj, this->FileName, this->dumper(), R));
 }
 
 template <class ELFT>
 static size_t getMaxDynamicTagSize(const ELFFile<ELFT> &Obj,
                                    typename ELFT::DynRange Tags) {
   size_t Max = 0;

 }
 
 template <class ELFT> void DumpStyle<ELFT>::printDynamicRelocationsHelper() {
   const bool IsMips64EL = this->Obj.isMips64EL();
   const DynRegionInfo &DynRelaRegion = this->dumper().getDynRelaRegion();
   if (DynRelaRegion.Size > 0) {
     printDynamicRelocHeader(ELF::SHT_RELA, "RELA", DynRelaRegion);
     for (const Elf_Rela &Rela : this->dumper().dyn_relas())
-      printDynamicReloc(Relocation<ELFT>(Rela, IsMips64EL));
+      printDynamicReloc(*Relocation<ELFT>(Rela, IsMips64EL).RelRela);
   }
 
   const DynRegionInfo &DynRelRegion = this->dumper().getDynRelRegion();
   if (DynRelRegion.Size > 0) {
     printDynamicRelocHeader(ELF::SHT_REL, "REL", DynRelRegion);
     for (const Elf_Rel &Rel : this->dumper().dyn_rels())
-      printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL));
+      printDynamicReloc(*Relocation<ELFT>(Rel, IsMips64EL).RelRela);
   }
 
   const DynRegionInfo &DynRelrRegion = this->dumper().getDynRelrRegion();
   if (DynRelrRegion.Size > 0) {
     printDynamicRelocHeader(ELF::SHT_REL, "RELR", DynRelrRegion);
     Elf_Relr_Range Relrs = this->dumper().dyn_relrs();
     for (const Elf_Rel &Rel : Obj.decode_relrs(Relrs))
-      printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL));
+      printDynamicReloc(*Relocation<ELFT>(Rel, IsMips64EL).RelRela);
   }
 
   const DynRegionInfo &DynPLTRelRegion = this->dumper().getDynPLTRelRegion();
   if (DynPLTRelRegion.Size) {
     if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) {
       printDynamicRelocHeader(ELF::SHT_RELA, "PLT", DynPLTRelRegion);
       for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
-        printDynamicReloc(Relocation<ELFT>(Rela, IsMips64EL));
+        printDynamicReloc(*Relocation<ELFT>(Rela, IsMips64EL).RelRela);
     } else {
       printDynamicRelocHeader(ELF::SHT_REL, "PLT", DynPLTRelRegion);
       for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>())
-        printDynamicReloc(Relocation<ELFT>(Rel, IsMips64EL));
+        printDynamicReloc(*Relocation<ELFT>(Rel, IsMips64EL).RelRela);
     }
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printGNUVersionSectionProlog(
     const typename ELFT::Shdr *Sec, const Twine &Label, unsigned EntriesNum) {
   StringRef SecName =
for (const uint8_t *I = Contents.begin(), *E = Contents.end(); I < E;) {
       StringRef Lib((const char *)I);
       OnLibEntry(Lib, I - Contents.begin());
       I += Lib.size() + 1;
     }
   }
 }
 
 template <class ELFT>
-void DumpStyle<ELFT>::printRelocationsHelper(const Elf_Shdr &Sec) {
+void DumpStyle<ELFT>::forEachRelocationDo(
+    const Elf_Shdr &Sec, bool RawRelr,
+    llvm::function_ref<void(const Relocation<ELFT> &, unsigned,
+                            const Elf_Shdr &, const Elf_Shdr *)>
+        Fn) {
   auto Warn = [&](Error &&E,
                   const Twine &Prefix = "unable to read relocations from") {
     this->reportUniqueWarning(createError(Prefix + " " + describe(Obj, Sec) +
                                           ": " + toString(std::move(E))));
   };
 
   // SHT_RELR/SHT_ANDROID_RELR sections do not have an associated symbol table.
   // For them we should not treat the value of the sh_link field as an index of
void DumpStyle<ELFT>::forEachRelocationDo(
   }
 
   unsigned RelNdx = 0;
   const bool IsMips64EL = this->Obj.isMips64EL();
   switch (Sec.sh_type) {
   case ELF::SHT_REL:
     if (Expected<Elf_Rel_Range> RangeOrErr = Obj.rels(Sec)) {
       for (const Elf_Rel &R : *RangeOrErr)
-        printReloc(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec, SymTab);
+        Fn(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec, SymTab);
     } else {
       Warn(RangeOrErr.takeError());
     }
     break;
   case ELF::SHT_RELA:
     if (Expected<Elf_Rela_Range> RangeOrErr = Obj.relas(Sec)) {
       for (const Elf_Rela &R : *RangeOrErr)
-        printReloc(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec, SymTab);
+        Fn(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec, SymTab);
     } else {
       Warn(RangeOrErr.takeError());
     }
     break;
   case ELF::SHT_RELR:
   case ELF::SHT_ANDROID_RELR: {
     Expected<Elf_Relr_Range> RangeOrErr = Obj.relrs(Sec);
     if (!RangeOrErr) {
       Warn(RangeOrErr.takeError());
       break;
     }
-    if (opts::RawRelr) {
+    if (RawRelr) {
       for (const Elf_Relr &R : *RangeOrErr)
-        printRelrReloc(R);
+        Fn(R, ++RelNdx, Sec, /*SymTab=*/nullptr);
       break;
     }
 
     for (const Elf_Rel &R : Obj.decode_relrs(*RangeOrErr))
-      printReloc(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec,
-                 /*SymTab=*/nullptr);
+      Fn(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec,
     break;
   }
   case ELF::SHT_ANDROID_REL:
   case ELF::SHT_ANDROID_RELA:
     if (Expected<std::vector<Elf_Rela>> RelasOrErr = Obj.android_relas(Sec)) {
       for (const Elf_Rela &R : *RelasOrErr)
-        printReloc(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec, SymTab);
+        Fn(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec, SymTab);
     } else {
       Warn(RelasOrErr.takeError());
     }
     break;
   }
 }
 
 template <class ELFT>
template <class ELFT> void LLVMStyle<ELFT>::printRelocations() {
   for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
     if (!isRelocationSec<ELFT>(Sec))
       continue;
 
     StringRef Name = this->getPrintableSectionName(Sec);
     unsigned SecNdx = &Sec - &cantFail(this->Obj.sections()).front();
     W.startLine() << "Section (" << SecNdx << ") " << Name << " {\n";
     W.indent();
-    this->printRelocationsHelper(Sec);
+    this->forEachRelocationDo(Sec, opts::RawRelr, this->PrintRelocFn);
     W.unindent();
     W.startLine() << "}\n";
   }
 }
 
 template <class ELFT> void LLVMStyle<ELFT>::printRelrReloc(const Elf_Relr &R) {
   W.startLine() << W.hex(R) << "\n";
 }
 
 template <class ELFT>
-void LLVMStyle<ELFT>::printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+void LLVMStyle<ELFT>::printReloc(const RelRelaReloc<ELFT> &R, unsigned RelIndex,
                                  const Elf_Shdr &Sec, const Elf_Shdr *SymTab) {
   Expected<RelSymbol<ELFT>> Target =
       this->dumper().getRelocationTarget(R, SymTab);
   if (!Target) {
     this->reportUniqueWarning(createError(
         "unable to print relocation " + Twine(RelIndex) + " in " +
         describe(this->Obj, Sec) + ": " + toString(Target.takeError())));
     return;
   }
 
   printRelRelaReloc(R, Target->Name);
 }
 
 template <class ELFT>
-void LLVMStyle<ELFT>::printRelRelaReloc(const Relocation<ELFT> &R,
+void LLVMStyle<ELFT>::printRelRelaReloc(const RelRelaReloc<ELFT> &R,
                                         StringRef SymbolName) {
   SmallString<32> RelocName;
   this->Obj.getRelocationTypeName(R.Type, RelocName);
 
   uintX_t Addend = R.Addend.getValueOr(0);
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", R.Offset);
for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
     W.printNumber("Size", Sec.sh_size);
     W.printNumber("Link", Sec.sh_link);
     W.printNumber("Info", Sec.sh_info);
     W.printNumber("AddressAlignment", Sec.sh_addralign);
     W.printNumber("EntrySize", Sec.sh_entsize);
 
     if (opts::SectionRelocations) {
       ListScope D(W, "Relocations");
-      this->printRelocationsHelper(Sec);
+      this->forEachRelocationDo(Sec, opts::RawRelr, this->PrintRelocFn);
     }
 
     if (opts::SectionSymbols) {
       ListScope D(W, "Symbols");
       if (const Elf_Shdr *Symtab = this->dumper().getDotSymtabSec()) {
         StringRef StrTable = unwrapOrError(
             this->FileName, this->Obj.getStringTableForSymtab(*Symtab));
 
template <class ELFT> void LLVMStyle<ELFT>::printDynamicRelocations() {
   W.startLine() << "Dynamic Relocations {\n";
   W.indent();
   this->printDynamicRelocationsHelper();
   W.unindent();
   W.startLine() << "}\n";
 }
 
 template <class ELFT>
-void LLVMStyle<ELFT>::printDynamicReloc(const Relocation<ELFT> &R) {
+void LLVMStyle<ELFT>::printDynamicReloc(const RelRelaReloc<ELFT> &R) {
   RelSymbol<ELFT> S =
       getSymbolForReloc(this->Obj, this->FileName, this->dumper(), R);
   printRelRelaReloc(R, S.Name);
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printProgramHeaders(
     bool PrintProgramHeaders, cl::boolOrDefault PrintSectionMapping) {