[llvm-objdump] - Print relocation record in a GNU format.

[grimar]

Summary

This fixes the https://bugs.llvm.org/show_bug.cgi?id=41355.

Previously with -r we printed relocation section name instead of the target section name.
It was like this: "RELOCATION RECORDS FOR [.rel.text]"
Now it is: "RELOCATION RECORDS FOR [.text]"

Also when relocation target section has more than one relocation section,
we did not combine the output. Now we do.

[rupprecht]

lgtm, thanks!

[jhenderson]

include/llvm/Object/ObjectFile.h

426 ↗

(On Diff #197321)

I'm not sure I understand what the purpose of this check and the similar ones below is? In what cases could SectionPimpl ever equal Other.SectionPimpl and need disambugiating on the OwningObject?

test/tools/llvm-objdump/relocations-elf.test

78 ↗

(On Diff #197321)

This is not a nice error. Can anything be done easily to improve it?

[MaskRay]

test/tools/llvm-objdump/relocations-elf.test

78 ↗

(On Diff #197321)

This message is associated with

static ManagedStatic<_object_error_category> error_category;

const std::error_category &object::object_category() {
  return *error_category;
}

I think more ErrorOr in lib/Object should migrate to Expected/Error to fix this. That improvement is not related to this patch.

[grimar]

include/llvm/Object/ObjectFile.h

426 ↗

(On Diff #197321)

In this patch I had to implement DenseMapInfo<object::SectionRef>
and particulary the getEmptyKey():

template <> struct DenseMapInfo<object::SectionRef> {
...
  static object::SectionRef getEmptyKey() {
    return object::SectionRef({}, nullptr);
  }

In this case OwningObject == nullptr and SectionPimpl is zeroed.

Problem was observer in the following test cases:

    LLVM :: tools/llvm-objdump/AArch64/macho-reloc-addend.test
    LLVM :: tools/llvm-objdump/ARM/macho-reloc-half.test

Assertion failed: !KeyInfoT::isEqual(Val, EmptyKey) && !KeyInfoT::isEqual(Val, T
ombstoneKey) && "Empty/Tombstone value shouldn't be inserted into map!"

It is coming from MachO implementation of section_begin and section_end:

section_iterator MachOObjectFile::section_begin() const {
  DataRefImpl DRI;
  return section_iterator(SectionRef(DRI, this));
}

section_iterator MachOObjectFile::section_end() const {
  DataRefImpl DRI;
  DRI.d.a = Sections.size();
  return section_iterator(SectionRef(DRI, this));
}

SectionRef created by section_begin has SectionPimpl (DataRefImpl) that is zeroed.
The only way to distinguish it from empty key is to check the owning object.

BTW, the same would probably be observed for Wasm:

section_iterator WasmObjectFile::section_begin() const {
  DataRefImpl Ref;
  Ref.d.a = 0;
  return section_iterator(SectionRef(Ref, this));
}

section_iterator WasmObjectFile::section_end() const {
  DataRefImpl Ref;
  Ref.d.a = Sections.size();
  return section_iterator(SectionRef(Ref, this));
}

test/tools/llvm-objdump/relocations-elf.test

78 ↗

(On Diff #197321)

It is coming from llvm/Object/ELFObjectFile.h:
https://github.com/llvm-mirror/llvm/blob/master/include/llvm/Object/ELFObjectFile.h#L844

auto R = EF.getSection(EShdr->sh_info);
if (!R)
  report_fatal_error(errorToErrorCode(R.takeError()).message());

Which finally calls report_fatal_error which is LLVM_ATTRIBUTE_NORETURN.
So answering your question - I do not see a easy way to improve it in this patch.

[MaskRay]

include/llvm/Object/ObjectFile.h

432 ↗

(On Diff #197321)

Just use && for operator== and implement operator!= in terms of operator==?

[grimar]

• Addressed review comments.
• Cosmetic change in the test case.

include/llvm/Object/ObjectFile.h

432 ↗

(On Diff #197321)

Yes, that is better. Done.

[grimar]

James, are you OK with this patch?

[jhenderson]

LGTM, with a nit.

test/tools/llvm-objdump/relocations-elf.test

74 ↗

(On Diff #197562)

I think this would be a bit clearer:
"Check we report an error if the relocated section identified by the sh_info field of a relocation section is invalid."

78 ↗

(On Diff #197321)

Okay, fair enough. There are definitely some improvements that could be made there. We shouldn't really be hitting report_fatal_error inside this sort of code, if we don't absolutely have to.

llvm/trunk/include/llvm/Object/ObjectFile.h

 //===- ObjectFile.h - File format independent object file -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares a file format independent ObjectFile class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_OBJECTFILE_H
 #define LLVM_OBJECT_OBJECTFILE_H
 
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/SymbolicFile.h"

 
 /// SectionRef
 inline SectionRef::SectionRef(DataRefImpl SectionP,
                               const ObjectFile *Owner)
   : SectionPimpl(SectionP)
   , OwningObject(Owner) {}
 
 inline bool SectionRef::operator==(const SectionRef &Other) const {
-  return SectionPimpl == Other.SectionPimpl;
+  return OwningObject == Other.OwningObject &&
+         SectionPimpl == Other.SectionPimpl;
 }
 
 inline bool SectionRef::operator!=(const SectionRef &Other) const {
-  return SectionPimpl != Other.SectionPimpl;
+  return !(*this == Other);
 }
 
 inline bool SectionRef::operator<(const SectionRef &Other) const {
+  assert(OwningObject == Other.OwningObject);
   return SectionPimpl < Other.SectionPimpl;
 }
 
 inline void SectionRef::moveNext() {
   return OwningObject->moveSectionNext(SectionPimpl);
 }
 
 inline std::error_code SectionRef::getName(StringRef &Result) const {

 }
 
 inline const ObjectFile *RelocationRef::getObject() const {
   return OwningObject;
 }
 
 } // end namespace object
 
+template <> struct DenseMapInfo<object::SectionRef> {
+  static bool isEqual(const object::SectionRef &A,
+                      const object::SectionRef &B) {
+    return A == B;
+  }
+  static object::SectionRef getEmptyKey() {
+    return object::SectionRef({}, nullptr);
+  }
+  static object::SectionRef getTombstoneKey() {
+    object::DataRefImpl TS;
+    TS.p = (uintptr_t)-1;
+    return object::SectionRef(TS, nullptr);
+  }
+  static unsigned getHashValue(const object::SectionRef &Sec) {
+    object::DataRefImpl Raw = Sec.getRawDataRefImpl();
+    return hash_combine(Raw.p, Raw.d.a, Raw.d.b);
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_OBJECTFILE_H

llvm/trunk/test/CodeGen/BPF/reloc-btf.ll

 ; RUN: llc -march=bpfel -filetype=obj < %s | llvm-objdump -r - | FileCheck --check-prefix=CHECK-RELOC %s
 
 ; Function Attrs: norecurse nounwind readnone
 define dso_local i32 @test() local_unnamed_addr #0 !dbg !7 {
 entry:
   ret i32 0, !dbg !11
 }
 
 ; CHECK-RELOC: file format ELF64-BPF
-; CHECK-RELOC: RELOCATION RECORDS FOR [.rel.debug_info]:
+; CHECK-RELOC: RELOCATION RECORDS FOR [.debug_info]:
 ; CHECK-RELOC: R_BPF_64_32 .debug_abbrev
 ; CHECK-RELOC: R_BPF_64_64 .text
-; CHECK-RELOC: RELOCATION RECORDS FOR [.rel.BTF.ext]:
+; CHECK-RELOC: RELOCATION RECORDS FOR [.BTF.ext]:
 ; CHECK-RELOC: R_BPF_NONE .text
 
 attributes #0 = { norecurse nounwind readnone "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4, !5}
 !llvm.ident = !{!6}
 

llvm/trunk/test/CodeGen/BPF/reloc.ll

; <label>:10                                      ; preds = %0
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %11, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @bpf_prog1.fmt, i64 0, i64 0), i64 15, i1 false)
   %12 = call i32 (i8*, i32, ...) inttoptr (i64 11 to i32 (i8*, i32, ...)*)(i8* %11, i32 15, %struct.sk_buff* %4, i8* %7) #1
   br label %13
 
 ; <label>:13                                      ; preds = %10, %0
   ret i32 0
 
 ; CHECK-RELOC: file format ELF64-BPF
-; CHECK-RELOC: RELOCATION RECORDS FOR [.rel.eh_frame]:
+; CHECK-RELOC: RELOCATION RECORDS FOR [.eh_frame]:
 ; CHECK-RELOC: R_BPF_64_64 events/net/netif_receive_skb
 }
 
 ; Function Attrs: nounwind
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #1
 
 attributes #0 = { norecurse }

llvm/trunk/test/DebugInfo/X86/DW_AT_location-reference.ll

 ; CHECK-NEXT:   DW_AT_decl_file
 ; CHECK-NEXT:   DW_AT_decl_line
 ; CHECK-NEXT:   DW_AT_type
 
 ; Check that we have no relocations in Darwin's output.
 ; DARWIN-NOT: X86_64_RELOC{{.*}} __debug_loc
 
 ; Check we have a relocation for the debug_loc entry in Linux output.
-; LINUX: RELOCATION RECORDS FOR [.rela.debug_info]
+; LINUX: RELOCATION RECORDS FOR [.debug_info]
 ; LINUX-NOT: RELOCATION RECORDS
 ; LINUX: R_X86_64{{.*}} .debug_loc
 
 ; ModuleID = 'simple.c'
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n32"
 
 @a = external global i32
 

llvm/trunk/test/DebugInfo/X86/split-dwarf-cross-unit-reference.ll

 ; * debug_info uses relocations and ref_addr no matter what
 ; * debug_info.dwo uses relocations for types as well as abstract subprograms
 ;   and variables when -split-dwarf-cross-cu-references is used
 ; * debug_info.dwo contains duplicate types, abstract subprograms and abstract
 ;   variables otherwise to avoid the need for cross-cu references
 
 ; DWO: .debug_info.dwo contents:
 ; CHECK-NOT: .rel{{a?}}.debug_info.dwo
-; CHECK: RELOCATION RECORDS FOR [.rel{{a?}}.debug_info]:
+; CHECK: RELOCATION RECORDS FOR [.debug_info]:
 ; CHECK-NOT: RELOCATION RECORDS
 ; Expect one relocation in debug_info, from the inlined f1 in foo to its
 ; abstract origin in bar
 ; CHECK: R_X86_64_32 .debug_info
 ; CHECK-NOT: RELOCATION RECORDS
 ; CHECK-NOT: .debug_info
 ; CHECK: RELOCATION RECORDS
 ; CHECK-NOT: .rel{{a?}}.debug_info.dwo

llvm/trunk/test/MC/AArch64/basic-pic.s

 // RUN: llvm-mc -triple=aarch64-none-linux-gnu -filetype=obj %s -o -| llvm-objdump -r - | FileCheck %s
 
-// CHECK: RELOCATION RECORDS FOR [.rela.text]
+// CHECK: RELOCATION RECORDS FOR [.text]
 
   .file "/home/espindola/llvm/llvm/test/CodeGen/AArch64/basic-pic.ll"
   .text
   .globl  get_globalvar
   .type get_globalvar,@function
 get_globalvar:                          // @get_globalvar
   .cfi_startproc
 // %bb.0:

llvm/trunk/test/MC/ARM/dwarf-asm-multiple-sections-dwarf-2.s

 // DWARF:      0x0000000000000000     11      0      1   0   0 is_stmt
 // DWARF-NEXT: 0x0000000000000004     11      0      1   0   0 is_stmt end_sequence
 
 
 // DWARF-NOT: .debug_ranges contents:
 // DWARF-NOT: .debug_pubnames contents:
 
 
-// RELOC: RELOCATION RECORDS FOR [.rel.debug_info]:
+// RELOC: RELOCATION RECORDS FOR [.debug_info]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_abbrev
 // RELOC-NEXT: 0000000c R_ARM_ABS32 .debug_line
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 foo
 
-// RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_ranges]:
+// RELOC-NOT: RELOCATION RECORDS FOR [.debug_ranges]:
 
-// RELOC: RELOCATION RECORDS FOR [.rel.debug_aranges]:
+// RELOC: RELOCATION RECORDS FOR [.debug_aranges]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_info
 // RELOC-NEXT: 00000010 R_ARM_ABS32 .text
 // RELOC-NEXT: 00000018 R_ARM_ABS32 foo

llvm/trunk/test/MC/ARM/dwarf-asm-multiple-sections.s

 // DWARF: 00000000 00000000 00000004
 // DWARF: 00000000 ffffffff 00000000
 // DWARF: 00000000 00000000 00000004
 // DWARF: 00000000 <End of list>
 
 
 
 // Offsets are different in DWARF v5 due to different header layout.
-// RELOC: RELOCATION RECORDS FOR [.rel.debug_info]:
+// RELOC: RELOCATION RECORDS FOR [.debug_info]:
 // RELOC4-NEXT: 00000006 R_ARM_ABS32 .debug_abbrev
 // RELOC4-NEXT: 0000000c R_ARM_ABS32 .debug_line
 // RELOC4-NEXT: 00000010 R_ARM_ABS32 .debug_ranges
 // RELOC5-NEXT: 00000008 R_ARM_ABS32 .debug_abbrev
 // RELOC5-NEXT: 0000000d R_ARM_ABS32 .debug_line
 // RELOC5-NEXT: 00000011 R_ARM_ABS32 .debug_ranges
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 foo
 
-// RELOC: RELOCATION RECORDS FOR [.rel.debug_ranges]:
+// RELOC: RELOCATION RECORDS FOR [.debug_ranges]:
 // RELOC-NEXT: 00000004 R_ARM_ABS32 .text
 // RELOC-NEXT: 00000014 R_ARM_ABS32 foo
 
-// RELOC: RELOCATION RECORDS FOR [.rel.debug_aranges]:
+// RELOC: RELOCATION RECORDS FOR [.debug_aranges]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_info
 // RELOC-NEXT: 00000010 R_ARM_ABS32 .text
 // RELOC-NEXT: 00000018 R_ARM_ABS32 foo
 
 
 // VERSION: {{.*}} warning: DWARF2 only supports one section per compilation unit
 
 // DWARF1: Dwarf version 1 is not supported.
 // DWARF6: Dwarf version 6 is not supported.

llvm/trunk/test/MC/ARM/dwarf-asm-nonstandard-section.s

 // DWARF-NEXT: 0x0000000000000004      7      0      1   0   0  is_stmt end_sequence
 
 
 // DWARF-NOT: .debug_ranges contents:
 // DWARF-NOT: .debug_pubnames contents:
 
 
 
-// RELOC: RELOCATION RECORDS FOR [.rel.debug_info]:
+// RELOC: RELOCATION RECORDS FOR [.debug_info]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_abbrev
 // RELOC-NEXT: 0000000c R_ARM_ABS32 .debug_line
 // RELOC-NEXT: R_ARM_ABS32 foo
 // RELOC-NEXT: R_ARM_ABS32 foo
 // RELOC-NEXT: R_ARM_ABS32 foo
 
-// RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_ranges]:
+// RELOC-NOT: RELOCATION RECORDS FOR [.debug_ranges]:
 
-// RELOC: RELOCATION RECORDS FOR [.rel.debug_aranges]:
+// RELOC: RELOCATION RECORDS FOR [.debug_aranges]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_info
 // RELOC-NEXT: 00000010 R_ARM_ABS32 foo

llvm/trunk/test/MC/ARM/dwarf-asm-single-section.s

 // DWARF:      0x0000000000000000      7      0      1   0   0 is_stmt
 // DWARF-NEXT: 0x0000000000000004      7      0      1   0   0 is_stmt end_sequence
 
 
 // DWARF-NOT: .debug_ranges contents:
 // DWARF-NOT: .debug_pubnames contents:
 
 
-// RELOC: RELOCATION RECORDS FOR [.rel.debug_info]:
+// RELOC: RELOCATION RECORDS FOR [.debug_info]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_abbrev
 // RELOC-NEXT: 0000000c R_ARM_ABS32 .debug_line
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 .text
 // RELOC-NEXT: R_ARM_ABS32 .text
 
-// RELOC-NOT: RELOCATION RECORDS FOR [.rel.debug_ranges]:
+// RELOC-NOT: RELOCATION RECORDS FOR [.debug_ranges]:
 
-// RELOC: RELOCATION RECORDS FOR [.rel.debug_aranges]:
+// RELOC: RELOCATION RECORDS FOR [.debug_aranges]:
 // RELOC-NEXT: 00000006 R_ARM_ABS32 .debug_info
 // RELOC-NEXT: 00000010 R_ARM_ABS32 .text

llvm/trunk/test/MC/ARM/symbol-variants.s

 @ RUN: llvm-mc < %s -triple armv7-none-linux-gnueabi -filetype=obj  | llvm-objdump -triple armv7-none-linux-gnueabi -r - | FileCheck %s --check-prefix=CHECK --check-prefix=ARM
 @ RUN: llvm-mc < %s -triple thumbv7-none-linux-gnueabi -filetype=obj  | llvm-objdump -triple thumbv7-none-linux-gnueabi -r - | FileCheck %s --check-prefix=CHECK --check-prefix=THUMB
 
-@ CHECK-LABEL: RELOCATION RECORDS FOR [.rel.text]
+@ CHECK-LABEL: RELOCATION RECORDS FOR [.text]
 .Lsym:
 
 @ empty
 .word f00
 .word f01
 @CHECK: 0 R_ARM_ABS32 f00
 @CHECK: 4 R_ARM_ABS32 f01
 

llvm/trunk/test/MC/Hexagon/extended_relocations.ll

 ; RUN: llc -filetype=obj -march=hexagon %s -o - | llvm-objdump -r - | FileCheck %s
 
-; CHECK: RELOCATION RECORDS FOR [.rela.text]:
+; CHECK: RELOCATION RECORDS FOR [.text]:
 ; CHECK: 00000000 R_HEX_B22_PCREL printf
 ; CHECK: 00000004 R_HEX_32_6_X .rodata.str1.1
 ; CHECK: 00000008 R_HEX_6_X .rodata.str1.1
 
 target triple = "hexagon-unknown--elf"
 
 @.str = private unnamed_addr constant [10 x i8] c"cxfir.log\00", align 1
 

llvm/trunk/test/Object/objdump-relocations.test

 ELF-hexagon: R_HEX_B15_PCREL testf
 ELF-hexagon: R_HEX_B22_PCREL puts
 
 // Note: this file was produced with gas to make sure we don't end up in a
 // situation where LLVM produces and accepts a broken file.
 ELF-MIPS64EL: .data
 ELF-MIPS64EL: R_MIPS_64/R_MIPS_NONE/R_MIPS_NONE zed
 
-ELF-MIPSEL: .rel.text
+ELF-MIPSEL: .text
 ELF-MIPSEL: R_MIPS_HI16 _gp_disp
 ELF-MIPSEL: R_MIPS_LO16 _gp_disp
 ELF-MIPSEL: R_MIPS_GOT16 $.str
 ELF-MIPSEL: R_MIPS_LO16 $.str
 ELF-MIPSEL: R_MIPS_CALL16 puts
 ELF-MIPSEL: R_MIPS_CALL16 SomeOtherFunction
 
 WASM:      CODE

llvm/trunk/test/Object/objdump-shndx.test

 RUN: llvm-objdump -r %p/Inputs/shndx.elf | FileCheck %s
 
 Test that llvm-objdump can handle shndx. The relocation points to a section
 symbol that has st_shndx == SHN_XINDEX. To print the section name llvm-objdump
 has to use the shndx section.
 
-CHECK:      RELOCATION RECORDS FOR [.rela.text]:
+CHECK:      RELOCATION RECORDS FOR [.text]:
 CHECK-NEXT: 0000000000000000 R_X86_64_32 bar

llvm/trunk/test/tools/llvm-objdump/relocations-elf.test

-# RUN: yaml2obj %s > %t
+# RUN: yaml2obj --docnum=1 %s > %t
 # RUN: llvm-objdump --reloc %t > %t1
 # RUN: llvm-objdump -r      %t > %t2
 # RUN: cmp %t1 %t2
 # RUN: FileCheck %s --input-file=%t1
 
-# CHECK: RELOCATION RECORDS FOR [.rel.text]:
-# CHECK: 0000000000000001 R_X86_64_32 glob1
-# CHECK: 0000000000000001 R_X86_64_32S glob2
-# CHECK: 0000000000000002 R_X86_64_64 loc1
-
-# CHECK: RELOCATION RECORDS FOR [.rela.text]:
-# CHECK: 0000000000000001 R_X86_64_32 glob1+1
-# CHECK: 0000000000000001 R_X86_64_32S glob2+2
-# CHECK: 0000000000000002 R_X86_64_64 loc1+3
+# CHECK:      RELOCATION RECORDS FOR [.text]:
+# CHECK-NEXT: 0000000000000001 R_X86_64_32 glob1
+# CHECK-NEXT: 0000000000000001 R_X86_64_32S glob2
+# CHECK-NEXT: 0000000000000002 R_X86_64_64 loc1
+# CHECK-NEXT: 0000000000000001 R_X86_64_32 glob1+1
+# CHECK-NEXT: 0000000000000001 R_X86_64_32S glob2+2
+# CHECK-NEXT: 0000000000000002 R_X86_64_64 loc1+3
 
-!ELF
+--- !ELF
 FileHeader: !FileHeader
   Class: ELFCLASS64
   Data: ELFDATA2LSB
   Type: ET_REL
   Machine: EM_X86_64
 
 Sections:
 - Name: .text
Symbols:
   - Name: loc2
   - Name:    glob1
     Section: .text
     Value:   0x0
     Size:    4
     Binding: STB_GLOBAL
   - Name:    glob2
     Binding: STB_GLOBAL
+
+## Check we report an error if the relocated section identified by the
+## sh_info field of a relocation section is invalid.
+# RUN: yaml2obj --docnum=2 %s > %t2
+# RUN: not llvm-objdump --reloc %t2 2>&1 | FileCheck %s --check-prefix=ERR
+# ERR: LLVM ERROR: Invalid data was encountered while parsing the file
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data: ELFDATA2LSB
+  Type: ET_REL
+  Machine: EM_X86_64
+Sections:
+- Name: .rela.foo
+  Type: SHT_RELA
+  Link: .symtab
+  Info: 0x255
+  Relocations:
+    - Offset: 0x1
+      Type: R_X86_64_NONE

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

 void 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;
 
+  // Build a mapping from relocation target to a vector of relocation
+  // sections. Usually, there is an only one relocation section for
+  // each relocated section.
+  MapVector<SectionRef, std::vector<SectionRef>> SecToRelSec;
   for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     if (Section.relocation_begin() == Section.relocation_end())
       continue;
+    const SectionRef TargetSec = *Section.getRelocatedSection();
+    SecToRelSec[TargetSec].push_back(Section);
+  }
+
+  for (std::pair<SectionRef, std::vector<SectionRef>> &P : SecToRelSec) {
     StringRef SecName;
-    error(Section.getName(SecName));
+    error(P.first.getName(SecName));
     outs() << "RELOCATION RECORDS FOR [" << SecName << "]:\n";
+
+    for (SectionRef Section : P.second) {
       for (const RelocationRef &Reloc : Section.relocations()) {
         uint64_t Address = Reloc.getOffset();
         SmallString<32> RelocName;
         SmallString<32> ValueStr;
         if (Address < StartAddress || Address > StopAddress || getHidden(Reloc))
           continue;
         Reloc.getTypeName(RelocName);
         error(getRelocationValueString(Reloc, ValueStr));
         outs() << format(Fmt.data(), Address) << " " << RelocName << " "
                << ValueStr << "\n";
       }
+    }
     outs() << "\n";
   }
 }
 
 void printDynamicRelocations(const ObjectFile *Obj) {
   // For the moment, this option is for ELF only
   if (!Obj->isELF())
     return;