[llvm-readobj] - Report warnings instead of errors for broken relocations.

[grimar]

Summary

This is a follow-up for https://reviews.llvm.org/D74545.

It adds test cases for each incorrect case returned in getRelocationTarget.

[grimar]

Will check something.

[grimar]

• Improved how errors looks like.
• Fixed one more test case.

[MaskRay]

llvm/test/Object/invalid.test

420–421

We probably should split invalid.test. For example, segments related errors and sections related errors can be separated.

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

1 ↗

(On Diff #244607)

Maybe relocation-errors.test?

llvm/tools/llvm-readobj/ELFDumper.cpp

3339

Target->first

5772

Target->second

[grimar]

• Addressed review comments.

llvm/test/Object/invalid.test

420–421

It feels that some of the tests might go to the corresponding tools test folders.
(e.g. docnum 21 below)

[jhenderson]

llvm/test/Object/invalid.test

420–421

Better yet would be to replace those tests which are testing library code with gtest unit tests to test the interfaces directly instead (and then additional tests in the tools folder to show the tools correctly handle the respective places properly).

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

2

Delete "do"

56–59

Seems like this overlaps with reloc-no-sym.test? Could we get rid of one or the other?

70

relocation in a section...

71

is neither SHT_SYMTAB nor SHT_DYNSYM

[grimar]

• Addressed review comments.

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

56–59

This one is a bit different: here we have a SHT_REL section.
(I can't test an addend here, like reloc-no-sym.test do).

And the intention to have it also was to show the order of warnings/normal relocations.
I.e. I wanted to have at least one valid relocation in the middle and
"relocation against a symbol with index 0" works good as it is related to the context and the
current code.

So, I'd keep both. (btw, reloc-no-sym.test seems lacks GNU test and SHT_REL test and might need to be improved).

[jhenderson]

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

48

no a symbol -> no symbol
index of -> index

llvm/tools/llvm-readobj/ELFDumper.cpp

3336–3337

I'm not sure this error message quite makes sense. To me, I read it as dumping the relocation at file offset 0x1234 (i.e. where the relocation is physically stored in the file), whereas the offset is the section-relative offset.

Perhaps this error should print the index of the relocation and its section, i.e. something like "unable to print the relocation with index 4 in .rela.text: ...". I'd also recommend the phrasing I've used there regarding "unable to print" instead of "error dumping".

Same comment goes for LLVM style.

By the way, would it not make sense to print something like "<?>" or "<corrupt>" etc for the invalid values?

[grimar]

• Addressed review comments.

llvm/tools/llvm-readobj/ELFDumper.cpp

3336–3337

By the way, would it not make sense to print something like "<?>" or "<corrupt>" etc for the invalid values?

Yes. I had an experiment about refactoring the getRelocationTarget method (used getFullSymbolName for STT_SECTION symbols path as it has very similar code). As a result I had 2 warnings of this patch gone and "<?>" displayed.
I think we might want both: i.e. to show a warning about what is wrong about the object parsed and to dump a relocation, using "<?>" if needed. It seems to be a good possible follow-up change.

Perhaps this error should print the index of the relocation and its section, i.e. something like "unable to print the relocation with index 4 in .rela.text: ...". I'd also recommend the phrasing I've used there regarding "unable to print" instead of "error dumping".

I've applied your suggestion with a change: I've used a section index instead of a section name in the error message:
this is more consistent with our others errors. Looks fine?

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

3336–3337

Looks fine, if a little verbose. Do you think something like "unable to print relocation 1 in section 2 ..." would be sufficient?

[grimar]

llvm/tools/llvm-readobj/ELFDumper.cpp

3336–3337

It sounds fine to me. I'll apply.

[grimar]

• Addressed review comment.

[jhenderson]

LGTM.

llvm/include/llvm/Object/ELF.h

 }
 
 template <class ELFT>
 Expected<StringRef>
 ELFFile<ELFT>::getStringTableForSymtab(const Elf_Shdr &Sec,
                                        Elf_Shdr_Range Sections) const {
 
   if (Sec.sh_type != ELF::SHT_SYMTAB && Sec.sh_type != ELF::SHT_DYNSYM)
-    // TODO: this error is untested.
     return createError(
         "invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM");
   auto SectionOrErr = object::getSection<ELFT>(Sections, Sec.sh_link);
   if (!SectionOrErr)
     return SectionOrErr.takeError();
   return getStringTable(*SectionOrErr);
 }
 

llvm/test/Object/invalid.test

 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
   SHNum:   0xFF
 
-## Check that llvm-readobj reports an error if a relocation contains an
-## incorrect (too large) symbol index.
-
-# RUN: yaml2obj %s --docnum=16 -o %t16
-# RUN: not llvm-readobj -r %t16 2>&1 | FileCheck -DFILE=%t16 --check-prefix=INVALID-REL-SYM %s
-
-# INVALID-REL-SYM: error: '[[FILE]]': unable to access section [index 2] data at 0x18000040: offset goes past the end of file
-
---- !ELF
-FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_REL
-  Machine: EM_X86_64
-Sections:
-  - Name: .rela.text
-    Type: SHT_RELA
-    Info: 0
-    Relocations:
-      - Offset: 0x0
-        Type:   R_X86_64_64
-        Symbol: 0xFFFFFF
-Symbols: []
-
 ## Check llvm-readobj does not crash on a truncated ELF.
 
 ## Create a truncated ELF object with ELFCLASSNONE class using echo.
 ## 0x7f, 'E', 'L', 'F', ELFCLASS64(2), ELFDATA2LSB(1),
 ## EV_CURRENT(1), ELFOSABI_LINUX(3), <padding zero bytes>, ET_REL(1), EM_NONE(0)
 # RUN: echo -e -n "\x7f\x45\x4c\x46\x02\x01\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" > %t11
 # RUN: not llvm-readobj -r %t11 2>&1 | FileCheck --check-prefix=INVALID-BUFFER %s
 
 # INVALID-BUFFER: error: {{.*}}': invalid buffer: the size (18) is smaller than an ELF header (64)
 
 # RUN: not llvm-readobj %p/Inputs/invalid-coff-header-too-small 2>&1 | FileCheck --check-prefix=COFF-HEADER %s
 # COFF-HEADER: The file was not recognized as a valid object file
 
 ## Check that llvm-readobj reports an error if section name offset
 ## overflows the section name string table.
 
-# RUN: yaml2obj %s --docnum=17 -o %t17
-# RUN: llvm-readobj --sections %t17 2>&1 | FileCheck -DFILE=%t17 --check-prefix=BROKEN-SECNAME %s
+# RUN: yaml2obj %s --docnum=16 -o %t16
+# RUN: llvm-readobj --sections %t16 2>&1 | FileCheck -DFILE=%t16 --check-prefix=BROKEN-SECNAME %s
 
 ## BROKEN-SECNAME: warning: '[[FILE]]': a section [index 2] has an invalid sh_name (0xb) offset which goes past the end of the section name string table
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .shstrtab
     Type: SHT_STRTAB
     Size: 1
 
 ## Check that llvm-readobj reports an error if a section has a broken offset
 ## that goes past the end of the file.
 
-# RUN: yaml2obj %s --docnum=18 -o %t18
-# RUN: not llvm-readobj --sections --section-data %t18 2>&1 \
-# RUN:  | FileCheck -DFILE=%t18 --check-prefix=BROKEN-SECSHOFFSET %s
+# RUN: yaml2obj %s --docnum=17 -o %t17
+# RUN: not llvm-readobj --sections --section-data %t17 2>&1 \
+# RUN:  | FileCheck -DFILE=%t17 --check-prefix=BROKEN-SECSHOFFSET %s
 
 # BROKEN-SECSHOFFSET: error: '[[FILE]]': section [index 1] has a sh_offset (0xffff0000) + sh_size (0x0) that is greater than the file size (0x160)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name:     .foo
     Type:     SHT_PROGBITS
     ShOffset: 0xFFFF0000
 
 ## Check that llvm-readobj reports an error if symbol name
 ## offset goes past the end of the symbol string table.
 
-# RUN: yaml2obj %s --docnum=19 -o %t19
-# RUN: not llvm-readobj --symbols %t19 2>&1 | FileCheck -DFILE=%t19 --check-prefix=INVALID-SYM-NAME %s
+# RUN: yaml2obj %s --docnum=18 -o %t18
+# RUN: not llvm-readobj --symbols %t18 2>&1 | FileCheck -DFILE=%t18 --check-prefix=INVALID-SYM-NAME %s
 
 # INVALID-SYM-NAME: error: '[[FILE]]': st_name (0x1) is past the end of the string table of size 0x1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .strtab
     Type: SHT_STRTAB
     Size: 1
 Symbols:
   - Name: foo
 
 ## Version index in .gnu.version overflows the version map.
 ## Check llvm-readobj reports it.
 
-# RUN: yaml2obj %s --docnum=20 -o %t20
-# RUN: llvm-readobj -dt %t20 2>&1 | FileCheck -DFILE=%t20 --check-prefix=INVALID-VERSION %s
+# RUN: yaml2obj %s --docnum=19 -o %t19
+# RUN: llvm-readobj -dt %t19 2>&1 | FileCheck -DFILE=%t19 --check-prefix=INVALID-VERSION %s
 
 # INVALID-VERSION: warning: '[[FILE]]': SHT_GNU_versym section refers to a version index 255 which is missing
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN

 # RUN: not llvm-readobj -l %p/Inputs/corrupt-invalid-phentsize.elf.x86-64 2>&1 \
 # RUN:   | FileCheck -DFILE=%p/Inputs/corrupt-invalid-phentsize.elf.x86-64 --check-prefix=PHENTSIZE %s
 
 # PHENTSIZE: error: '[[FILE]]': invalid e_phentsize: 57
 
 ## The dynamic table contains DT_STRTAB with a value that is not in any loadable segment.
 ## Check llvm-readobj reports it.
 
-# RUN: yaml2obj %s --docnum=21 -o %t21
-# RUN: llvm-readobj --dynamic-table %t21 2>&1 | FileCheck -DFILE=%t21 --check-prefix=INVALID-DTSTRTAB %s
+# RUN: yaml2obj %s --docnum=20 -o %t20
+# RUN: llvm-readobj --dynamic-table %t20 2>&1 | FileCheck -DFILE=%t20 --check-prefix=INVALID-DTSTRTAB %s
 
 # INVALID-DTSTRTAB: warning: '[[FILE]]': Unable to parse DT_STRTAB: virtual address is not in any segment: 0xffff0000
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC

 # RUN:   %p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 2>&1 \
 # RUN:    | FileCheck -DFILE=%p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 --check-prefix=RELOC-BROKEN-ENTSIZE %s
 
 # RELOC-BROKEN-ENTSIZE: warning: '[[FILE]]': invalid DT_RELASZ value (0x18) or DT_RELAENT value (0x19)
 
 ## Check that llvm-readobj reports a warning when .dynamic section has an invalid
 ## size, which isn't a multiple of the dynamic entry size. 
 
-# RUN: yaml2obj %s --docnum=22 -o %t22
-# RUN: llvm-readobj --dyn-relocations %t22 2>&1 | FileCheck -DFILE=%t22 --check-prefix=DYN-TABLE-SIZE %s
+# RUN: yaml2obj %s --docnum=21 -o %t21
+# RUN: llvm-readobj --dyn-relocations %t21 2>&1 | FileCheck -DFILE=%t21 --check-prefix=DYN-TABLE-SIZE %s
 
 # DYN-TABLE-SIZE: warning: '[[FILE]]': section with index 1 has invalid size (0x1){{$}}
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Content: "00"
 
 ## PT_DYNAMIC's p_offset field is so large that p_offset + p_filesz is larger
 ## than the object size. Check llvm-readobj reports it.
 
-# RUN: yaml2obj %s --docnum=23 -o %t23
-# RUN: llvm-readobj --dyn-relocations %t23 2>&1 | FileCheck -DFILE=%t23 --check-prefix=DYN-TABLE-PHDR %s
+# RUN: yaml2obj %s --docnum=22 -o %t22
+# RUN: llvm-readobj --dyn-relocations %t22 2>&1 | FileCheck -DFILE=%t22 --check-prefix=DYN-TABLE-PHDR %s
 
 # DYN-TABLE-PHDR: warning: '[[FILE]]': PT_DYNAMIC segment offset + size exceeds the size of the file
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_NULL
         Value: 0
 ProgramHeaders:
   - Type:   PT_DYNAMIC
     Offset: 0xffff0000
     Sections:
       - Section: .dynamic
 
 ## PT_DYNAMIC's p_filesz field is so large that p_offset + p_filesz is larger
 ## than the object size. Check llvm-readobj reports it.
 
-# RUN: yaml2obj %s --docnum=24 -o %t24
-# RUN: llvm-readobj --dyn-relocations %t24 2>&1 \
-# RUN:  | FileCheck -DFILE=%t24 --check-prefix=DYN-TABLE-PHDR %s
+# RUN: yaml2obj %s --docnum=23 -o %t23
+# RUN: llvm-readobj --dyn-relocations %t23 2>&1 \
+# RUN:  | FileCheck -DFILE=%t23 --check-prefix=DYN-TABLE-PHDR %s
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_NULL
         Value: 0
 ProgramHeaders:
   - Type:     PT_DYNAMIC
     FileSize: 0xffff0000
     Sections:
       - Section: .dynamic
 
-# RUN: yaml2obj --docnum=25 %s -o %t25
-# RUN: not obj2yaml 2>&1 %t25 | FileCheck %s -DFILE=%t25 --check-prefix=INVALID-SHSTRNDX
+# RUN: yaml2obj --docnum=24 %s -o %t24
+# RUN: not obj2yaml 2>&1 %t24 | FileCheck %s -DFILE=%t24 --check-prefix=INVALID-SHSTRNDX
 
 # INVALID-SHSTRNDX: Error reading file: [[FILE]]: section header string table index 255 does not exist
 
 --- !ELF
 FileHeader:
   Class:    ELFCLASS64
   Data:     ELFDATA2LSB
   Type:     ET_REL
   Machine:  EM_X86_64
   SHStrNdx: 0xFF
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
 
 ## We report an error if the number of sections stored in sh_size
 ## is greater than UINT64_MAX / sizeof(Elf_Shdr) == 288230376151711743.
 ## Here we check that do not crash on a border value.
 
-# RUN: yaml2obj --docnum=26 %s -o %t26
-# RUN: not llvm-readobj -h %t26 2>&1 | FileCheck -DFILE=%t26 --check-prefix=INVALID-SEC-NUM1 %s
+# RUN: yaml2obj --docnum=25 %s -o %t25
+# RUN: not llvm-readobj -h %t25 2>&1 | FileCheck -DFILE=%t25 --check-prefix=INVALID-SEC-NUM1 %s
 
 # INVALID-SEC-NUM1: error: '[[FILE]]': invalid section header table offset (e_shoff = 0x58) or invalid number of sections specified in the first section header's sh_size field (0x3ffffffffffffff)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
   SHNum:   0x0
 Sections:
   - Type: SHT_NULL
     Size: 288230376151711743
 
 ## See above, but now we test the UINT64_MAX / sizeof(Elf_Shdr) value.
 ## The error is slightly different in this case.
 
-# RUN: yaml2obj --docnum=27 %s -o %t27
-# RUN: not llvm-readobj -h %t27 2>&1 | FileCheck -DFILE=%t27 --check-prefix=INVALID-SEC-NUM2 %s
+# RUN: yaml2obj --docnum=26 %s -o %t26
+# RUN: not llvm-readobj -h %t26 2>&1 | FileCheck -DFILE=%t26 --check-prefix=INVALID-SEC-NUM2 %s
 
 # INVALID-SEC-NUM2: error: '[[FILE]]': invalid number of sections specified in the NULL section's sh_size field (288230376151711744)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
   SHNum:   0x0
 Sections:
   - Type: SHT_NULL
     Size: 288230376151711744
 
 ## Check the case when SHOff is too large. SHOff + sizeof(Elf_Shdr) overflows the uint64 type.
 
-# RUN: yaml2obj --docnum=28 %s -o %t28
-# RUN: not llvm-readobj -h %t28 2>&1 | FileCheck -DFILE=%t28 --check-prefix=INVALID-SEC-NUM3 %s
+# RUN: yaml2obj --docnum=27 %s -o %t27
+# RUN: not llvm-readobj -h %t27 2>&1 | FileCheck -DFILE=%t27 --check-prefix=INVALID-SEC-NUM3 %s
 
 # INVALID-SEC-NUM3: error: '[[FILE]]': section header table goes past the end of the file: e_shoff = 0xffffffffffffffff
  
 --- !ELF
 FileHeader:
   Class:    ELFCLASS64
   Data:     ELFDATA2LSB
   Type:     ET_REL
   Machine:  EM_X86_64
   SHOff:    0xffffffffffffffff
 
 ## Check that llvm-objdump reports an error when it tries to dump a
 ## symbol name and .strtab is empty.
 
-# RUN: yaml2obj %s --docnum=29 -o %t29
-# RUN: not llvm-objdump -syms %t29 2>&1 | FileCheck -DFILE=%t29 --check-prefix=STRTAB-EMPTY2 %s
+# RUN: yaml2obj %s --docnum=28 -o %t28
+# RUN: not llvm-objdump -syms %t28 2>&1 | FileCheck -DFILE=%t28 --check-prefix=STRTAB-EMPTY2 %s
 
 # STRTAB-EMPTY2: error: '[[FILE]]': SHT_STRTAB string table section [index 1] is empty
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .strtab
     Type: SHT_STRTAB
     Content: ""
 Symbols:
   - Name: foo
 
 ## Check that we report a warning if SHT_GNU_versym has invalid
 ## sh_entsize value (3 instead of 2) when trying to access the entries.
 
-# RUN: yaml2obj %s --docnum=30 -o %t30
-# RUN: llvm-readobj -V %t30 2>&1 | FileCheck -DFILE=%t30 --check-prefix=INVALID-VER-SHENTSIZE %s
+# RUN: yaml2obj %s --docnum=29 -o %t29
+# RUN: llvm-readobj -V %t29 2>&1 | FileCheck -DFILE=%t29 --check-prefix=INVALID-VER-SHENTSIZE %s
 
 # INVALID-VER-SHENTSIZE: warning: '[[FILE]]': cannot read content of SHT_GNU_versym section with index 1: section [index 1] has an invalid sh_entsize: 3
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   OSABI:   ELFOSABI_FREEBSD
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:    .gnu.version
     Type:    SHT_GNU_versym
     EntSize: 0x0000000000000003
     Entries: [ ]
     Link:    .dynsym
 ## Needed to trigger creation of .dynsym.
 DynamicSymbols:
   - Name:    foo
     Binding: STB_GLOBAL
 
 ## Check the case when e_shstrndx == SHN_XINDEX, but null section's sh_link contains
 ## the index of a section header string table that is larger than the number of the sections.
 
-# RUN: yaml2obj --docnum=31 %s -o %t31
-# RUN: not llvm-objcopy %t31 2>&1 | FileCheck %s -DFILE=%t31 --check-prefix=INVALID-SHSTRTAB-INDEX
+# RUN: yaml2obj --docnum=30 %s -o %t30
+# RUN: not llvm-objcopy %t30 2>&1 | FileCheck %s -DFILE=%t30 --check-prefix=INVALID-SHSTRTAB-INDEX
 
 # INVALID-SHSTRTAB-INDEX: error: section header string table index 255 does not exist
 
 --- !ELF
 FileHeader:
   Class:    ELFCLASS64
   Data:     ELFDATA2LSB
   Type:     ET_REL
   Machine:  EM_X86_64
 ## SHN_XINDEX == 0xffff.
   SHStrNdx: 0xffff
 Sections:
   - Type: SHT_NULL
     Link: 0xff

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:     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:   }
+# 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:   }
+# 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:  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-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
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:    .text
+    Type:    SHT_PROGBITS
+    Content: '00'
+  - Name:   .foo
+    Type:   SHT_PROGBITS
+    ShName: 0xFEFEFEFE
+  - Name: .rel.text
+    Type: SHT_REL
+    Info: .text
+    Relocations:
+## Case 1: There is no symbol with index 0xFEFEFEFE.
+      - Offset: 0x0
+        Symbol: 0xFEFEFEFE
+        Type:   R_X86_64_NONE
+      - Offset: 0x0
+        Symbol: 0xFEFEFEFE
+        Type:   R_X86_64_NONE
+## Case 2: Test that no warning is reported for a relocation against a symbol with index 0.
+      - Offset: 0x2
+        Symbol: 0
+        Type:   R_X86_64_NONE
+## Case 3: Test a relocation against a section symbol that has an invalid
+##         section index (larger than the number of sections).
+      - Offset: 0x3
+        Symbol: .sec.symbol1
+        Type:   R_X86_64_NONE
+## Case 4: Test a relocation against a section symbol that has an invalid
+##         sh_name offset that goes past the end of the section name string table.
+      - Offset: 0x4
+        Symbol: .sec.symbol2
+        Type:   R_X86_64_NONE
+## Case 5: Test a relocation in a section that is linked to a symbol table that
+##         has a section type that is neither SHT_SYMTAB nor SHT_DYNSYM.
+##         In this case the code fails to find a corresponding symbol string table.
+  - Name: .rela.text
+    Type: SHT_RELA
+    Info: .text
+    Link: .fake.symtab
+    Relocations:
+      - Offset: 0x5
+        Symbol: symbol
+        Type:   R_X86_64_NONE
+  - Name:    .fake.symtab
+    Type:    SHT_PROGBITS
+    EntSize: 24
+    Size:    48
+Symbols:
+  - Name:    symbol
+    Section: .text
+    Value:   0
+  - Name:  .sec.symbol1
+    Type:  STT_SECTION
+    Index: 0xFF
+  - Name:  .sec.symbol2
+    Type:  STT_SECTION
+    Index: 0x2

llvm/tools/llvm-readobj/ELFDumper.cpp

if (F.Column != 0)
       OS.PadToColumn(F.Column);
     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 printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
-                       const Elf_Rela &R, bool IsRela);
+  void printRelocation(const ELFO *Obj, unsigned SecIndex,
+                       const Elf_Shdr *SymTab, const Elf_Rela &R,
+                       unsigned RelIndex, bool IsRela);
   void printRelocation(const ELFO *Obj, const Elf_Sym *Sym,
                        StringRef SymbolName, const Elf_Rela &R, bool IsRela);
   void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
                    StringRef StrTable, bool IsDynamic,
                    bool NonVisibilityBitsUsed) override;
   std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol,
                                   const Elf_Sym *FirstSym);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela R, bool IsRela);
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 printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab);
+  void printRelocation(const ELFO *Obj, unsigned SecIndex, Elf_Rela Rel,
+                       unsigned RelIndex, const Elf_Shdr *SymTab);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel);
   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,
                    StringRef StrTable, bool IsDynamic,
                    bool /*NonVisibilityBitsUsed*/) override;
   void printProgramHeaders(const ELFO *Obj);
for (const GroupSection &G : V) {
     }
   }
 
   if (V.empty())
     OS << "There are no section groups in this file.\n";
 }
 
 template <class ELFT>
-void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
-                                     const Elf_Rela &R, bool IsRela) {
-  const typename ELFT::Sym *Sym;
-  std::string Name;
-  std::tie(Sym, Name) = unwrapOrError(
-      this->FileName, this->dumper()->getRelocationTarget(SymTab, R));
-  printRelocation(Obj, Sym, Name, R, IsRela);
+void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, unsigned SecIndex,
+                                     const Elf_Shdr *SymTab, const Elf_Rela &R,
+                                     unsigned RelIndex, bool IsRela) {
+  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
+    printRelocation(Obj, /*Sym=*/Target->first, /*Name=*/Target->second, R,
+                    IsRela);
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Sym *Sym,
                                      StringRef SymbolName, const Elf_Rela &R,
                                      bool IsRela) {
   // First two fields are bit width dependent. The rest of them are fixed width.
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) {
     }
     uintX_t Offset = Sec.sh_offset;
     OS << "\nRelocation section '" << Name << "' at offset 0x"
        << to_hexString(Offset, false) << " contains " << Entries
        << " entries:\n";
     printRelocHeader(Sec.sh_type);
     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 auto &R : unwrapOrError(this->FileName, Obj->rels(&Sec))) {
         Elf_Rela Rela;
         Rela.r_offset = R.r_offset;
         Rela.r_info = R.r_info;
         Rela.r_addend = 0;
-        printRelocation(Obj, SymTab, Rela, false);
+        printRelocation(Obj, SecNdx, SymTab, Rela, ++RelNdx, false);
       }
       break;
     case ELF::SHT_RELA:
       for (const auto &R : unwrapOrError(this->FileName, Obj->relas(&Sec)))
-        printRelocation(Obj, SymTab, R, true);
+        printRelocation(Obj, SecNdx, SymTab, R, ++RelNdx, true);
       break;
     case ELF::SHT_RELR:
     case ELF::SHT_ANDROID_RELR:
       if (opts::RawRelr)
         for (const auto &R : unwrapOrError(this->FileName, Obj->relrs(&Sec)))
           OS << to_string(format_hex_no_prefix(R, ELFT::Is64Bits ? 16 : 8))
              << "\n";
       else
         for (const auto &R : RelrRelas)
-          printRelocation(Obj, SymTab, R, false);
+          printRelocation(Obj, SecNdx, SymTab, R, ++RelNdx, false);
       break;
     case ELF::SHT_ANDROID_REL:
     case ELF::SHT_ANDROID_RELA:
       for (const auto &R : AndroidRelas)
-        printRelocation(Obj, SymTab, R, Sec.sh_type == ELF::SHT_ANDROID_RELA);
+        printRelocation(Obj, SecNdx, SymTab, R, ++RelNdx,
+                        Sec.sh_type == ELF::SHT_ANDROID_RELA);
       break;
     }
   }
   if (!HasRelocSections)
     OS << "\nThere are no relocations in this file.\n";
 }
 
 // Print the offset of a particular section from anyone of the ranges:
for (const Elf_Shdr &Sec : unwrapOrError(this->FileName, Obj->sections())) {
     W.startLine() << "}\n";
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printRelocations(const Elf_Shdr *Sec, const ELFO *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))) {
       Elf_Rela Rela;
       Rela.r_offset = R.r_offset;
       Rela.r_info = R.r_info;
       Rela.r_addend = 0;
-      printRelocation(Obj, Rela, SymTab);
+      printRelocation(Obj, SecNdx, Rela, ++RelNdx, SymTab);
     }
     break;
   case ELF::SHT_RELA:
     for (const Elf_Rela &R : unwrapOrError(this->FileName, Obj->relas(Sec)))
-      printRelocation(Obj, R, SymTab);
+      printRelocation(Obj, SecNdx, R, ++RelNdx, SymTab);
     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)
         W.startLine() << W.hex(R) << "\n";
     } else {
       std::vector<Elf_Rela> RelrRelas =
           unwrapOrError(this->FileName, Obj->decode_relrs(Relrs));
       for (const Elf_Rela &R : RelrRelas)
-        printRelocation(Obj, R, SymTab);
+        printRelocation(Obj, SecNdx, R, ++RelNdx, SymTab);
     }
     break;
   }
   case ELF::SHT_ANDROID_REL:
   case ELF::SHT_ANDROID_RELA:
     for (const Elf_Rela &R :
          unwrapOrError(this->FileName, Obj->android_relas(Sec)))
-      printRelocation(Obj, R, SymTab);
+      printRelocation(Obj, SecNdx, R, ++RelNdx, SymTab);
     break;
   }
 }
 
 template <class ELFT>
-void LLVMStyle<ELFT>::printRelocation(const ELFO *Obj, Elf_Rela Rel,
+void LLVMStyle<ELFT>::printRelocation(const ELFO *Obj, unsigned SecIndex,
+                                      Elf_Rela Rel, unsigned RelIndex,
                                       const Elf_Shdr *SymTab) {
-  std::string TargetName =
-      unwrapOrError(this->FileName,
-                    this->dumper()->getRelocationTarget(SymTab, Rel))
-          .second;
+  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);
 
   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 : "-",