[llvm-readobj][ELF] Teach llvm-readobj to show dynamic relocation in REL format

[atanasyan]

Summary

MIPS 32-bit ABI uses REL relocation record format to save dynamic relocations. The patch teaches llvm-readobj to show dynamic relocations in this format.

[davide]

The change looks good, please include a comment explaining how you generated (including the code itself, maybe) the object so we can regenerate that if needed.

[davide]

tools/llvm-readobj/ELFDumper.cpp

111

Actually, this is out of order.

956

Ditto.

1030

Can you use 'RELA' as typename? (given you're dealing with rela(s))

[atanasyan]

tools/llvm-readobj/ELFDumper.cpp

956

I use here the same order as used for DT_RELAxx entries.

[atanasyan]

• Add instructions how to create dyn-rel.so.elf-mips
• s/REL/RELA/ in template argument
• Order printDynamicRelocation declaration properly

[atanasyan]

Ping?

[davide]

LGTM.

test/Object/dyn-rel-relocation.test

+// Check that 'llvm-readobj -dyn-relocations' shows dynamic relocations
+// if they have REL record format.
+
+// dyn-rel.so.elf-mips
+// % cat test.s
+//   .globl  __start
+// __start:
+//   nop
+// 
+//   .data
+//   .type  v1,@object
+//   .size  v1,4
+// v1:
+//   .word 0
+// 
+//   .globl v2
+//   .type  v2,@object
+//   .size  v2,8
+// v2:
+//   .word v2+4 # R_MIPS_32 target v2 addend 4
+//   .word v1   # R_MIPS_32 target v1 addend 0
+//
+// % llvm-mc -filetype=obj -triple=mips-unknown-linux -o test.o test.s
+// % ld  -m elf32btsmip -shared -o dyn-rel.so.elf-mips test.o
+
+RUN: llvm-readobj -relocations -dyn-relocations -expand-relocs \
+RUN:   %p/Inputs/dyn-rel.so.elf-mips | FileCheck %s
+
+// CHECK:      Relocations [
+// CHECK-NEXT:   Section (6) .rel.dyn {
+// CHECK-NEXT:     Relocation {
+// CHECK-NEXT:       Offset: 0x0
+// CHECK-NEXT:       Type: R_MIPS_NONE (0)
+// CHECK-NEXT:       Symbol: - (0)
+// CHECK-NEXT:       Addend: 0x0
+// CHECK-NEXT:     }
+// CHECK-NEXT:     Relocation {
+// CHECK-NEXT:       Offset: 0x102F8
+// CHECK-NEXT:       Type: R_MIPS_REL32 (3)
+// CHECK-NEXT:       Symbol: - (0)
+// CHECK-NEXT:       Addend: 0x0
+// CHECK-NEXT:     }
+// CHECK-NEXT:     Relocation {
+// CHECK-NEXT:       Offset: 0x102F4
+// CHECK-NEXT:       Type: R_MIPS_REL32 (3)
+// CHECK-NEXT:       Symbol: v2 (9)
+// CHECK-NEXT:       Addend: 0x0
+// CHECK-NEXT:     }
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]
+
+// CHECK:      Dynamic Relocations {
+// CHECK-NEXT:   Relocation {
+// CHECK-NEXT:     Offset: 0x0
+// CHECK-NEXT:     Type: R_MIPS_NONE (0)
+// CHECK-NEXT:     Symbol: -
+// CHECK-NEXT:     Addend: 0x0
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Relocation {
+// CHECK-NEXT:     Offset: 0x102F8
+// CHECK-NEXT:     Type: R_MIPS_REL32 (3)
+// CHECK-NEXT:     Symbol: -
+// CHECK-NEXT:     Addend: 0x0
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Relocation {
+// CHECK-NEXT:     Offset: 0x102F4
+// CHECK-NEXT:     Type: R_MIPS_REL32 (3)
+// CHECK-NEXT:     Symbol: v2
+// CHECK-NEXT:     Addend: 0x0
+// CHECK-NEXT:   }
+// CHECK-NEXT: }

tools/llvm-readobj/ELFDumper.cpp

 private:
   typedef ELFFile<ELFT> ELFO;
   typedef typename ELFO::Elf_Shdr Elf_Shdr;
   typedef typename ELFO::Elf_Sym Elf_Sym;
   typedef typename ELFO::Elf_Dyn Elf_Dyn;
   typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
   typedef typename ELFO::Elf_Rel Elf_Rel;
   typedef typename ELFO::Elf_Rela Elf_Rela;
+  typedef typename ELFO::Elf_Rel_Range Elf_Rel_Range;
   typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range;
   typedef typename ELFO::Elf_Phdr Elf_Phdr;
   typedef typename ELFO::Elf_Half Elf_Half;
   typedef typename ELFO::Elf_Hash Elf_Hash;
   typedef typename ELFO::Elf_GnuHash Elf_GnuHash;
   typedef typename ELFO::Elf_Ehdr Elf_Ehdr;
   typedef typename ELFO::Elf_Word Elf_Word;
   typedef typename ELFO::uintX_t uintX_t;
struct DynRegionInfo {
     /// \brief Size of each entity in the region.
     uintX_t EntSize;
   };
 
   void printSymbolsHelper(bool IsDynamic);
   void printSymbol(const Elf_Sym *Symbol, const Elf_Shdr *SymTab,
                    StringRef StrTable, bool IsDynamic);
 
+  void printDynamicRelocation(Elf_Rela Rel);
   void printRelocations(const Elf_Shdr *Sec);
   void printRelocation(Elf_Rela Rel, const Elf_Shdr *SymTab);
   void printValue(uint64_t Type, uint64_t Value);
 
-  const Elf_Rela *dyn_rela_begin() const;
-  const Elf_Rela *dyn_rela_end() const;
+  template <typename RELA>
+  static const RELA *dyn_rela_begin(const DynRegionInfo &region);
+  template <typename RELA>
+  static const RELA *dyn_rela_end(const DynRegionInfo &region);
+  Elf_Rel_Range dyn_rels() const;
   Elf_Rela_Range dyn_relas() const;
   StringRef getDynamicString(uint64_t Offset) const;
   const Elf_Dyn *dynamic_table_begin() const {
     ErrorOr<const Elf_Dyn *> Ret = Obj->dynamic_table_begin(DynamicProgHeader);
     error(Ret.getError());
     return *Ret;
   }
   const Elf_Dyn *dynamic_table_end() const {
     ErrorOr<const Elf_Dyn *> Ret = Obj->dynamic_table_end(DynamicProgHeader);
     error(Ret.getError());
     return *Ret;
   }
   StringRef getSymbolVersion(StringRef StrTab, const Elf_Sym *symb,
                              bool &IsDefault);
   void LoadVersionMap();
   void LoadVersionNeeds(const Elf_Shdr *ec) const;
   void LoadVersionDefs(const Elf_Shdr *sec) const;
 
   const ELFO *Obj;
+  DynRegionInfo DynRelRegion;
   DynRegionInfo DynRelaRegion;
   const Elf_Phdr *DynamicProgHeader = nullptr;
   StringRef DynamicStringTable;
   const Elf_Sym *DynSymStart = nullptr;
   StringRef SOName;
   const Elf_Hash *HashTable = nullptr;
   const Elf_GnuHash *GnuHashTable = nullptr;
   const Elf_Shdr *DotDynSymSec = nullptr;
for (const Elf_Dyn &Dyn : dynamic_table()) {
     case ELF::DT_HASH:
       HashTable =
           reinterpret_cast<const Elf_Hash *>(toMappedAddr(Dyn.getPtr()));
       break;
     case ELF::DT_GNU_HASH:
       GnuHashTable =
           reinterpret_cast<const Elf_GnuHash *>(toMappedAddr(Dyn.getPtr()));
       break;
+    case ELF::DT_REL:
+      DynRelRegion.Addr = toMappedAddr(Dyn.getPtr());
+      break;
+    case ELF::DT_RELSZ:
+      DynRelRegion.Size = Dyn.getVal();
+      break;
+    case ELF::DT_RELENT:
+      DynRelRegion.EntSize = Dyn.getVal();
+      break;
     case ELF::DT_RELA:
       DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr());
       break;
     case ELF::DT_RELASZ:
       DynRelaRegion.Size = Dyn.getVal();
       break;
     case ELF::DT_RELAENT:
       DynRelaRegion.EntSize = Dyn.getVal();
case ELF::SHT_SYMTAB_SHNDX: {
       ShndxTable = *TableOrErr;
       break;
     }
     }
   }
 }
 
 template <typename ELFT>
-const typename ELFDumper<ELFT>::Elf_Rela *
-ELFDumper<ELFT>::dyn_rela_begin() const {
-  if (DynRelaRegion.Size && DynRelaRegion.EntSize != sizeof(Elf_Rela))
+template <typename RELA>
+const RELA *ELFDumper<ELFT>::dyn_rela_begin(const DynRegionInfo &Region) {
+  if (Region.Size && Region.EntSize != sizeof(RELA))
     report_fatal_error("Invalid relocation entry size");
-  return reinterpret_cast<const Elf_Rela *>(DynRelaRegion.Addr);
+  return reinterpret_cast<const RELA *>(Region.Addr);
 }
 
 template <typename ELFT>
-const typename ELFDumper<ELFT>::Elf_Rela *
-ELFDumper<ELFT>::dyn_rela_end() const {
-  uint64_t Size = DynRelaRegion.Size;
-  if (Size % sizeof(Elf_Rela))
+template <typename RELA>
+const RELA *ELFDumper<ELFT>::dyn_rela_end(const DynRegionInfo &Region) {
+  uint64_t Size = Region.Size;
+  if (Size % sizeof(RELA))
     report_fatal_error("Invalid relocation table size");
-  return dyn_rela_begin() + Size / sizeof(Elf_Rela);
+  return dyn_rela_begin<RELA>(Region) + Size / sizeof(RELA);
+}
+
+template <typename ELFT>
+typename ELFDumper<ELFT>::Elf_Rel_Range ELFDumper<ELFT>::dyn_rels() const {
+  return make_range(dyn_rela_begin<Elf_Rel>(DynRelRegion),
+                    dyn_rela_end<Elf_Rel>(DynRelRegion));
 }
 
 template <typename ELFT>
 typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const {
-  return make_range(dyn_rela_begin(), dyn_rela_end());
+  return make_range(dyn_rela_begin<Elf_Rela>(DynRelaRegion),
+                    dyn_rela_end<Elf_Rela>(DynRelaRegion));
 }
 
 template<class ELFT>
 void ELFDumper<ELFT>::printFileHeaders() {
   const Elf_Ehdr *Header = Obj->getHeader();
 
   {
     DictScope D(W, "ElfHeader");
for (const Elf_Shdr &Sec : Obj->sections()) {
 
     printRelocations(&Sec);
 
     W.unindent();
     W.startLine() << "}\n";
   }
 }
 
-template<class ELFT>
-void ELFDumper<ELFT>::printDynamicRelocations() {
+template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() {
+  if (DynRelRegion.Size && DynRelaRegion.Size)
+    report_fatal_error("There are both REL and RELA dynamic relocations");
   W.startLine() << "Dynamic Relocations {\n";
   W.indent();
-  for (const Elf_Rela &Rel : dyn_relas()) {
-    SmallString<32> RelocName;
-    Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
-    StringRef SymbolName;
-    uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL());
-    const Elf_Sym *Sym = DynSymStart + SymIndex;
-    SymbolName = errorOrDefault(Sym->getName(DynamicStringTable));
-    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.size() > 0 ? SymbolName : "-");
-      W.printHex("Addend", Rel.r_addend);
-    }
-    else {
-      raw_ostream& OS = W.startLine();
-      OS << W.hex(Rel.r_offset) << " " << RelocName << " "
-         << (SymbolName.size() > 0 ? SymbolName : "-") << " "
-         << W.hex(Rel.r_addend) << "\n";
-    }
+  if (DynRelaRegion.Size > 0)
+    for (const Elf_Rela &Rela : dyn_relas())
+      printDynamicRelocation(Rela);
+  else
+    for (const Elf_Rel &Rel : dyn_rels()) {
+      Elf_Rela Rela;
+      Rela.r_offset = Rel.r_offset;
+      Rela.r_info = Rel.r_info;
+      Rela.r_addend = 0;
+      printDynamicRelocation(Rela);
     }
   W.unindent();
   W.startLine() << "}\n";
 }
 
 template <class ELFT>
 void ELFDumper<ELFT>::printRelocations(const Elf_Shdr *Sec) {
   ErrorOr<const Elf_Shdr *> SymTabOrErr = Obj->getSection(Sec->sh_link);
   error(SymTabOrErr.getError());
void ELFDumper<ELFT>::printRelocation(Elf_Rela Rel, const Elf_Shdr *SymTab) {
   } else {
     raw_ostream& OS = W.startLine();
     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
        << (TargetName.size() > 0 ? TargetName : "-") << " "
        << W.hex(Rel.r_addend) << "\n";
   }
 }
 
-template<class ELFT>
+template <class ELFT>
+void ELFDumper<ELFT>::printDynamicRelocation(Elf_Rela Rel) {
+  SmallString<32> RelocName;
+  Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
+  StringRef SymbolName;
+  uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL());
+  const Elf_Sym *Sym = DynSymStart + SymIndex;
+  SymbolName = errorOrDefault(Sym->getName(DynamicStringTable));
+  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.size() > 0 ? SymbolName : "-");
+    W.printHex("Addend", Rel.r_addend);
+  } else {
+    raw_ostream &OS = W.startLine();
+    OS << W.hex(Rel.r_offset) << " " << RelocName << " "
+       << (SymbolName.size() > 0 ? SymbolName : "-") << " "
+       << W.hex(Rel.r_addend) << "\n";
+  }
+}
+
+template<class ELFT>
 void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) {
   const Elf_Shdr *Symtab = (IsDynamic) ? DotDynSymSec : DotSymtabSec;
   if (!Symtab)
     return;
   ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab);
   error(StrTableOrErr.getError());
   StringRef StrTable = *StrTableOrErr;
   for (const Elf_Sym &Sym : Obj->symbols(Symtab))