[llvm-readelf/readobj] - Detemplate printRelRelaReloc() methods.

[grimar]

Summary

Methods became templated in D83871.

D83935 tries to move out the common code and I had to introduce
2 more virtual methods: printRelReloc and printRelReloc to call
the templated printRelRelaReloc from the base class,
where the common code lives.

This patch shows that we can call printRelRelaReloc directly from the
base class after making it virtual and detemplating it.

The benefit is that the code becomes shorter. But instead of having just
Elf_Rel/Elf_Rela argument, we will have two: const Elf_Rel &R, Optional<int64_t> Addend

Should we do it?

[jhenderson]

I'm no more a fan of using Elf_Rel for Elf_Rela relocations than I was of using Elf_Rela for Elf_Rel, even with the extra Addend argment. I think if we are to go down this road, I'd split it up into its component parts in the first instance, but that might become too many arguments.

llvm/tools/llvm-readobj/ELFDumper.cpp

6448

I think /*Addend=*/None is the preferred style. Same below.

[grimar]

OK. I do not have any strong feelings about this. Abandoning.

llvm/tools/llvm-readobj/ELFDumper.cpp

public:
   const ELFDumper<ELFT> *dumper() const { return Dumper; }
 
 protected:
   void printDependentLibsHelper(
       const ELFFile<ELFT> *Obj,
       function_ref<void(const Elf_Shdr &)> OnSectionStart,
       function_ref<void(StringRef, uint64_t)> OnSectionEntry);
 
-  virtual void printRelReloc(const ELFO *Obj, unsigned SecIndex,
+  virtual void printRelrReloc(const Elf_Relr &R) = 0;
+  virtual void printRelRelaReloc(const ELFO *Obj, unsigned SecIndex,
                                  const Elf_Shdr *SymTab, const Elf_Rel &R,
+                                 Optional<int64_t> Addend,
                                  unsigned RelIndex) = 0;
-  virtual void printRelaReloc(const ELFO *Obj, unsigned SecIndex,
-                              const Elf_Shdr *SymTab, const Elf_Rela &R,
-                              unsigned RelIndex) = 0;
-  virtual void printRelrReloc(const Elf_Relr &R) = 0;
   void printRelocationsHelper(const ELFFile<ELFT> *Obj, const Elf_Shdr &Sec);
 
   void reportUniqueWarning(Error Err) const;
   StringRef FileName;
 
 private:
   const ELFDumper<ELFT> *Dumper;
 };
formatted_raw_ostream &printField(struct Field F) {
     OS << F.Str;
     OS.flush();
     return OS;
   }
   void printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym, uint32_t Sym,
                          StringRef StrTable, uint32_t Bucket);
   void printRelocHeader(unsigned SType);
 
-  void printRelReloc(const ELFO *Obj, unsigned SecIndex, const Elf_Shdr *SymTab,
-                     const Elf_Rel &R, unsigned RelIndex) override;
-  void printRelaReloc(const ELFO *Obj, unsigned SecIndex,
-                      const Elf_Shdr *SymTab, const Elf_Rela &R,
-                      unsigned RelIndex) override;
   void printRelrReloc(const Elf_Relr &R) override;
-
-  template <class RelTy>
   void printRelRelaReloc(const ELFO *Obj, unsigned SecIndex,
-                         const Elf_Shdr *SymTab, const RelTy &R,
-                         unsigned RelIndex);
-  template <class RelTy>
+                         const Elf_Shdr *SymTab, const Elf_Rel &R,
+                         Optional<int64_t> Addend, unsigned RelIndex) override;
+
   void printRelRelaReloc(const ELFO *Obj, const Elf_Sym *Sym,
-                         StringRef SymbolName, const RelTy &R);
+                         StringRef SymbolName, const Elf_Rel &R,
+                         Optional<int64_t> Addend);
   void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool NonVisibilityBitsUsed) override;
   std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol,
                                   const Elf_Sym *FirstSym);
-  template <class RelTy>
-  void printDynamicRelocation(const ELFO *Obj, const RelTy &R);
+  void printDynamicRelocation(const ELFO *Obj, const Elf_Rel &R,
+                              Optional<int64_t> Addend);
   void printProgramHeaders(const ELFO *Obj);
   void printSectionMapping(const ELFO *Obj);
   void printGNUVersionSectionProlog(const ELFFile<ELFT> *Obj,
                                     const typename ELFT::Shdr *Sec,
                                     const Twine &Label, unsigned EntriesNum);
 };
 
 template <class ELFT>
public:
   void printELFLinkerOptions(const ELFFile<ELFT> *Obj) 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 ELFO *Obj, unsigned SecIndex, const Elf_Shdr *SymTab,
-                     const Elf_Rel &R, unsigned RelIndex) override;
-  void printRelaReloc(const ELFO *Obj, unsigned SecIndex,
-                      const Elf_Shdr *SymTab, const Elf_Rela &R,
-                      unsigned RelIndex) override;
   void printRelrReloc(const Elf_Relr &R) override;
-  template <class RelTy>
-  void printRelRelaReloc(const ELFO *Obj, unsigned SecIndex, const RelTy &Rel,
-                         unsigned RelIndex, const Elf_Shdr *SymTab);
-  template <class RelTy>
-  void printDynamicRelocation(const ELFO *Obj, const RelTy& Rel);
+  void printRelRelaReloc(const ELFO *Obj, unsigned SecIndex,
+                         const Elf_Shdr *SymTab, const Elf_Rel &R,
+                         Optional<int64_t> Addend, unsigned RelIndex) override;
+  void printDynamicRelocation(const ELFO *Obj, const Elf_Rel &R,
+                              Optional<int64_t> Addend);
 
   void printSymbols(const ELFO *Obj);
   void printDynamicSymbols(const ELFO *Obj);
   void printSymbolSection(const Elf_Sym *Symbol, const Elf_Sym *First);
   void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
                    Optional<StringRef> StrTable, bool IsDynamic,
                    bool /*NonVisibilityBitsUsed*/) override;
   void printProgramHeaders(const ELFO *Obj);
for (const GroupMember &GM : G.Members) {
       OS << "   [" << format_decimal(GM.Index, 5) << "]   " << GM.Name << "\n";
     }
   }
 
   if (V.empty())
     OS << "There are no section groups in this file.\n";
 }
 
-template <class ELFT>
-void GNUStyle<ELFT>::printRelReloc(const ELFO *Obj, unsigned SecIndex,
-                                   const Elf_Shdr *SymTab, const Elf_Rel &R,
-                                   unsigned RelIndex) {
-  printRelRelaReloc(Obj, SecIndex, SymTab, R, RelIndex);
-}
-
-template <class ELFT>
-void GNUStyle<ELFT>::printRelaReloc(const ELFO *Obj, unsigned SecIndex,
-                                    const Elf_Shdr *SymTab, const Elf_Rela &R,
-                                    unsigned RelIndex) {
-  printRelRelaReloc(Obj, SecIndex, SymTab, R, RelIndex);
-}
-
 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 ELFO *Obj, unsigned SecIndex,
-                                       const Elf_Shdr *SymTab, const RelTy &R,
+                                       const Elf_Shdr *SymTab, const Elf_Rel &R,
+                                       Optional<int64_t> Addend,
                                        unsigned RelIndex) {
   Expected<std::pair<const typename ELFT::Sym *, std::string>> Target =
       this->dumper()->getRelocationTarget(SymTab, R);
   if (!Target)
     this->reportUniqueWarning(createError(
         "unable to print relocation " + Twine(RelIndex) + " in section " +
         Twine(SecIndex) + ": " + toString(Target.takeError())));
   else
-    printRelRelaReloc(Obj, /*Sym=*/Target->first, /*Name=*/Target->second, R);
-}
-
-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;
+    printRelRelaReloc(Obj, /*Sym=*/Target->first, /*Name=*/Target->second, R,
+                      Addend);
 }
 
 template <class ELFT>
-template <class RelTy>
 void GNUStyle<ELFT>::printRelRelaReloc(const ELFO *Obj, const Elf_Sym *Sym,
-                                       StringRef SymbolName, const RelTy &R) {
+                                       StringRef SymbolName, const Elf_Rel &R,
+                                       Optional<int64_t> Addend) {
   // 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));
 
   SmallString<32> RelocName;
   Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName);
   Fields[2].Str = RelocName.c_str();
 
   if (Sym)
     Fields[3].Str = to_string(format_hex_no_prefix(Sym->getValue(), Width));
 
   Fields[4].Str = std::string(SymbolName);
   for (const Field &F : Fields)
     printField(F);
 
-  std::string Addend;
-  if (Optional<int64_t> A = getAddend<ELFT>(R)) {
-    int64_t RelAddend = *A;
+  std::string A;
+  if (Addend) {
+    int64_t RelAddend = *Addend;
     if (!SymbolName.empty()) {
       if (RelAddend < 0) {
-        Addend = " - ";
+        A = " - ";
         RelAddend = std::abs(RelAddend);
       } else {
-        Addend = " + ";
+        A = " + ";
       }
     }
-    Addend += to_hexString(RelAddend, false);
+    A += to_hexString(RelAddend, false);
   }
-  OS << Addend << "\n";
+  OS << A << "\n";
 }
 
 template <class ELFT> void GNUStyle<ELFT>::printRelocHeader(unsigned SType) {
   bool IsRela = SType == ELF::SHT_RELA || SType == ELF::SHT_ANDROID_RELA;
   bool IsRelr = SType == ELF::SHT_RELR || SType == ELF::SHT_ANDROID_RELR;
   if (ELFT::Is64Bits)
     OS << "    ";
   else
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 ELFO *Obj, const RelTy &R) {
-  RelSymbol<ELFT> S = getSymbolForReloc(Obj, this->FileName, this->dumper(), R);
-  printRelRelaReloc(Obj, S.Sym, S.Name, R);
+void GNUStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, const Elf_Rel &R,
+                                            Optional<int64_t> Addend) {
+  RelSymbol<ELFT> S =
+      getSymbolForReloc<ELFT>(Obj, this->FileName, this->dumper(), R);
+  printRelRelaReloc(Obj, S.Sym, S.Name, R, Addend);
 }
 
 template <class ELFT>
 static size_t getMaxDynamicTagSize(const ELFFile<ELFT> *Obj,
                                    typename ELFT::DynRange Tags) {
   size_t Max = 0;
   for (const typename ELFT::Dyn &Dyn : Tags)
     Max = std::max(Max, Obj->getDynamicTagAsString(Dyn.d_tag).size());
void GNUStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
   if (DynRelaRegion.Size > 0) {
     OS << "\n'RELA' relocation section at offset "
        << format_hex(reinterpret_cast<const uint8_t *>(DynRelaRegion.Addr) -
                          Obj->base(),
                      1)
        << " contains " << DynRelaRegion.Size << " bytes:\n";
     printRelocHeader(ELF::SHT_RELA);
     for (const Elf_Rela &Rela : this->dumper()->dyn_relas())
-      printDynamicRelocation(Obj, Rela);
+      printDynamicRelocation(Obj, Rela, /*Addend=*/(int64_t)Rela.r_addend);
   }
   if (DynRelRegion.Size > 0) {
     OS << "\n'REL' relocation section at offset "
        << format_hex(reinterpret_cast<const uint8_t *>(DynRelRegion.Addr) -
                          Obj->base(),
                      1)
        << " contains " << DynRelRegion.Size << " bytes:\n";
     printRelocHeader(ELF::SHT_REL);
     for (const Elf_Rel &Rel : this->dumper()->dyn_rels())
-      printDynamicRelocation(Obj, Rel);
+      printDynamicRelocation(Obj, Rel, /*Addend=*/None);
   }
   if (DynRelrRegion.Size > 0) {
     OS << "\n'RELR' relocation section at offset "
        << format_hex(reinterpret_cast<const uint8_t *>(DynRelrRegion.Addr) -
                          Obj->base(),
                      1)
        << " contains " << DynRelrRegion.Size << " bytes:\n";
     printRelocHeader(ELF::SHT_REL);
     Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
     std::vector<Elf_Rel> RelrRels =
         unwrapOrError(this->FileName, Obj->decode_relrs(Relrs));
     for (const Elf_Rel &R : RelrRels)
-      printDynamicRelocation(Obj, R);
+      printDynamicRelocation(Obj, R, /*Addend=*/None);
   }
   if (DynPLTRelRegion.Size) {
     OS << "\n'PLT' relocation section at offset "
        << format_hex(reinterpret_cast<const uint8_t *>(DynPLTRelRegion.Addr) -
                          Obj->base(),
                      1)
        << " contains " << DynPLTRelRegion.Size << " bytes:\n";
 
     if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) {
       printRelocHeader(ELF::SHT_RELA);
       for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
-        printDynamicRelocation(Obj, Rela);
+        printDynamicRelocation(Obj, Rela, /*Addend=*/(int64_t)Rela.r_addend);
     } else {
       printRelocHeader(ELF::SHT_REL);
       for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>())
-        printDynamicRelocation(Obj, Rel);
+        printDynamicRelocation(Obj, Rel, /*Addend=*/None);
     }
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printGNUVersionSectionProlog(
     const ELFFile<ELFT> *Obj, const typename ELFT::Shdr *Sec,
     const Twine &Label, unsigned EntriesNum) {
void DumpStyle<ELFT>::printRelocationsHelper(const ELFFile<ELFT> *Obj,
   const Elf_Shdr *SymTab =
       unwrapOrError(this->FileName, Obj->getSection(Sec.sh_link));
   unsigned SecNdx = &Sec - &cantFail(Obj->sections()).front();
   unsigned RelNdx = 0;
 
   switch (Sec.sh_type) {
   case ELF::SHT_REL:
     for (const Elf_Rel &R : unwrapOrError(this->FileName, Obj->rels(&Sec)))
-      printRelReloc(Obj, SecNdx, SymTab, R, ++RelNdx);
+      printRelRelaReloc(Obj, SecNdx, SymTab, R, /*Addend=*/None, ++RelNdx);
     break;
   case ELF::SHT_RELA:
     for (const Elf_Rela &R : unwrapOrError(this->FileName, Obj->relas(&Sec)))
-      printRelaReloc(Obj, SecNdx, SymTab, R, ++RelNdx);
+      printRelRelaReloc(Obj, SecNdx, SymTab, R, (int64_t)R.r_addend, ++RelNdx);
     break;
   case ELF::SHT_RELR:
   case ELF::SHT_ANDROID_RELR: {
     Elf_Relr_Range Relrs = unwrapOrError(this->FileName, Obj->relrs(&Sec));
     if (opts::RawRelr) {
       for (const Elf_Relr &R : Relrs)
         printRelrReloc(R);
       break;
     }
     std::vector<Elf_Rel> RelrRels =
         unwrapOrError(this->FileName, Obj->decode_relrs(Relrs));
     for (const Elf_Rel &R : RelrRels)
-      printRelReloc(Obj, SecNdx, SymTab, R, ++RelNdx);
+      printRelRelaReloc(Obj, SecNdx, SymTab, R, /*Addend=*/None, ++RelNdx);
     break;
   }
   case ELF::SHT_ANDROID_REL:
   case ELF::SHT_ANDROID_RELA:
     for (const Elf_Rela &R :
          unwrapOrError(this->FileName, Obj->android_relas(&Sec)))
-      printRelaReloc(Obj, SecNdx, SymTab, R, ++RelNdx);
+      printRelRelaReloc(Obj, SecNdx, SymTab, R, (int64_t)R.r_addend, ++RelNdx);
     break;
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printDependentLibs(const ELFFile<ELFT> *Obj) {
   bool SectionStarted = false;
   struct NameOffset {
for (const Elf_Shdr &Sec : cantFail(Obj->sections())) {
     W.startLine() << "Section (" << SecNdx << ") " << Name << " {\n";
     W.indent();
     this->printRelocationsHelper(Obj, Sec);
     W.unindent();
     W.startLine() << "}\n";
   }
 }
 
-template <class ELFT>
-void LLVMStyle<ELFT>::printRelReloc(const ELFO *Obj, unsigned SecIndex,
-                                    const Elf_Shdr *SymTab, const Elf_Rel &R,
-                                    unsigned RelIndex) {
-  printRelRelaReloc(Obj, SecIndex, R, RelIndex, SymTab);
-}
-
-template <class ELFT>
-void LLVMStyle<ELFT>::printRelaReloc(const ELFO *Obj, unsigned SecIndex,
-                                     const Elf_Shdr *SymTab, const Elf_Rela &R,
-                                     unsigned RelIndex) {
-  printRelRelaReloc(Obj, SecIndex, R, RelIndex, 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 ELFO *Obj, unsigned SecIndex,
-                                        const RelTy &Rel, unsigned RelIndex,
-                                        const Elf_Shdr *SymTab) {
+                                        const Elf_Shdr *SymTab,
+                                        const Elf_Rel &Rel,
+                                        Optional<int64_t> Addend,
+                                        unsigned RelIndex) {
   Expected<std::pair<const typename ELFT::Sym *, std::string>> Target =
       this->dumper()->getRelocationTarget(SymTab, Rel);
   if (!Target) {
     this->reportUniqueWarning(createError(
         "unable to print relocation " + Twine(RelIndex) + " in section " +
         Twine(SecIndex) + ": " + toString(Target.takeError())));
     return;
   }
 
   std::string TargetName = Target->second;
   SmallString<32> RelocName;
   Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
 
-  uintX_t Addend = getAddend<ELFT>(Rel).getValueOr(0);
+  uintX_t A = Addend.getValueOr(0);
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Rel.r_offset);
     W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
     W.printNumber("Symbol", !TargetName.empty() ? TargetName : "-",
                   Rel.getSymbol(Obj->isMips64EL()));
-    W.printHex("Addend", Addend);
+    W.printHex("Addend", A);
   } else {
     raw_ostream &OS = W.startLine();
     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
-       << (!TargetName.empty() ? TargetName : "-") << " " << W.hex(Addend)
-       << "\n";
+       << (!TargetName.empty() ? TargetName : "-") << " " << W.hex(A) << "\n";
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printSectionHeaders(const ELFO *Obj) {
   ListScope SectionsD(W, "Sections");
 
   int SectionIndex = -1;
void LLVMStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
   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(Obj, Rela);
+      printDynamicRelocation(Obj, Rela, (int64_t)Rela.r_addend);
   }
   if (DynRelRegion.Size > 0) {
     for (const Elf_Rel &Rel : this->dumper()->dyn_rels())
-      printDynamicRelocation(Obj, Rel);
+      printDynamicRelocation(Obj, Rel, /*Addend*/None);
   }
 
   if (DynRelrRegion.Size > 0) {
     Elf_Relr_Range Relrs = this->dumper()->dyn_relrs();
     std::vector<Elf_Rel> RelrRels =
         unwrapOrError(this->FileName, Obj->decode_relrs(Relrs));
     for (const Elf_Rel &R : RelrRels)
-      printDynamicRelocation(Obj, R);
+      printDynamicRelocation(Obj, R, /*Addend*/None);
   }
   if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela))
     for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
-      printDynamicRelocation(Obj, Rela);
+      printDynamicRelocation(Obj, Rela, (int64_t)Rela.r_addend);
   else
     for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>())
-      printDynamicRelocation(Obj, Rel);
+      printDynamicRelocation(Obj, Rel, /*Addend*/None);
 
   W.unindent();
   W.startLine() << "}\n";
 }
 
 template <class ELFT>
- template <class RelTy>
-void LLVMStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, const RelTy& Rel) {
+void LLVMStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, const Elf_Rel &Rel,
+                                             Optional<int64_t> Addend) {
   SmallString<32> RelocName;
   Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
   std::string SymbolName =
-      getSymbolForReloc(Obj, this->FileName, this->dumper(), Rel).Name;
+      getSymbolForReloc<ELFT>(Obj, this->FileName, this->dumper(), Rel).Name;
 
-  uintX_t Addend = getAddend<ELFT>(Rel).getValueOr(0);
+  uintX_t A = Addend.getValueOr(0);
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Rel.r_offset);
     W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
     W.printString("Symbol", !SymbolName.empty() ? SymbolName : "-");
-    W.printHex("Addend", Addend);
+    W.printHex("Addend", A);
   } else {
     raw_ostream &OS = W.startLine();
     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
-       << (!SymbolName.empty() ? SymbolName : "-") << " " << W.hex(Addend)
-       << "\n";
+       << (!SymbolName.empty() ? SymbolName : "-") << " " << W.hex(A) << "\n";
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printProgramHeaders(
     const ELFO *Obj, bool PrintProgramHeaders,
     cl::boolOrDefault PrintSectionMapping) {
   if (PrintProgramHeaders)