Index: llvm/tools/llvm-readobj/ELFDumper.cpp
===================================================================
--- llvm/tools/llvm-readobj/ELFDumper.cpp
+++ llvm/tools/llvm-readobj/ELFDumper.cpp
@@ -205,6 +205,22 @@
 
 } // 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);
@@ -370,9 +386,8 @@
   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;
@@ -754,10 +769,8 @@
       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);
 
@@ -870,23 +883,18 @@
   }
   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,
@@ -938,15 +946,11 @@
   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();
@@ -1058,12 +1062,12 @@
 }
 
 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;
@@ -3607,30 +3611,10 @@
 }
 
 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 " +
@@ -3639,30 +3623,25 @@
     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)
@@ -3674,7 +3653,7 @@
     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) {
@@ -4357,11 +4336,11 @@
 
 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(
@@ -4395,8 +4374,7 @@
 } // 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));
 }
@@ -4452,30 +4430,30 @@
     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));
     }
   }
 }
@@ -5475,7 +5453,7 @@
   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());
     }
@@ -5483,7 +5461,7 @@
   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());
     }
@@ -5502,14 +5480,14 @@
     }
 
     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());
     }
@@ -6148,31 +6126,15 @@
   }
 }
 
-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 " +
@@ -6180,12 +6142,13 @@
     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);
@@ -6388,39 +6351,39 @@
   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);