[llvm-readobj/elf] - Refine signature of print*Reloc methods.

[grimar]

Summary

This makes the interface cleaner and slightly improves messages
reported.

I need it for another patch that is going to reuse
virtual print*Reloc methods for printing dynamic relocations.
(in that case the const Elf_Shdr *Sec argument introduced
instead of unsigned SecIndex will be nullptr).

[grimar]

• Fix minor nit.

[jhenderson]

Not sure this shouldn't be two separate patches (improve error message/change signature), but I'm not going to ask for it. LGTM.

llvm/test/tools/llvm-readobj/ELF/relocation-errors.test

 ## Check how we report warnings when dumping an object with broken relocations.
 
 # RUN: yaml2obj %s -o %t64
 # RUN: llvm-readobj --relocations %t64 2>&1 | FileCheck %s -DFILE=%t64 --check-prefix=LLVM
 # RUN: llvm-readelf --relocations %t64 2>&1 | FileCheck %s -DFILE=%t64 --check-prefix=GNU
 
 # LLVM:      Relocations [
 # LLVM-NEXT:   Section (3) .rel.text {
-# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 1 in section 3: unable to access section [index 6] data at 0x17e7e7e8b0: offset goes past the end of file
-# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 2 in section 3: unable to access section [index 6] data at 0x17e7e7e8b0: offset goes past the end of file
+# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 1 in SHT_REL section with index 3: unable to access section [index 6] data at 0x17e7e7e8b0: offset goes past the end of file
+# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 2 in SHT_REL section with index 3: unable to access section [index 6] data at 0x17e7e7e8b0: offset goes past the end of file
 # LLVM-NEXT:     0x2 R_X86_64_NONE - 0x0
-# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 4 in section 3: invalid section index: 255
-# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 5 in section 3: a section [index 2] has an invalid sh_name (0xfefefefe) offset which goes past the end of the section name string table
+# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 4 in SHT_REL section with index 3: invalid section index: 255
+# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 5 in SHT_REL section with index 3: a section [index 2] has an invalid sh_name (0xfefefefe) offset which goes past the end of the section name string table
 # LLVM-NEXT:   }
 # LLVM-NEXT:   Section (4) .rela.text {
-# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 1 in section 4: invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM
+# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 1 in SHT_RELA section with index 4: invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM
 # LLVM-NEXT:   }
 # LLVM-NEXT: ]
 
 # GNU:       Relocation section '.rel.text' at offset 0x41 contains 5 entries:
 # GNU-NEXT:      Offset             Info             Type               Symbol's Value  Symbol's Name
-# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 1 in section 3: unable to access section [index 6] data at 0x17e7e7e8b0: offset goes past the end of file
-# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 2 in section 3: unable to access section [index 6] data at 0x17e7e7e8b0: offset goes past the end of file
+# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 1 in SHT_REL section with index 3: unable to access section [index 6] data at 0x17e7e7e8b0: offset goes past the end of file
+# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 2 in SHT_REL section with index 3: unable to access section [index 6] data at 0x17e7e7e8b0: offset goes past the end of file
 # GNU-NEXT:  0000000000000002  0000000000000000 R_X86_64_NONE
-# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 4 in section 3: invalid section index: 255
-# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 5 in section 3: a section [index 2] has an invalid sh_name (0xfefefefe) offset which goes past the end of the section name string table
+# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 4 in SHT_REL section with index 3: invalid section index: 255
+# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 5 in SHT_REL section with index 3: a section [index 2] has an invalid sh_name (0xfefefefe) offset which goes past the end of the section name string table
 # GNU-EMPTY:
 # GNU-NEXT:  Relocation section '.rela.text' at offset 0x91 contains 1 entries:
 # GNU-NEXT:      Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
-# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 1 in section 4: invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM
+# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 1 in SHT_RELA section with index 4: invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

llvm/tools/llvm-readobj/ELFDumper.cpp

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(unsigned SecIndex, const Elf_Shdr *SymTab,
-                             const Elf_Rel &R, unsigned RelIndex) = 0;
-  virtual void printRelaReloc(unsigned SecIndex, const Elf_Shdr *SymTab,
-                              const Elf_Rela &R, unsigned RelIndex) = 0;
+  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 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(unsigned SecIndex, const Elf_Shdr *SymTab,
-                     const Elf_Rel &R, unsigned RelIndex) override;
-  void printRelaReloc(unsigned SecIndex, const Elf_Shdr *SymTab,
-                      const Elf_Rela &R, unsigned RelIndex) override;
+  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 printRelrReloc(const Elf_Relr &R) override;
 
   template <class RelTy>
-  void printRelRelaReloc(unsigned SecIndex, const Elf_Shdr *SymTab,
-                         const RelTy &R, unsigned RelIndex);
+  void printRelRelaReloc(const RelTy &R, unsigned RelIndex, const Elf_Shdr &Sec,
+                         const Elf_Shdr *SymTab);
   template <class RelTy>
   void printRelRelaReloc(const Elf_Sym *Sym, StringRef SymbolName,
                          const RelTy &R);
   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);
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(unsigned SecIndex, const Elf_Shdr *SymTab,
-                     const Elf_Rel &R, unsigned RelIndex) override;
-  void printRelaReloc(unsigned SecIndex, const Elf_Shdr *SymTab,
-                      const Elf_Rela &R, unsigned RelIndex) override;
+  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 printRelrReloc(const Elf_Relr &R) override;
   template <class RelTy>
-  void printRelRelaReloc(unsigned SecIndex, const RelTy &Rel, unsigned RelIndex,
+  void printRelRelaReloc(const RelTy &R, unsigned RelIndex, const Elf_Shdr &Sec,
                          const Elf_Shdr *SymTab);
   template <class RelTy> void printDynamicRelocation(const RelTy &Rel);
 
   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,
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(unsigned SecIndex, const Elf_Shdr *SymTab,
-                                   const Elf_Rel &R, unsigned RelIndex) {
-  printRelRelaReloc(SecIndex, SymTab, R, RelIndex);
+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(unsigned SecIndex, const Elf_Shdr *SymTab,
-                                    const Elf_Rela &R, unsigned RelIndex) {
-  printRelRelaReloc(SecIndex, SymTab, R, RelIndex);
+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(unsigned SecIndex,
-                                       const Elf_Shdr *SymTab, const RelTy &R,
-                                       unsigned RelIndex) {
+void GNUStyle<ELFT>::printRelRelaReloc(const RelTy &R, unsigned RelIndex,
+                                       const Elf_Shdr &Sec,
+                                       const Elf_Shdr *SymTab) {
   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())));
+        "unable to print relocation " + Twine(RelIndex) + " in " +
+        describe(this->Obj, Sec) + ": " + toString(Target.takeError())));
   else
     printRelRelaReloc(/*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;
 }
if (Sec.sh_type != ELF::SHT_RELR && Sec.sh_type != ELF::SHT_ANDROID_RELR) {
     Expected<const Elf_Shdr *> SymTabOrErr = Obj.getSection(Sec.sh_link);
     if (!SymTabOrErr) {
       Warn(SymTabOrErr.takeError(), "unable to locate a symbol table for");
       return;
     }
     SymTab = *SymTabOrErr;
   }
 
-  unsigned SecNdx = &Sec - &cantFail(Obj.sections()).front();
   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(SecNdx, SymTab, R, ++RelNdx);
+        printRelReloc(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(SecNdx, SymTab, R, ++RelNdx);
+        printRelaReloc(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(SecNdx, /*SymTab=*/nullptr, R, ++RelNdx);
+      printRelReloc(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(SecNdx, SymTab, R, ++RelNdx);
+        printRelaReloc(R, ++RelNdx, &Sec, SymTab);
     } else {
       Warn(RelasOrErr.takeError());
     }
     break;
   }
 }
 
 template <class ELFT>
for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
     W.indent();
     this->printRelocationsHelper(Sec);
     W.unindent();
     W.startLine() << "}\n";
   }
 }
 
 template <class ELFT>
-void LLVMStyle<ELFT>::printRelReloc(unsigned SecIndex, const Elf_Shdr *SymTab,
-                                    const Elf_Rel &R, unsigned RelIndex) {
-  printRelRelaReloc(SecIndex, R, RelIndex, SymTab);
+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(unsigned SecIndex, const Elf_Shdr *SymTab,
-                                     const Elf_Rela &R, unsigned RelIndex) {
-  printRelRelaReloc(SecIndex, R, RelIndex, SymTab);
+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(unsigned SecIndex, const RelTy &Rel,
-                                        unsigned RelIndex,
+void LLVMStyle<ELFT>::printRelRelaReloc(const RelTy &Rel, unsigned RelIndex,
+                                        const Elf_Shdr &Sec,
                                         const Elf_Shdr *SymTab) {
   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())));
+        "unable to print relocation " + Twine(RelIndex) + " in " +
+        describe(this->Obj, Sec) + ": " + toString(Target.takeError())));
     return;
   }
 
   std::string TargetName = Target->second;
   SmallString<32> RelocName;
   this->Obj.getRelocationTypeName(Rel.getType(this->Obj.isMips64EL()),
                                   RelocName);