Add support for dumping relocations in non-relocatable files

[colinl]

Summary

Relocations can be in non-relocatable files by linking with --emit-relocs. This removes the associated violated assertion in ELFObjectFile and removes the short-circuit return in llvm-objdump. The comment says objdump doesn't print out these relocations though this isn't correct. Using the associated test file it's seen GNU objdump indeed prints out these relocations.

[mcrosier]

Fairly out of my field of expertise.

[• rafael]

Please add a comment saying how the binary was created.

The assert is correct. Whatever is calling getRelocationOffset should
instead be trying to get the address.

Testing locally I see that objdump prints relocations that were copied
by --emit-reloc but not dynamic relocations.

Given

void g(void);
void f(void) {

g();

}

objudump on x86_64 will print

---

RELOCATION RECORDS FOR [.text]:
OFFSET TYPE VALUE
0000000000000005 R_X86_64_PLT32 g-0x0000000000000004

RELOCATION RECORDS FOR [.eh_frame]:
OFFSET TYPE VALUE

0000000000000020 R_X86_64_PC32 .text+0x0000000000000270

readelf prints

---

Relocation section '.rela.plt' at offset 0x238 contains 1 entries:

Offset             Info             Type               Symbol's

Value Symbol's Name + Addend
00000000000013e8 0000000200000007 R_X86_64_JUMP_SLOT 0000000000000000 g + 0

Relocation section '.rela.text' at offset 0x428 contains 1 entries:

Offset             Info             Type               Symbol's

Value Symbol's Name + Addend
0000000000000275 0000000600000004 R_X86_64_PLT32 0000000000000000 g - 4

Relocation section '.rela.eh_frame' at offset 0x440 contains 1 entries:

Offset             Info             Type               Symbol's

Value Symbol's Name + Addend
00000000000002a0 0000000100000002 R_X86_64_PC32

0000000000000270 .text + 270

Note that:

• The relocations from .rela.plt are missing in objdump.
• The relocations in the .so have addresses. What objdump does is map

address to section and subtract the section address to get an offset.

Please investigate exactly which relocations are skipped by objdump.

Please make sure llvm-objdump skips the same relocations and prints
offsets like objdump.

Cheers,
Rafael

[colinl]

It looks like in the ELF spec, as you already noticed, it says r_offset contains the virtual address if the file type is ET_EXEC or ET_DYN so in those cases we look for the relocated section and subtract the address.

I added a comment in the test on how the binary was created.

For equivalent functionality of dynamic relocations we'd need to add the -R flag to llvm-objdump, SymbolRef would need an accessor like isDynamic, the ELF implementation can use code from getRelocationSymbol to determine if it's dynamic:

bool IsDyn = Rel.d.b & 1;
DataRefImpl SymbolData;
if (IsDyn)
  SymbolData = toDRI(DotDynSymSec, symbolIdx);
else
  SymbolData = toDRI(DotSymtabSec, symbolIdx);

and then COFF and MachO would need implementations for those file types. The interwoven disassembly/relocations would need to also take this in to account.

It'd be good to have equivalent functionality though I think we should do that in a separate revision since it's non-trivial.

[colinl]

*ping*

Does this solution and test look acceptable?

[colinl]

I'm noticing r215844 saying GNU objdump doesn't print relocations in non-relocatable files. This doesn't seem correct, with -emit-relocs objdump does seem to print relocations in executable and SO files.

[shankare]

r_offset is being modeled as per the ELF spec IMO and looks correct. GNU objdump does show relocations when there are relocation sections, that point to the section that needs relocation.

Example :-

00000000004000c0 <foo>:
  4000c0: 55                    push   %rbp
  4000c1: 48 89 e5              mov    %rsp,%rbp
  4000c4: e8 e7 ff ff ff        callq  4000b0 <bar>
        4000c5: R_X86_64_PC32   bar-0x4
  4000c9: 5d                    pop    %rbp
  4000ca: c3                    retq

[khemant]

LGTM.

[colinl]

The assert is correct. Whatever is calling getRelocationOffset should
instead be trying to get the address.

I disagree, the assertion isn't correct.

You can ask for a relocation's offset inside an exe and SO file. r_offset is overloaded to contain the address in these which is why section offset needs to be subtracted in order to get the offset.

I'm not looking for the address, I'm looking for precisely the relocation offset.

[shankare]

http://www.sco.com/developers/gabi/latest/ch4.reloc.html

r_offset
This member gives the location at which to apply the relocation action. For a relocatable file, the value is the byte offset from the beginning of the section to the storage unit affected by the relocation. For an executable file or a shared object, the value is the virtual address of the storage unit affected by the relocation.

This shows that the assertion is incorrect, as the ELF ABI suggests reading relocation records is valid in Executables as well.

While relocation offset is not looked up for shared libraries from .rela.dyn and .rela.plt sections, there is a usecase where relocation sections are generated with the linker switch --emit-relocs

Removing the assertion, LGTM.

[llvm-commits]

llvm-objdump wants to print the relocationOffset, so it calls RelocationRef::relocationOffset which calls ELFObjectFile::getRelocationOffset

Since objdump wants the relocation offset, and this pipes down to ELFObjectFile::getRelocationOffset, at what point is the address supposed to be asked for?

[colinl]

Is this the recommendation on how to print relocation section offsets inside executable files?

[• rafael]

This is much better, but needs a bit more work.

include/llvm/Object/ELFObjectFile.h

687

It is undesirable to expose this.

Calling a relocation "dynamic" was a hack to avoid looking at sh_link every time one asks for a symbol for a relocation. I removed the hack in r264624.

test/tools/llvm-objdump/X86/relocations-in-nonrelocatable.test

7

You can produce a much simpler file by running

gcc -c main.c -fno-asynchronous-unwind-tables -fPIC
ld.gold main.o -o main.so -shared --emit-relocs

Please do that and also run "llvm-readobj -r" so show all the relocations in the file.

I investigated a bit exactly which relocations are printed by bfd objdump. The answer is that it prints relocations from sections that use .symtab as the symbol table. That is just a limitation of bfd.

Some options we have given the desire to print relocations in executables and shared libraries.

• Add a check for just the restriction that bfd has. That seems a bit too much of a bug for bug compatibility.
• Print any relocation in section that have a relocated section (sh_info is not zero). Unlike bfd this would print the info for .rela.plt.
• Print all relocations. Unlike bfd this would print .rela.plt and .rela.dyn.

tools/llvm-objdump/llvm-objdump.cpp

444

This is guarding against a relocation with a symbol index of 0? That is an independent change, no?

445

Since moving it, please use the new variable name style: Symb

462

Does gnu objdump print ABS for this? Seems like an odd term. ABS refers to symbols, but in here you have no symbol at all.

1195

You only need a sorted std::vector, no?

1196

Initialize the iterators with "I = " not "I(...)";

1221

Can you use lower_bound?

include/llvm/Object/COFF.h

   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 
   void moveRelocationNext(DataRefImpl &Rel) const override;
+  bool getRelocationIsDynamic(DataRefImpl Rel) const override { return false; }
+  uint64_t getRelocationAddress(DataRefImpl Rel) const override;
   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
   uint64_t getRelocationType(DataRefImpl Rel) const override;

include/llvm/Object/ELFObjectFile.h

   section_iterator getRelocatedSection(DataRefImpl Sec) const override;
 
   void moveRelocationNext(DataRefImpl &Rel) const override;
+  bool getRelocationIsDynamic(DataRefImpl Rel) const override;
+  uint64_t getRelocationAddress(DataRefImpl Rel) const override;
   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
   uint64_t getRelocationType(DataRefImpl Rel) const override;

   if (!symbolIdx)
     return symbol_end();
 
-  bool IsDyn = Rel.d.b & 1;
   DataRefImpl SymbolData;
-  if (IsDyn)
+  if (getRelocationIsDynamic(Rel))
     SymbolData = toDRI(DotDynSymSec, symbolIdx);
   else
     SymbolData = toDRI(DotSymtabSec, symbolIdx);

 }
 
 template <class ELFT>
-uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const {
+bool ELFObjectFile<ELFT>::getRelocationIsDynamic(DataRefImpl Rel) const {
+  return Rel.d.b & 1;
+}
+
+template <class ELFT>
+uint64_t ELFObjectFile<ELFT>::getRelocationAddress(DataRefImpl Rel) const {
+  assert(EF.getHeader()->e_type != ELF::ET_REL &&
+         "Only executable and shared objcet files have relocation addresses");
+  const Elf_Shdr *sec = getRelSection(Rel);
+  if (sec->sh_type == ELF::SHT_REL)
+    return getRel(Rel)->r_offset;
+
+  return getRela(Rel)->r_offset;
+}
+
+template <class ELFT>
+uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const {
   assert(EF.getHeader()->e_type == ELF::ET_REL &&
          "Only relocatable object files have relocation offsets");
   const Elf_Shdr *sec = getRelSection(Rel);

include/llvm/Object/MachO.h

   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 
   void moveRelocationNext(DataRefImpl &Rel) const override;
+  bool getRelocationIsDynamic(DataRefImpl Rel) const override { return false; }
+  uint64_t getRelocationAddress(DataRefImpl Rel) const override;
   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
   section_iterator getRelocationSection(DataRefImpl Rel) const;

include/llvm/Object/ObjectFile.h

 
   void moveNext();
 
+  bool isDynamic() const;
+  uint64_t getAddress() const;
   uint64_t getOffset() const;
   symbol_iterator getSymbol() const;
   uint64_t getType() const;

   // Same as above for RelocationRef.
   friend class RelocationRef;
   virtual void moveRelocationNext(DataRefImpl &Rel) const = 0;
+  virtual bool getRelocationIsDynamic(DataRefImpl Rel) const = 0;
+  virtual uint64_t getRelocationAddress(DataRefImpl Rel) const = 0;
   virtual uint64_t getRelocationOffset(DataRefImpl Rel) const = 0;
   virtual symbol_iterator getRelocationSymbol(DataRefImpl Rel) const = 0;
   virtual uint64_t getRelocationType(DataRefImpl Rel) const = 0;

   return OwningObject->moveRelocationNext(RelocationPimpl);
 }
 
+inline bool RelocationRef::isDynamic() const {
+  return OwningObject->getRelocationIsDynamic(RelocationPimpl);
+}
+
+inline uint64_t RelocationRef::getAddress() const {
+  return OwningObject->getRelocationAddress(RelocationPimpl);
+}
+
 inline uint64_t RelocationRef::getOffset() const {
   return OwningObject->getRelocationOffset(RelocationPimpl);
 }

lib/Object/COFFObjectFile.cpp

             reinterpret_cast<const coff_relocation*>(Rel.p) + 1);
 }
 
+uint64_t COFFObjectFile::getRelocationAddress(DataRefImpl Rel) const {
+  const coff_relocation *R = toRel(Rel);
+  return R->VirtualAddress;
+}
+
 uint64_t COFFObjectFile::getRelocationOffset(DataRefImpl Rel) const {
   const coff_relocation *R = toRel(Rel);
   return R->VirtualAddress;

lib/Object/MachOObjectFile.cpp

   ++Rel.d.b;
 }
 
+uint64_t MachOObjectFile::getRelocationAddress(DataRefImpl Rel) const {
+  assert((getHeader().filetype == MachO::MH_DYLIB ||
+          getHeader().filetype == MachO::MH_EXECUTE) &&
+         "Only implemented for MH_DYLIB and MH_EXECUTE");
+  MachO::any_relocation_info RE = getRelocation(Rel);
+  return getAnyRelocationAddress(RE);
+}
+
 uint64_t MachOObjectFile::getRelocationOffset(DataRefImpl Rel) const {
   assert(getHeader().filetype == MachO::MH_OBJECT &&
          "Only implemented for MH_OBJECT");

test/tools/llvm-objdump/X86/relocations-in-nonrelocatable.test

+// This test checks that relocation in nonrelocatable files are printed
+// RUN: llvm-objdump -r %p/Inputs/relocations-in-nonrelocatable.elf-x86_64 | FileCheck %s
+
+// (main.c)
+// void g(void){}
+// int main(void) { g(); };
+// gcc main.c -o main -Wl,--emit-relocs
+
+CHECK: 00000000000000f8 R_X86_64_PC32 g-4-P
 No newline at end of file

tools/llvm-objdump/llvm-objdump.cpp

   }
   }
   symbol_iterator SI = RelRef.getSymbol();
-  const Elf_Sym *symb = Obj->getSymbol(SI->getRawDataRefImpl());
   StringRef Target;
-  if (symb->getType() == ELF::STT_SECTION) {
-    ErrorOr<section_iterator> SymSI = SI->getSection();
-    if (std::error_code EC = SymSI.getError())
-      return EC;
-    const Elf_Shdr *SymSec = Obj->getSection((*SymSI)->getRawDataRefImpl());
-    ErrorOr<StringRef> SecName = EF.getSectionName(SymSec);
-    if (std::error_code EC = SecName.getError())
-      return EC;
-    Target = *SecName;
-  } else {
-    ErrorOr<StringRef> SymName = symb->getName(StrTab);
-    if (!SymName)
-      return SymName.getError();
-    Target = *SymName;
-  }
+  if (SI != Obj->symbol_end()) {
+    const Elf_Sym *symb = Obj->getSymbol(SI->getRawDataRefImpl());
+    if (symb->getType() == ELF::STT_SECTION) {
+      ErrorOr<section_iterator> SymSI = SI->getSection();
+      if (std::error_code EC = SymSI.getError())
+        return EC;
+      const Elf_Shdr *SymSec = Obj->getSection((*SymSI)->getRawDataRefImpl());
+      ErrorOr<StringRef> SecName = EF.getSectionName(SymSec);
+      if (std::error_code EC = SecName.getError())
+        return EC;
+      Target = *SecName;
+    } else {
+      ErrorOr<StringRef> SymName = symb->getName(StrTab);
+      if (!SymName)
+        return SymName.getError();
+      Target = *SymName;
+    }
+  } else
+    Target = "*ABS*";
   switch (EF.getHeader()->e_machine) {
   case ELF::EM_X86_64:
     switch (type) {

 void llvm::PrintRelocations(const ObjectFile *Obj) {
   StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64 :
                                                  "%08" PRIx64;
-  // Regular objdump doesn't print relocations in non-relocatable object
-  // files.
-  if (!Obj->isRelocatableObject())
-    return;
 
+  std::map <uint64_t, SectionRef> SectionAddress;
+  for (section_iterator i (Obj->section_begin()), n (Obj->section_end()); i != n; ++i)
+    SectionAddress [i->getAddress()] = *i;
   for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
+    bool PrintHeader = true;
     if (Section.relocation_begin() == Section.relocation_end())
       continue;
-    StringRef secname;
-    error(Section.getName(secname));
-    outs() << "RELOCATION RECORDS FOR [" << secname << "]:\n";
     for (const RelocationRef &Reloc : Section.relocations()) {
+      if (Reloc.isDynamic())
+        continue;
+      if (PrintHeader) {
+        StringRef secname;
+        error(Section.getName(secname));
+        outs() << "RELOCATION RECORDS FOR [" << secname << "]:\n";
+        PrintHeader = false;
+      }
       bool hidden = getHidden(Reloc);
-      uint64_t address = Reloc.getOffset();
+      uint64_t Address;
+      if (Obj->isRelocatableObject())
+        Address = Reloc.getOffset();
+      else {
+        Address = Reloc.getAddress();
+        auto BoundingSection = SectionAddress.upper_bound(Address);
+        if (BoundingSection == SectionAddress.begin())
+          // Lower than any section
+          continue;
+        --BoundingSection;
+        if ((BoundingSection->first + BoundingSection->second.getSize()) < Address)
+          // Not in closest section
+          continue;
+        Address -= BoundingSection->first;
+      }
       SmallString<32> relocname;
       SmallString<32> valuestr;
       if (hidden)

         continue;
       Reloc.getTypeName(relocname);
       error(getRelocationValueString(Reloc, valuestr));
-      outs() << format(Fmt.data(), address) << " " << relocname << " "
+      outs() << format(Fmt.data(), Address) << " " << relocname << " "
              << valuestr << "\n";
     }
     outs() << "\n";