[llvm-readobj/elf] - Introduce Relocation<ELFT> helper.

[grimar]

Summary

It removes templating for Elf_Rel[a] handling that we
introduced earlier and introduces a helper class instead.

It was briefly discussed in D87087, which showed,
why having templates is probably not ideal for the generalization
of dumpers code.

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

217

I'd rather avoid this, for reasons which I think were previously discussed when you first tried something like this - it essentially lies about the underlying relocation type. Furthermore, I don't think it is necessary - you can store the relocation's properties in the class itself, derived at construction time when you already have a "real" relocation. In other words, your members might become something like this:

uint64_t Offset;
Optional<int64_t> Addend;
uint32_t SymIndex;
uint32_t Type;

You might need the odd new function elsewhere, to replace where you do things like getRelocationSymbol, to take an index, but I don't think any of them will be that complex.

[grimar]

• Addressed review comment.

llvm/tools/llvm-readobj/ELFDumper.cpp

217

Done.

[jhenderson]

LGTM, thanks for the work.

llvm/tools/llvm-readobj/ELFDumper.cpp

215

Registering that I am not particularly keen on casting from Rela -> Rel like this (a person in the future could decide to change the Rel constructor to do something with the assumption that it really is always an Elf_Rel here). I don't have any great alternative currently though, without duplicating logic, so am not asking this to change.

llvm/tools/llvm-readobj/ELFDumper.cpp

struct VerNeed {
   unsigned Cnt;
   unsigned Offset;
   std::string File;
   std::vector<VernAux> AuxV;
 };
 
 } // namespace
 
+template <class ELFT> class Relocation {
+public:
+  using Elf_Rel = typename ELFT::Rel;
+  using Elf_Rela = typename ELFT::Rela;
+
+  Relocation(const Elf_Rel &R) : Reloc(R) {}
+  Relocation(const Elf_Rela &R) : Reloc(R), Addend(R.r_addend) {}
+
+  Optional<int64_t> getAddend() const { return Addend; }
+  const Elf_Rel &getRel() const { return Reloc; }
+
+private:
+  const Elf_Rel &Reloc;
+  Optional<int64_t> Addend;
+};
+
 template <typename ELFT> class ELFDumper : public ObjDumper {
 public:
   ELFDumper(const object::ELFObjectFile<ELFT> *ObjF, ScopedPrinter &Writer);
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
   void printDependentLibs() 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;
 
-  template <class RelTy>
-  Expected<RelSymbol<ELFT>> getRelocationTarget(const Elf_Shdr *SymTab,
-                                                const RelTy &R) const;
+  Expected<RelSymbol<ELFT>> getRelocationTarget(const Relocation<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,
                             const typename ELFT::Shdr &Sec) {
public:
   virtual void printMipsABIFlags(const ELFObjectFile<ELFT> *Obj) = 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 printRelReloc(const Elf_Rel &R, unsigned RelIndex,
-                             const Elf_Shdr *Sec, const Elf_Shdr *SymTab) = 0;
-  virtual void printRelaReloc(const Elf_Rela &R, unsigned RelIndex,
-                              const Elf_Shdr *Sec, const Elf_Shdr *SymTab) = 0;
+  virtual void printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+                          const Elf_Shdr &Sec, const Elf_Shdr *SymTab) = 0;
   virtual void printRelrReloc(const Elf_Relr &R) = 0;
   void printRelocationsHelper(const Elf_Shdr &Sec);
 
   StringRef getPrintableSectionName(const Elf_Shdr &Sec) const;
 
   void reportUniqueWarning(Error Err) const;
 
   StringRef FileName;
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 *FirstSym, uint32_t Sym,
                          StringRef StrTable, uint32_t Bucket);
-  void printRelReloc(const Elf_Rel &R, unsigned RelIndex, const Elf_Shdr *Sec,
-                     const Elf_Shdr *SymTab) override;
-  void printRelaReloc(const Elf_Rela &R, unsigned RelIndex, const Elf_Shdr *Sec,
-                      const Elf_Shdr *SymTab) override;
+  void printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+                  const Elf_Shdr &Sec, const Elf_Shdr *SymTab) override;
   void printRelrReloc(const Elf_Relr &R) override;
 
-  template <class RelTy>
-  void printRelRelaReloc(const RelTy &R, unsigned RelIndex, const Elf_Shdr &Sec,
-                         const Elf_Shdr *SymTab);
-  template <class RelTy>
-  void printRelRelaReloc(const RelTy &R, const RelSymbol<ELFT> &RelSym);
+  void printRelRelaReloc(const Relocation<ELFT> &R,
+                         const RelSymbol<ELFT> &RelSym);
   void printSymbol(const Elf_Sym *Symbol, const Elf_Sym *First,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool NonVisibilityBitsUsed) override;
   std::string getSymbolSectionNdx(const Elf_Sym *Symbol,
                                   const Elf_Sym *FirstSym);
-  template <class RelTy> void printDynamicRelocation(const RelTy &R);
+  void printDynamicRelocation(const Relocation<ELFT> &R);
   void printProgramHeaders();
   void printSectionMapping();
   void printGNUVersionSectionProlog(const typename ELFT::Shdr *Sec,
                                     const Twine &Label, unsigned EntriesNum);
 };
 
 template <class ELFT>
 void ELFDumper<ELFT>::reportUniqueWarning(Error Err) const {
public:
   void printELFLinkerOptions() override;
   void printStackSizes(const ELFObjectFile<ELFT> *Obj) 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(const ELFObjectFile<ELFT> *Obj) override;
 
 private:
-  void printRelReloc(const Elf_Rel &R, unsigned RelIndex, const Elf_Shdr *Sec,
-                     const Elf_Shdr *SymTab) override;
-  void printRelaReloc(const Elf_Rela &R, unsigned RelIndex, const Elf_Shdr *Sec,
-                      const Elf_Shdr *SymTab) override;
+  void printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+                  const Elf_Shdr &Sec, const Elf_Shdr *SymTab) override;
   void printRelrReloc(const Elf_Relr &R) override;
-  template <class RelTy>
-  void printRelRelaReloc(const RelTy &R, unsigned RelIndex, const Elf_Shdr &Sec,
-                         const Elf_Shdr *SymTab);
-  template <class RelTy> void printDynamicRelocation(const RelTy &Rel);
+
+  void printDynamicRelocation(const Relocation<ELFT> &R);
 
   void printSymbols();
   void printDynamicSymbols();
   void printSymbolSection(const Elf_Sym *Symbol, const Elf_Sym *First);
   void printSymbol(const Elf_Sym *Symbol, const Elf_Sym *First,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool /*NonVisibilityBitsUsed*/) override;
   void printProgramHeaders();
if (Expected<const Elf_Versym *> EntryOrErr =
           ObjF->getELFFile()->template getEntry<Elf_Versym>(
               SymbolVersionSection, EntryIndex))
     return this->getSymbolVersionByIndex((*EntryOrErr)->vs_index, IsDefault);
   else
     return EntryOrErr.takeError();
 }
 
 template <typename ELFT>
-template <class RelTy>
 Expected<RelSymbol<ELFT>>
-ELFDumper<ELFT>::getRelocationTarget(const Elf_Shdr *SymTab,
-                                     const RelTy &R) const {
+ELFDumper<ELFT>::getRelocationTarget(const Relocation<ELFT> &R,
+                                     const Elf_Shdr *SymTab) const {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
-  Expected<const Elf_Sym *> SymOrErr = Obj->getRelocationSymbol(&R, SymTab);
+  Expected<const Elf_Sym *> SymOrErr =
+      Obj->getRelocationSymbol(&R.getRel(), SymTab);
   if (!SymOrErr)
     return SymOrErr.takeError();
   const Elf_Sym *Sym = *SymOrErr;
   if (!Sym)
     return RelSymbol<ELFT>(nullptr, "");
 
   // The st_name field of a STT_SECTION is usually 0 (empty string).
   // This code block returns the section name.
for (const GroupSection &G : V) {
     }
   }
 
   if (V.empty())
     OS << "There are no section groups in this file.\n";
 }
 
 template <class ELFT>
-void GNUStyle<ELFT>::printRelReloc(const Elf_Rel &R, unsigned RelIndex,
-                                   const Elf_Shdr *Sec,
-                                   const Elf_Shdr *SymTab) {
-  printRelRelaReloc(R, RelIndex, *Sec, SymTab);
-}
-
-template <class ELFT>
-void GNUStyle<ELFT>::printRelaReloc(const Elf_Rela &R, unsigned RelIndex,
-                                    const Elf_Shdr *Sec,
-                                    const Elf_Shdr *SymTab) {
-  printRelRelaReloc(R, RelIndex, *Sec, SymTab);
-}
-
-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>
-template <class RelTy>
-void GNUStyle<ELFT>::printRelRelaReloc(const RelTy &R, unsigned RelIndex,
-                                       const Elf_Shdr &Sec,
-                                       const Elf_Shdr *SymTab) {
+void GNUStyle<ELFT>::printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+                                const Elf_Shdr &Sec, const Elf_Shdr *SymTab) {
   Expected<RelSymbol<ELFT>> Target =
-      this->dumper()->getRelocationTarget(SymTab, R);
+      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>
-static Optional<int64_t> getAddend(const typename ELFT::Rela &R) {
-  return (int64_t)R.r_addend;
-}
-
-template <class ELFT>
-static Optional<int64_t> getAddend(const typename ELFT::Rel &) {
-  return None;
+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>
-template <class RelTy>
-void GNUStyle<ELFT>::printRelRelaReloc(const RelTy &R,
+void GNUStyle<ELFT>::printRelRelaReloc(const Relocation<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.r_offset, Width));
-  Fields[1].Str = to_string(format_hex_no_prefix(R.r_info, Width));
+  const Elf_Rel &Rel = R.getRel();
+  Fields[0].Str = to_string(format_hex_no_prefix(Rel.r_offset, Width));
+  Fields[1].Str = to_string(format_hex_no_prefix(Rel.r_info, Width));
 
   SmallString<32> RelocName;
-  this->Obj.getRelocationTypeName(R.getType(this->Obj.isMips64EL()), RelocName);
+  this->Obj.getRelocationTypeName(Rel.getType(this->Obj.isMips64EL()),
+                                  RelocName);
   Fields[2].Str = RelocName.c_str();
 
   if (RelSym.Sym)
     Fields[3].Str =
         to_string(format_hex_no_prefix(RelSym.Sym->getValue(), Width));
 
   Fields[4].Str = std::string(RelSym.Name);
   for (const Field &F : Fields)
     printField(F);
 
   std::string Addend;
-  if (Optional<int64_t> A = getAddend<ELFT>(R)) {
+  if (Optional<int64_t> A = R.getAddend()) {
     int64_t RelAddend = *A;
     if (!RelSym.Name.empty()) {
       if (RelAddend < 0) {
         Addend = " - ";
         RelAddend = std::abs(RelAddend);
       } else {
         Addend = " + ";
       }
template <class ELFT> void GNUStyle<ELFT>::printSectionMapping() {
   if (!Sections.empty()) {
     OS << "   None  " << Sections << '\n';
     OS.flush();
   }
 }
 
 namespace {
 
-template <class ELFT, class RelTy>
+template <class ELFT>
 RelSymbol<ELFT> getSymbolForReloc(const ELFFile<ELFT> &Obj, StringRef FileName,
                                   const ELFDumper<ELFT> *Dumper,
-                                  const RelTy &Reloc) {
-  uint32_t SymIndex = Reloc.getSymbol(Obj.isMips64EL());
+                                  const Relocation<ELFT> &Reloc) {
+  uint32_t SymIndex = Reloc.getRel().getSymbol(Obj.isMips64EL());
   auto WarnAndReturn = [&](const typename ELFT::Sym *Sym,
                            const Twine &Reason) -> RelSymbol<ELFT> {
     reportWarning(
         createError("unable to get name of the dynamic symbol with index " +
                     Twine(SymIndex) + ": " + 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>
-template <class RelTy>
-void GNUStyle<ELFT>::printDynamicRelocation(const RelTy &R) {
+void GNUStyle<ELFT>::printDynamicRelocation(const Relocation<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 GNUStyle<ELFT>::printDynamicRelocations() {
   const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion();
   const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion();
   const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion();
   const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion();
   if (DynRelaRegion.Size > 0) {
     printDynamicRelocHeader(this->Obj, OS, ELF::SHT_RELA, "RELA",
                             DynRelaRegion);
     for (const Elf_Rela &Rela : this->dumper()->dyn_relas())
-      printDynamicRelocation(Rela);
+      printDynamicRelocation(Relocation<ELFT>(Rela));
   }
   if (DynRelRegion.Size > 0) {
     printDynamicRelocHeader(this->Obj, OS, ELF::SHT_REL, "REL", DynRelRegion);
     for (const Elf_Rel &Rel : this->dumper()->dyn_rels())
-      printDynamicRelocation(Rel);
+      printDynamicRelocation(Relocation<ELFT>(Rel));
   }
   if (DynRelrRegion.Size > 0) {
     printDynamicRelocHeader(this->Obj, OS, ELF::SHT_REL, "RELR", DynRelrRegion);
     Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
     for (const Elf_Rel &R : this->Obj.decode_relrs(Relrs))
-      printDynamicRelocation(R);
+      printDynamicRelocation(Relocation<ELFT>(R));
   }
   if (DynPLTRelRegion.Size) {
     if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) {
       printDynamicRelocHeader(this->Obj, OS, ELF::SHT_RELA, "PLT",
                               DynPLTRelRegion);
       for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
-        printDynamicRelocation(Rela);
+        printDynamicRelocation(Relocation<ELFT>(Rela));
     } else {
       printDynamicRelocHeader(this->Obj, OS, ELF::SHT_REL, "PLT",
                               DynPLTRelRegion);
       for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>())
-        printDynamicRelocation(Rel);
+        printDynamicRelocation(Relocation<ELFT>(Rel));
     }
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printGNUVersionSectionProlog(
     const typename ELFT::Shdr *Sec, const Twine &Label, unsigned EntriesNum) {
   StringRef SecName =
if (Sec.sh_type != ELF::SHT_RELR && Sec.sh_type != ELF::SHT_ANDROID_RELR) {
     SymTab = *SymTabOrErr;
   }
 
   unsigned RelNdx = 0;
   switch (Sec.sh_type) {
   case ELF::SHT_REL:
     if (Expected<Elf_Rel_Range> RangeOrErr = Obj.rels(&Sec)) {
       for (const Elf_Rel &R : *RangeOrErr)
-        printRelReloc(R, ++RelNdx, &Sec, SymTab);
+        printReloc(Relocation<ELFT>(R), ++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)
-        printRelaReloc(R, ++RelNdx, &Sec, SymTab);
+        printReloc(Relocation<ELFT>(R), ++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) {
       for (const Elf_Relr &R : *RangeOrErr)
         printRelrReloc(R);
       break;
     }
 
     for (const Elf_Rel &R : Obj.decode_relrs(*RangeOrErr))
-      printRelReloc(R, ++RelNdx, &Sec, /*SymTab=*/nullptr);
+      printReloc(Relocation<ELFT>(R), ++RelNdx, Sec, /*SymTab=*/nullptr);
     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)
-        printRelaReloc(R, ++RelNdx, &Sec, SymTab);
+        printReloc(Relocation<ELFT>(R), ++RelNdx, Sec, SymTab);
     } else {
       Warn(RelasOrErr.takeError());
     }
     break;
   }
 }
 
 template <class ELFT>
for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
     W.startLine() << "Section (" << SecNdx << ") " << Name << " {\n";
     W.indent();
     this->printRelocationsHelper(Sec);
     W.unindent();
     W.startLine() << "}\n";
   }
 }
 
-template <class ELFT>
-void LLVMStyle<ELFT>::printRelReloc(const Elf_Rel &R, unsigned RelIndex,
-                                    const Elf_Shdr *Sec,
-                                    const Elf_Shdr *SymTab) {
-  printRelRelaReloc(R, RelIndex, *Sec, SymTab);
-}
-
-template <class ELFT>
-void LLVMStyle<ELFT>::printRelaReloc(const Elf_Rela &R, unsigned RelIndex,
-                                     const Elf_Shdr *Sec,
-                                     const Elf_Shdr *SymTab) {
-  printRelRelaReloc(R, RelIndex, *Sec, SymTab);
-}
-
 template <class ELFT> void LLVMStyle<ELFT>::printRelrReloc(const Elf_Relr &R) {
   W.startLine() << W.hex(R) << "\n";
 }
 
 template <class ELFT>
-template <class RelTy>
-void LLVMStyle<ELFT>::printRelRelaReloc(const RelTy &Rel, unsigned RelIndex,
-                                        const Elf_Shdr &Sec,
-                                        const Elf_Shdr *SymTab) {
+void LLVMStyle<ELFT>::printReloc(const Relocation<ELFT> &R, unsigned RelIndex,
+                                 const Elf_Shdr &Sec, const Elf_Shdr *SymTab) {
   Expected<RelSymbol<ELFT>> Target =
-      this->dumper()->getRelocationTarget(SymTab, Rel);
+      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;
   }
 
+  const Elf_Rel& Rel = R.getRel();
   std::string TargetName = Target->Name;
   SmallString<32> RelocName;
   this->Obj.getRelocationTypeName(Rel.getType(this->Obj.isMips64EL()),
                                   RelocName);
 
-  uintX_t Addend = getAddend<ELFT>(Rel).getValueOr(0);
+  uintX_t Addend = R.getAddend().getValueOr(0);
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Rel.r_offset);
     W.printNumber("Type", RelocName, (int)Rel.getType(this->Obj.isMips64EL()));
     W.printNumber("Symbol", !TargetName.empty() ? TargetName : "-",
                   Rel.getSymbol(this->Obj.isMips64EL()));
     W.printHex("Addend", Addend);
   } else {
template <class ELFT> void LLVMStyle<ELFT>::printDynamicRelocations() {
   const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion();
   const DynRegionInfo &DynRelrRegion = this->dumper()->getDynRelrRegion();
   const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion();
 
   W.startLine() << "Dynamic Relocations {\n";
   W.indent();
   if (DynRelaRegion.Size > 0) {
     for (const Elf_Rela &Rela : this->dumper()->dyn_relas())
-      printDynamicRelocation(Rela);
+      printDynamicRelocation(Relocation<ELFT>(Rela));
   }
   if (DynRelRegion.Size > 0) {
     for (const Elf_Rel &Rel : this->dumper()->dyn_rels())
-      printDynamicRelocation(Rel);
+      printDynamicRelocation(Relocation<ELFT>(Rel));
   }
 
   if (DynRelrRegion.Size > 0) {
     Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
-    for (const Elf_Rel &R : this->Obj.decode_relrs(Relrs))
-      printDynamicRelocation(R);
+    for (const Elf_Rel &Rel : this->Obj.decode_relrs(Relrs))
+      printDynamicRelocation(Relocation<ELFT>(Rel));
   }
   if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela))
     for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
-      printDynamicRelocation(Rela);
+      printDynamicRelocation(Relocation<ELFT>(Rela));
   else
     for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>())
-      printDynamicRelocation(Rel);
+      printDynamicRelocation(Relocation<ELFT>(Rel));
 
   W.unindent();
   W.startLine() << "}\n";
 }
 
 template <class ELFT>
-template <class RelTy>
-void LLVMStyle<ELFT>::printDynamicRelocation(const RelTy &Rel) {
+void LLVMStyle<ELFT>::printDynamicRelocation(const Relocation<ELFT> &R) {
+  const Elf_Rel& Rel = R.getRel();
   SmallString<32> RelocName;
   this->Obj.getRelocationTypeName(Rel.getType(this->Obj.isMips64EL()),
                                   RelocName);
   std::string SymbolName =
-      getSymbolForReloc(this->Obj, this->FileName, this->dumper(), Rel).Name;
+      getSymbolForReloc(this->Obj, this->FileName, this->dumper(), R).Name;
 
-  uintX_t Addend = getAddend<ELFT>(Rel).getValueOr(0);
+  uintX_t Addend = R.getAddend().getValueOr(0);
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Rel.r_offset);
     W.printNumber("Type", RelocName, (int)Rel.getType(this->Obj.isMips64EL()));
     W.printString("Symbol", !SymbolName.empty() ? SymbolName : "-");
     W.printHex("Addend", Addend);
   } else {
     raw_ostream &OS = W.startLine();