[libObject, llvm-readobj] - Reimplement `ELFFile<ELFT>::getEntry`.

[grimar]

Summary

Currently, ELFFile<ELFT>::getEntry does not check an index of
an entry. Because of that the code might read past the end of the symbol
table silently. I've added a test to llvm-readobj\ELF\relocations.test
to demonstrate the possible issue. Also, I've added a unit test for
this method.

After this change, getEntry stops reporting the section index and
reuses the getSectionContentsAsArray method, which already has
all the validation needed. Our related warnings now provide
more and better context sometimes.

[jhenderson]

Does this change impact reading a dynamic symbol table for an object with no section header table? In such a case, the size is derived from the hash table, so I imagine it'll work the same, but ideally it should be tested.

llvm/test/tools/llvm-nm/invalid-symbol-table-size.test

6 ↗

(On Diff #311564)

Seems to me like this change is a regression on the old behaviour? Same with llvm-objdump and llvm-size. Please don't land it with this.

llvm/test/tools/llvm-readobj/ELF/reloc-symbol-with-versioning.test

2–6

Why did this change?

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

503

Although actually I think the comment would be better as "Check that we report a warning when a relocation has a symbol index past the end of the symbol table", to avoid confusion with an attempt to look up a symbol by name.

535–538

I'm not sure you really need these other relocations - just the one with the invalid symbol index would be enough.

llvm/unittests/Object/ELFObjectFileTest.cpp

353–354

This could be ASSERT_THAT_EXPECTED(SecOrErr, Succeeded()); right?

[grimar]

llvm/test/tools/llvm-nm/invalid-symbol-table-size.test

6 ↗

(On Diff #311564)

This is because of the following code in llvm/Object/ELFObjectFile.h

const Elf_Sym *getSymbol(DataRefImpl Sym) const {
  auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
  if (!Ret)
    report_fatal_error(Ret.takeError());
  return *Ret;
}

Previously getEntry<Elf_Sym> ignored this error
Now it started to call report_fatal_error right here.

Ideally, we should never call report_fatal_error. I am also not sure I can call it a regression,
because the code had this call before my change too. I.e. I believe it might report LLVM ERROR
for another broken input already. It is just a luck that it "worked".
And the root of the issue is in Elf_Sym *getSymbol, which should return Expected<> I think.

Do you want me to update the getSymbol first?

[jhenderson]

llvm/test/tools/llvm-nm/invalid-symbol-table-size.test

6 ↗

(On Diff #311564)

The way I see it, before we weren't getting crashes in the test and now we are, due to the reworking of the function, so it's a regression, at least for the cases that are tested. I think fixing getSymbol may be a prerequisite of this change then.

[grimar]

llvm/test/tools/llvm-nm/invalid-symbol-table-size.test

6 ↗

(On Diff #311564)

I've prepared the patch: D93297

[grimar]

• Addressed review comments.

llvm/test/tools/llvm-readobj/ELF/reloc-symbol-with-versioning.test

2–6

Left from debugging. I've added --implicit-check-not=warning: just in case,
as this test was updated to stop triggering the fixed issue.

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

535–538

I think we need at least 2 to test the new "unable to read an entry with index X" part properly.

llvm/unittests/Object/ELFObjectFileTest.cpp

353–354

I think so. But this place is gone.

[grimar]

In D93209#2454183, @jhenderson wrote:

Does this change impact reading a dynamic symbol table for an object with no section header table? In such a case, the size is derived from the hash table, so I imagine it'll work the same, but ideally it should be tested.

Nope, this patch is unrelated to dynamic symbols. I am changing getEntry(const Elf_Shdr &Section, uint32_t Entry), it accepts the Elf_Shdr.
We print dynamic relocations with the use of DynRegionInfo::getAsArrayRef() to get entries.

template <class ELFT> void DumpStyle<ELFT>::printDynamicRelocationsHelper() {
  const bool IsMips64EL = this->Obj.isMips64EL();
  const DynRegionInfo &DynRelaRegion = this->dumper().getDynRelaRegion();
  if (DynRelaRegion.Size > 0) {
    printDynamicRelocHeader(ELF::SHT_RELA, "RELA", DynRelaRegion);
    for (const Elf_Rela &Rela : this->dumper().dyn_relas())
      printDynamicReloc(Relocation<ELFT>(Rela, IsMips64EL));
  }
...


template <typename ELFT>
typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const {
  return DynRelaRegion.getAsArrayRef<Elf_Rela>();
}

[MaskRay]

LG.

The diagnostic in getSectionContentsAsArray has been improved

[jhenderson]

LGTM, with nit.

FYI, tomorrow is my last day working before my Christmas break. I'll be back in from around the 4th of January. I'll try to clear as much of my review backlog as possible, but apologies if I fail to get to everything.

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

503

[grimar]

In D93209#2459995, @jhenderson wrote:

LGTM, with nit.

FYI, tomorrow is my last day working before my Christmas break. I'll be back in from around the 4th of January. I'll try to clear as much of my review backlog as possible, but apologies if I fail to get to everything.

Thanks and happy holidays!

[hvdijk]

llvm/include/llvm/Object/ELF.h

629

This multiplication does not produce consistent results across hosts, as size_t may or may not be 64 bits so the result may or may not be truncated to 32 bits. It's fairly harmless since it's just the error message that's affected, but it causes test failures on some hosts. The original code cast Entry to uint64_t before multiplying, I think the new code needs to do the same.

[grimar]

llvm/include/llvm/Object/ELF.h

629

Thanks! This was already fixed in rG43327ba98da138d9d87e13f65675a0b600dae018

lld/test/ELF/invalid/dynamic-section-broken.test

 ## .dynamic section has invalid sh_entsize, check we report it.
 # RUN: yaml2obj --docnum=1 %s -o %t.so
 # RUN: not ld.lld %t.so -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR1
-# ERR1: error: {{.*}}.so: section [index 1] has an invalid sh_entsize: 291
+# ERR1: error: {{.*}}.so: section [index 1] has invalid sh_entsize: expected 16, but got 291
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:

llvm/include/llvm/Object/ELF.h

 }
 
 template <class ELFT>
 template <typename T>
 Expected<ArrayRef<T>>
 ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr &Sec) const {
   if (Sec.sh_entsize != sizeof(T) && sizeof(T) != 1)
     return createError("section " + getSecIndexForError(*this, Sec) +
-                       " has an invalid sh_entsize: " + Twine(Sec.sh_entsize));
+                       " has invalid sh_entsize: expected " + Twine(sizeof(T)) +
+                       ", but got " + Twine(Sec.sh_entsize));
 
   uintX_t Offset = Sec.sh_offset;
   uintX_t Size = Sec.sh_size;
 
   if (Size % sizeof(T))
     return createError("section " + getSecIndexForError(*this, Sec) +
                        " has an invalid sh_size (" + Twine(Size) +
                        ") which is not a multiple of its sh_entsize (" +
if (!SecOrErr)
     return SecOrErr.takeError();
   return getEntry<T>(**SecOrErr, Entry);
 }
 
 template <class ELFT>
 template <typename T>
 Expected<const T *> ELFFile<ELFT>::getEntry(const Elf_Shdr &Section,
                                             uint32_t Entry) const {
-  if (sizeof(T) != Section.sh_entsize)
-    return createError("section " + getSecIndexForError(*this, Section) +
-                       " has invalid sh_entsize: expected " + Twine(sizeof(T)) +
-                       ", but got " + Twine(Section.sh_entsize));
-  uint64_t Pos = Section.sh_offset + (uint64_t)Entry * sizeof(T);
-  if (Pos + sizeof(T) > Buf.size())
-    return createError("unable to access section " +
-                       getSecIndexForError(*this, Section) + " data at 0x" +
-                       Twine::utohexstr(Pos) +
-                       ": offset goes past the end of file");
-  return reinterpret_cast<const T *>(base() + Pos);
+  Expected<ArrayRef<T>> EntriesOrErr = getSectionContentsAsArray<T>(Section);
+  if (!EntriesOrErr)
+    return EntriesOrErr.takeError();
+
+  ArrayRef<T> Arr = *EntriesOrErr;
+  if (Entry >= Arr.size())
+    return createError("can't read an entry at 0x" +
+                       Twine::utohexstr(Entry * sizeof(T)) +
+                       ": it goes past the end of the section (0x" +
+                       Twine::utohexstr(Section.sh_size) + ")");
+  return &Arr[Entry];
 }
 
 template <class ELFT>
 Expected<const typename ELFT::Shdr *>
 ELFFile<ELFT>::getSection(uint32_t Index) const {
   auto TableOrErr = sections();
   if (!TableOrErr)
     return TableOrErr.takeError();

llvm/test/Object/invalid.test

 Symbols:
   - Name: foo
 
 ## Check that llvm-readobj reports an error if .symtab has an invalid sh_entsize.
 
 # RUN: yaml2obj %s --docnum=6 -o %t6
 # RUN: llvm-readobj --symbols %t6 2>&1 | FileCheck -DFILE=%t6 --check-prefix=INVALID-SYM-SIZE %s
 
-# INVALID-SYM-SIZE: warning: '[[FILE]]': unable to read symbols from the SHT_SYMTAB section: section [index 1] has an invalid sh_entsize: 32
+# INVALID-SYM-SIZE: warning: '[[FILE]]': unable to read symbols from the SHT_SYMTAB section: section [index 1] has invalid sh_entsize: expected 24, but got 32
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
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=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
+# INVALID-VER-SHENTSIZE: warning: '[[FILE]]': cannot read content of SHT_GNU_versym section with index 1: section [index 1] has invalid sh_entsize: expected 2, but got 3
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   OSABI:   ELFOSABI_FREEBSD
   Type:    ET_DYN
   Machine: EM_X86_64

llvm/test/tools/llvm-readobj/ELF/call-graph-profile.test

Symbols:
   - Name: bar
 
 ## Check we report a warning when unable to get the content of the SHT_LLVM_CALL_GRAPH_PROFILE section.
 # RUN: yaml2obj %s -DENTSIZE=0xF -o %t2.o
 # RUN: llvm-readobj %t2.o --cg-profile 2>&1 | FileCheck %s -DFILE=%t2.o --check-prefix=LLVM-ERR
 # RUN: llvm-readelf %t2.o --cg-profile | FileCheck %s --check-prefix=GNU
 
 # LLVM-ERR:      CGProfile [
-# LLVM-ERR-NEXT: warning: '[[FILE]]': unable to dump the SHT_LLVM_CALL_GRAPH_PROFILE section: section [index 1] has an invalid sh_entsize: 15
+# LLVM-ERR-NEXT: warning: '[[FILE]]': unable to dump the SHT_LLVM_CALL_GRAPH_PROFILE section: section [index 1] has invalid sh_entsize: expected 16, but got 15
 # LLVM-ERR-NEXT: ]
 
 ## Check we report a warning when unable to dump a name of a symbol.
 # RUN: yaml2obj %s --docnum=2 -o %t3.o
 # RUN: llvm-readobj %t3.o --cg-profile 2>&1 | FileCheck %s -DFILE=%t3.o --check-prefix=LLVM-BROKEN-SYM
 # RUN: llvm-readelf %t3.o --cg-profile | FileCheck %s --check-prefix=GNU
 
 # LLVM-BROKEN-SYM:      CGProfile [

llvm/test/tools/llvm-readobj/ELF/reloc-symbol-with-versioning.test

 # RUN: yaml2obj %s -o %t.o
-# RUN: llvm-readobj --demangle -r %t.o | FileCheck %s --check-prefix LLVM
-# RUN: llvm-readelf --demangle -r %t.o | FileCheck %s --check-prefix GNU
+# RUN: llvm-readobj --demangle -r %t.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=LLVM --implicit-check-not=warning:
+# RUN: llvm-readelf --demangle -r %t.o 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=GNU --implicit-check-not=warning:
 
 # GNU:      Relocation section '.rela.plt' at offset {{.*}} contains 5 entries:
 # GNU-NEXT:     Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
 # GNU-NEXT: 0000000000013018  0000000100000007 R_X86_64_JUMP_SLOT     0000000000000000 f1@v3 + 0
 # GNU-NEXT: 0000000000013020  0000000200000007 R_X86_64_JUMP_SLOT     0000000000000000 f2@v2 + 0
 # GNU-NEXT: 0000000000013028  0000000300000007 R_X86_64_JUMP_SLOT     0000000000000000 g1@v1 + 0
 # GNU-NEXT: 0000000000013040  0000000400000007 R_X86_64_JUMP_SLOT     0000000000000000 f1()@v3 + 0
 # GNU-NEXT: 0000000000013058  0000000500000007 R_X86_64_JUMP_SLOT     0000000000000000 f3 + 0
 
FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name:    .gnu.version
     Type:    SHT_GNU_versym
     Flags:   [ SHF_ALLOC ]
-    Entries: [ 0, 2, 3, 4, 2 ]
+    Entries: [ 0, 2, 3, 4, 2, 1 ]
   - Name:         .gnu.version_r
     Type:         SHT_GNU_verneed
     Flags:        [ SHF_ALLOC ]
     Link:         .dynstr
     AddressAlign: 0x0000000000000004
     Info:         0x0000000000000002
     Dependencies:
       - Version: 1

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 SHT_REL section with index 3: unable to access section [index 6] data at 0x17e7e7e8d0: 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 0x17e7e7e8d0: 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 read an entry with index 4278124286 from SHT_SYMTAB section with index 6: can't read an entry at 0x17e7e7e7d0: it goes past the end of the section (0x90)
+# LLVM-NEXT: warning: '[[FILE]]': unable to print relocation 2 in SHT_REL section with index 3: unable to read an entry with index 4278124286 from SHT_SYMTAB section with index 6: can't read an entry at 0x17e7e7e7d0: it goes past the end of the section (0x90)
 # LLVM-NEXT:     0x2 R_X86_64_NONE -{{$}}
 # LLVM-NEXT:     0x3 R_X86_64_NONE .sec.symbol1{{$}}
 # LLVM-NEXT: warning: '[[FILE]]': invalid section index: 255
 # LLVM-NEXT:     0x4 R_X86_64_NONE <section 255>{{$}}
 # LLVM-NEXT:     0x5 R_X86_64_NONE .sec.symbol2{{$}}
 # LLVM-NEXT: warning: '[[FILE]]': a section [index 2] has an invalid sh_name (0xfefefefe) offset which goes past the end of the section name string table
 # LLVM-NEXT:     0x6 R_X86_64_NONE <section 2>{{$}}
 # LLVM-NEXT:   }
 # LLVM-NEXT:   Section (4) .rela.text {
 # 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 7 entries:
 # GNU-NEXT:      Offset             Info             Type               Symbol's Value  Symbol's Name
-# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 1 in SHT_REL section with index 3: unable to access section [index 6] data at 0x17e7e7e8d0: 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 0x17e7e7e8d0: 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 read an entry with index 4278124286 from SHT_SYMTAB section with index 6: can't read an entry at 0x17e7e7e7d0: it goes past the end of the section (0x90)
+# GNU-NEXT:  warning: '[[FILE]]': unable to print relocation 2 in SHT_REL section with index 3: unable to read an entry with index 4278124286 from SHT_SYMTAB section with index 6: can't read an entry at 0x17e7e7e7d0: it goes past the end of the section (0x90)
 # GNU-NEXT:  0000000000000002  0000000000000000 R_X86_64_NONE
 # GNU-NEXT:  0000000000000003  0000000200000000 R_X86_64_NONE 0000000000000000 .sec.symbol1
 # GNU-NEXT:  warning: '[[FILE]]': invalid section index: 255
 # GNU-NEXT:  0000000000000004  0000000400000000 R_X86_64_NONE 0000000000000000 <section 255>
 # GNU-NEXT:  0000000000000005  0000000300000000 R_X86_64_NONE 0000000000000000 .sec.symbol2
 # GNU-NEXT:  warning: '[[FILE]]': a section [index 2] has an invalid sh_name (0xfefefefe) offset which goes past the end of the section name string table
 # GNU-NEXT:  0000000000000006  0000000500000000 R_X86_64_NONE 0000000000000000 <section 2>
 # GNU-EMPTY:

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

 # RUN: yaml2obj %s --docnum=1 -DENTSIZEREL=1 -o %t.broken.rel
 # RUN: llvm-readobj --relocations %t.broken.rel 2>&1 \
 # RUN:   | FileCheck %s -DFILE=%t.broken.rel --check-prefix=BROKEN-REL-LLVM
 # RUN: llvm-readelf --relocations %t.broken.rel 2>&1 \
 # RUN:   | FileCheck %s -DFILE=%t.broken.rel --check-prefix=BROKEN-REL-GNU
 
 # BROKEN-REL-LLVM:      Relocations [
 # BROKEN-REL-LLVM-NEXT:   Section (2) .rel.text {
-# BROKEN-REL-LLVM-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_REL section with index 2: section [index 2] has an invalid sh_entsize: 1
+# BROKEN-REL-LLVM-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_REL section with index 2: section [index 2] has invalid sh_entsize: expected 16, but got 1
 # BROKEN-REL-LLVM-NEXT:   }
 # BROKEN-REL-LLVM-NEXT:   Section (3) .rela.text {
 # BROKEN-REL-LLVM-NEXT:     0x0 R_X86_64_NONE rela_0 0x0
 # BROKEN-REL-LLVM-NEXT:     0x1 R_X86_64_PC32 rela_neg 0xFFFFFFFFFFFFFFFF
 # BROKEN-REL-LLVM-NEXT:     0x5 R_X86_64_PLT32 rela_pos 0x2
 # BROKEN-REL-LLVM-NEXT:     0xFFFFFFFFFFFFFFFF R_X86_64_64 rela_minneg 0x8000000000000000
 # BROKEN-REL-LLVM-NEXT:     0x9 R_X86_64_32S rela_maxpos 0x7FFFFFFFFFFFFFFF
 # BROKEN-REL-LLVM-NEXT:   }
 # BROKEN-REL-LLVM-NEXT: ]
 
 # BROKEN-REL-GNU:      Relocation section '.rel.text' at offset 0x51 contains 64 entries:
 # BROKEN-REL-GNU-NEXT:     Offset             Info             Type       Symbol's Value  Symbol's Name
-# BROKEN-REL-GNU-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_REL section with index 2: section [index 2] has an invalid sh_entsize: 1
+# BROKEN-REL-GNU-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_REL section with index 2: section [index 2] has invalid sh_entsize: expected 16, but got 1
 # BROKEN-REL-GNU:      Relocation section '.rela.text' at offset 0x91 contains 5 entries:
 # BROKEN-REL-GNU-NEXT:     Offset             Info             Type       Symbol's Value  Symbol's Name
 # BROKEN-REL-GNU-NEXT: 0000000000000000  0000000500000000 R_X86_64_NONE  0000000000000000 rela_0 + 0
 # BROKEN-REL-GNU-NEXT: 0000000000000001  0000000600000002 R_X86_64_PC32  0000000000000001 rela_neg - 1
 # BROKEN-REL-GNU-NEXT: 0000000000000005  0000000700000004 R_X86_64_PLT32 0000000000000002 rela_pos + 2
 # BROKEN-REL-GNU-NEXT: ffffffffffffffff  0000000800000001 R_X86_64_64    0000000000000003 rela_minneg - 8000000000000000
 # BROKEN-REL-GNU-NEXT: 0000000000000009  000000090000000b R_X86_64_32S   ffffffffffffffff rela_maxpos + 7fffffffffffffff
 
 ## Case B: check the case when relocations can't be read from an SHT_RELA section.
 ##         because of broken sh_entsize field.
 # RUN: yaml2obj %s --docnum=1 -DENTSIZERELA=1 -o %t.broken.rela
 # RUN: llvm-readobj --relocations %t.broken.rela 2>&1 \
 # RUN:   | FileCheck %s -DFILE=%t.broken.rela --check-prefix=BROKEN-RELA-LLVM
 # RUN: llvm-readelf --relocations %t.broken.rela 2>&1 \
 # RUN:   | FileCheck %s -DFILE=%t.broken.rela --check-prefix=BROKEN-RELA-GNU
 
 # BROKEN-RELA-LLVM:      Relocations [
 # BROKEN-RELA-LLVM-NEXT:   Section (2) .rel.text {
 # BROKEN-RELA-LLVM-NEXT:     0x0 R_X86_64_NONE rel_0{{$}}
 # BROKEN-RELA-LLVM-NEXT:     0x1 R_X86_64_PC32 rel_neg{{$}}
 # BROKEN-RELA-LLVM-NEXT:     0x5 R_X86_64_PLT32 rel_pos{{$}}
 # BROKEN-RELA-LLVM-NEXT:     0x9 R_X86_64_64 rel_64{{$}}
 # BROKEN-RELA-LLVM-NEXT:   }
 # BROKEN-RELA-LLVM-NEXT:   Section (3) .rela.text {
-# BROKEN-RELA-LLVM-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_RELA section with index 3: section [index 3] has an invalid sh_entsize: 1
+# BROKEN-RELA-LLVM-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_RELA section with index 3: section [index 3] has invalid sh_entsize: expected 24, but got 1
 # BROKEN-RELA-LLVM-NEXT:   }
 # BROKEN-RELA-LLVM-NEXT: ]
 
 # BROKEN-RELA-GNU:      Relocation section '.rel.text' at offset 0x51 contains 4 entries:
 # BROKEN-RELA-GNU-NEXT:     Offset             Info             Type       Symbol's Value  Symbol's Name
 # BROKEN-RELA-GNU-NEXT: 0000000000000000  0000000100000000 R_X86_64_NONE  0000000000000000 rel_0
 # BROKEN-RELA-GNU-NEXT: 0000000000000001  0000000200000002 R_X86_64_PC32  0000000000000001 rel_neg
 # BROKEN-RELA-GNU-NEXT: 0000000000000005  0000000300000004 R_X86_64_PLT32 0000000000000002 rel_pos
 # BROKEN-RELA-GNU-NEXT: 0000000000000009  0000000400000001 R_X86_64_64    ffffffffffffffff rel_64
 # BROKEN-RELA-GNU-EMPTY:
 # BROKEN-RELA-GNU-NEXT: Relocation section '.rela.text' at offset 0x91 contains 120 entries:
 # BROKEN-RELA-GNU-NEXT:     Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
-# BROKEN-RELA-GNU-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_RELA section with index 3: section [index 3] has an invalid sh_entsize: 1
+# BROKEN-RELA-GNU-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_RELA section with index 3: section [index 3] has invalid sh_entsize: expected 24, but got 1
 
 ## Case C: check the case when relocations can't be read from SHT_REL/SHT_RELA sections
 ##         because of broken sh_link fields.
 # RUN: yaml2obj %s --docnum=1 -DLINK=0xffff -o %t.broken.link
 # RUN: llvm-readobj --relocations %t.broken.link 2>&1 \
 # RUN:   | FileCheck %s -DFILE=%t.broken.link --check-prefix=BROKEN-LINK-LLVM
 # RUN: llvm-readelf --relocations %t.broken.link 2>&1 \
 # RUN:   | FileCheck %s -DFILE=%t.broken.link --check-prefix=BROKEN-LINK-GNU

 # GNU-SHNAME:      warning: '[[FILE]]': unable to get the name of SHT_RELA section with index 3: a section [index 3] has an invalid sh_name (0xffffffff) offset which goes past the end of the section name string table
 # GNU-SHNAME:      Relocation section '<?>' at offset 0x91 contains 5 entries:
 # GNU-SHNAME-NEXT:     Offset             Info             Type       Symbol's Value  Symbol's Name + Addend
 # GNU-SHNAME-NEXT: 0000000000000000  0000000500000000 R_X86_64_NONE  0000000000000000 rela_0 + 0
 # GNU-SHNAME-NEXT: 0000000000000001  0000000600000002 R_X86_64_PC32  0000000000000001 rela_neg - 1
 # GNU-SHNAME-NEXT: 0000000000000005  0000000700000004 R_X86_64_PLT32 0000000000000002 rela_pos + 2
 # GNU-SHNAME-NEXT: ffffffffffffffff  0000000800000001 R_X86_64_64    0000000000000003 rela_minneg - 8000000000000000
 # GNU-SHNAME-NEXT: 0000000000000009  000000090000000b R_X86_64_32S   ffffffffffffffff rela_maxpos + 7fffffffffffffff
+
+## Check that we report a warning when a relocation has a
+## symbol index past the end of the symbol table
+
+# RUN: yaml2obj %s --docnum=3 -o %t3
+# RUN: llvm-readobj --relocs %t3 2>&1 | \
+# RUN:   FileCheck %s --implicit-check-not=warning: -DFILE=%t3 --check-prefix=LLVM-SYMNDX
+# RUN: llvm-readelf --relocs %t3 2>&1 | \
+# RUN:   FileCheck %s --implicit-check-not=warning: -DFILE=%t3 --check-prefix=GNU-SYMNDX
+
+# LLVM-SYMNDX:      Relocations [
+# LLVM-SYMNDX-NEXT:   Section (1) .rela.text {
+# LLVM-SYMNDX-NEXT: warning: '[[FILE]]': unable to print relocation 1 in SHT_RELA section with index 1: unable to read an entry with index 2 from SHT_SYMTAB section with index 2: can't read an entry at 0x30: it goes past the end of the section (0x30)
+# LLVM-SYMNDX-NEXT: warning: '[[FILE]]': unable to print relocation 2 in SHT_RELA section with index 1: unable to read an entry with index 3 from SHT_SYMTAB section with index 2: can't read an entry at 0x48: it goes past the end of the section (0x30)
+# LLVM-SYMNDX-NEXT:   }
+# LLVM-SYMNDX-NEXT: ]
+
+# GNU-SYMNDX:      Relocation section '.rela.text' at offset 0x40 contains 2 entries:
+# GNU-SYMNDX-NEXT:     Offset             Info             Type     Symbol's Value  Symbol's Name + Addend
+# GNU-SYMNDX-NEXT: warning: '[[FILE]]': unable to print relocation 1 in SHT_RELA section with index 1: unable to read an entry with index 2 from SHT_SYMTAB section with index 2: can't read an entry at 0x30: it goes past the end of the section (0x30)
+# GNU-SYMNDX-NEXT: warning: '[[FILE]]': unable to print relocation 2 in SHT_RELA section with index 1: unable to read an entry with index 3 from SHT_SYMTAB section with index 2: can't read an entry at 0x48: it goes past the end of the section (0x30)
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .rela.text
+    Type: SHT_RELA
+    Relocations:
+      - Type:   R_X86_64_NONE
+        Symbol: 0x2
+      - Type:   R_X86_64_NONE
+        Symbol: 0x3
+Symbols:
+  - Name: foo

llvm/test/tools/llvm-readobj/ELF/relr-relocs.test

 # RUN: yaml2obj --docnum=2 -DENTSIZE=1 %s -o %t2.broken
 # RUN: llvm-readobj --relocations %t2.broken 2>&1 | \
 # RUN:   FileCheck -DFILE=%t2.broken --check-prefix=BROKEN-LLVM %s -DSECNAME=SHT_RELR
 # RUN: llvm-readelf --relocations %t2.broken 2>&1 | \
 # RUN:   FileCheck -DFILE=%t2.broken --check-prefix=BROKEN-GNU %s -DSECNAME=SHT_RELR
 
 # BROKEN-LLVM:      Relocations [
 # BROKEN-LLVM-NEXT:   Section (1) .relr.dyn {
-# BROKEN-LLVM-NEXT: warning: '[[FILE]]': unable to read relocations from [[SECNAME]] section with index 1: section [index 1] has an invalid sh_entsize: 1
+# BROKEN-LLVM-NEXT: warning: '[[FILE]]': unable to read relocations from [[SECNAME]] section with index 1: section [index 1] has invalid sh_entsize: expected 4, but got 1
 # BROKEN-LLVM-NEXT:   }
 # BROKEN-LLVM-NEXT: ]
 
-# BROKEN-GNU:      warning: '[[FILE]]': unable to get the number of relocations in [[SECNAME]] section with index 1: section [index 1] has an invalid sh_entsize: 1
+# BROKEN-GNU:      warning: '[[FILE]]': unable to get the number of relocations in [[SECNAME]] section with index 1: section [index 1] has invalid sh_entsize: expected 4, but got 1
 # BROKEN-GNU:      Relocation section '.relr.dyn' at offset 0x34 contains <?> entries:
 # BROKEN-GNU-NEXT:  Offset     Info    Type                Sym. Value  Symbol's Name
-# BROKEN-GNU-NEXT: warning: '[[FILE]]': unable to read relocations from [[SECNAME]] section with index 1: section [index 1] has an invalid sh_entsize: 1
+# BROKEN-GNU-NEXT: warning: '[[FILE]]': unable to read relocations from [[SECNAME]] section with index 1: section [index 1] has invalid sh_entsize: expected 4, but got 1
 
 ## Case B: check the case when relocations can't be read from an SHT_ANDROID_RELR section.
 ##         SHT_ANDROID_RELR = 0x6fffff00.
 # RUN: yaml2obj --docnum=2 -DENTSIZE=1 -DSHTYPE=0x6fffff00 %s -o %t2.broken.android
 # RUN: llvm-readobj --relocations %t2.broken.android 2>&1 | \
 # RUN:   FileCheck -DFILE=%t2.broken.android --check-prefix=BROKEN-LLVM %s -DSECNAME=SHT_ANDROID_RELR
 # RUN: llvm-readelf --relocations %t2.broken.android 2>&1 | \
 # RUN:   FileCheck -DFILE=%t2.broken.android --check-prefix=BROKEN-GNU %s -DSECNAME=SHT_ANDROID_RELR

llvm/test/tools/llvm-readobj/ELF/stack-sizes.test

 # RUN: yaml2obj --docnum=1 %s -DSYMTABOFFSET=0xffffeeee -o %t01.broken.symtab
 # RUN: llvm-readelf --stack-sizes %t01.broken.symtab 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t01.broken.symtab --check-prefix=SYMTAB-GNU --implicit-check-not=warning:
 # RUN: llvm-readobj --stack-sizes %t01.broken.symtab 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t01.broken.symtab --check-prefix=SYMTAB-LLVM --implicit-check-not=warning:
 
 # SYMTAB-GNU:      Stack Sizes:
 # SYMTAB-GNU-NEXT:          Size     Function
-# SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 5: unable to access section [index 7] data at 0xffffef36: offset goes past the end of file
+# SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 5: unable to read an entry with index 3 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to read the symbol table: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-GNU-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 3
 # SYMTAB-GNU-NEXT:            16     ?
-# SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 5: unable to access section [index 7] data at 0xffffef1e: offset goes past the end of file
+# SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 5: unable to read an entry with index 2 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-GNU-NEXT:            32     ?
-# SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 6: unable to access section [index 7] data at 0xffffef06: offset goes past the end of file
+# SYMTAB-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 6: unable to read an entry with index 1 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-GNU-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 4
 # SYMTAB-GNU-NEXT:             8     ?
 
 # SYMTAB-LLVM:      StackSizes [
-# SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 5: unable to access section [index 7] data at 0xffffef36: offset goes past the end of file
+# SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 5: unable to read an entry with index 3 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to read the symbol table: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 3
 # SYMTAB-LLVM-NEXT:   Entry {
 # SYMTAB-LLVM-NEXT:     Function: ?
 # SYMTAB-LLVM-NEXT:     Size: 0x10
 # SYMTAB-LLVM-NEXT:   }
-# SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 5: unable to access section [index 7] data at 0xffffef1e: offset goes past the end of file
+# SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 5: unable to read an entry with index 2 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-LLVM-NEXT:   Entry {
 # SYMTAB-LLVM-NEXT:     Function: ?
 # SYMTAB-LLVM-NEXT:     Size: 0x20
 # SYMTAB-LLVM-NEXT:   }
-# SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 6: unable to access section [index 7] data at 0xffffef06: offset goes past the end of file
+# SYMTAB-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 1 in SHT_RELA section with index 6: unable to read an entry with index 1 from SHT_SYMTAB section with index 7: section [index 7] has a sh_offset (0xffffeeee) + sh_size (0x78) that is greater than the file size (0x450)
 # SYMTAB-LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 4
 # SYMTAB-LLVM-NEXT:   Entry {
 # SYMTAB-LLVM-NEXT:     Function: ?
 # SYMTAB-LLVM-NEXT:     Size: 0x8
 # SYMTAB-LLVM-NEXT:   }
 # SYMTAB-LLVM-NEXT: ]
 
 ## In this case we have a function symbol with an invalid section index.

 # RUN:   FileCheck %s -DFILE=%t07 --check-prefix=BADSECTION-OUT-LLVM --implicit-check-not=warning:
 
 # BADSECTION-OUT-GNU:      Stack Sizes:
 # BADSECTION-OUT-GNU-NEXT:          Size     Function
 # BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': cannot identify the section for relocation symbol '_Z3foof': invalid section index: 10
 # BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': unable to get address of symbol '_Z3foof': invalid section index: 10
 # BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 2
 # BADSECTION-OUT-GNU-NEXT:             8     ?
-# BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 3: unable to access section [index 4] data at 0x18a0: offset goes past the end of file
+# BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 3: unable to read an entry with index 255 from SHT_SYMTAB section with index 4: can't read an entry at 0x17e8: it goes past the end of the section (0x30)
 # BADSECTION-OUT-GNU-NEXT:            22     ?
-# BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 3 in SHT_RELA section with index 3: unable to access section [index 4] data at 0x18a0: offset goes past the end of file
+# BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 3 in SHT_RELA section with index 3: unable to read an entry with index 255 from SHT_SYMTAB section with index 4: can't read an entry at 0x17e8: it goes past the end of the section (0x30)
 # BADSECTION-OUT-GNU-NEXT:            36     ?
 
 # BADSECTION-OUT-LLVM:      StackSizes [
 # BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': cannot identify the section for relocation symbol '_Z3foof': invalid section index: 10
 # BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': unable to get address of symbol '_Z3foof': invalid section index: 10
 # BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry in SHT_PROGBITS section with index 2
 # BADSECTION-OUT-LLVM-NEXT:   Entry {
 # BADSECTION-OUT-LLVM-NEXT:     Function: ?
 # BADSECTION-OUT-LLVM-NEXT:     Size: 0x8
 # BADSECTION-OUT-LLVM-NEXT:   }
-# BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 3: unable to access section [index 4] data at 0x18a0: offset goes past the end of file
+# BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 2 in SHT_RELA section with index 3: unable to read an entry with index 255 from SHT_SYMTAB section with index 4: can't read an entry at 0x17e8: it goes past the end of the section (0x30)
 # BADSECTION-OUT-LLVM-NEXT:   Entry {
 # BADSECTION-OUT-LLVM-NEXT:     Function: ?
 # BADSECTION-OUT-LLVM-NEXT:     Size: 0x16
 # BADSECTION-OUT-LLVM-NEXT:   }
-# BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 3 in SHT_RELA section with index 3: unable to access section [index 4] data at 0x18a0: offset goes past the end of file
+# BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': unable to get the target of relocation with index 3 in SHT_RELA section with index 3: unable to read an entry with index 255 from SHT_SYMTAB section with index 4: can't read an entry at 0x17e8: it goes past the end of the section (0x30)
 # BADSECTION-OUT-LLVM-NEXT:   Entry {
 # BADSECTION-OUT-LLVM-NEXT:     Function: ?
 # BADSECTION-OUT-LLVM-NEXT:     Size: 0x24
 # BADSECTION-OUT-LLVM-NEXT:   }
 # BADSECTION-OUT-LLVM-NEXT: ]
 
 # RUN: llvm-readelf --stack-sizes --demangle %t07 2>&1 | FileCheck %s --check-prefix=BADSECTION-DEMANGLE-ERR -DFILE=%t07
 # RUN: llvm-readobj --stack-sizes --demangle %t07 2>&1 | FileCheck %s --check-prefix=BADSECTION-DEMANGLE-ERR -DFILE=%t07

llvm/test/tools/llvm-readobj/ELF/symbols.test

 ##         from the the SHT_SYMTAB section.
 # RUN: yaml2obj --docnum=2 -DENTSIZE=0xFF %s -o %t64.err2
 # RUN: llvm-readobj --symbols %t64.err2 2>&1 | \
 # RUN:  FileCheck %s -DFILE=%t64.err2 --check-prefix=SYMTAB-ENTSIZE-ERR-LLVM
 # RUN: llvm-readelf --symbols %t64.err2 2>&1 | \
 # RUN:  FileCheck %s -DFILE=%t64.err2 --check-prefix=SYMTAB-ENTSIZE-ERR-GNU
 
 # SYMTAB-ENTSIZE-ERR-LLVM:      Symbols [
-# SYMTAB-ENTSIZE-ERR-LLVM-NEXT:   warning: '[[FILE]]': unable to read symbols from the SHT_SYMTAB section: section [index 1] has an invalid sh_entsize: 255
+# SYMTAB-ENTSIZE-ERR-LLVM-NEXT:   warning: '[[FILE]]': unable to read symbols from the SHT_SYMTAB section: section [index 1] has invalid sh_entsize: expected 24, but got 255
 # SYMTAB-ENTSIZE-ERR-LLVM:      ]
 
-# SYMTAB-ENTSIZE-ERR-GNU:     warning: '[[FILE]]': unable to read symbols from the SHT_SYMTAB section: section [index 1] has an invalid sh_entsize: 255
+# SYMTAB-ENTSIZE-ERR-GNU:     warning: '[[FILE]]': unable to read symbols from the SHT_SYMTAB section: section [index 1] has invalid sh_entsize: expected 24, but got 255
 # SYMTAB-ENTSIZE-ERR-GNU-NOT: {{.}}
 
 ## Case 3: check we report a warning, but continue dumping, when we are unable to read the name of the SHT_SYMTAB section.
 ##         In this case we set the e_shstrndx field to an invalid index so that the .shstrtab section can't be located.
 # RUN: yaml2obj --docnum=2 -DSHSTRTAB=0xff %s -o %t64.err3
 # RUN: llvm-readobj --symbols %t64.err3 2>&1 | \
 # RUN:  FileCheck %s -DFILE=%t64.err3 --check-prefix=SYMTAB-SHSTRTAB-ERR-LLVM --implicit-check-not=warning:
 # RUN: llvm-readelf --symbols %t64.err3 2>&1 | \

llvm/test/tools/llvm-readobj/ELF/versym-invalid.test

 
 # INVALID-ENT-SIZE-GNU:      Symbol table '.dynsym' contains 2 entries:
 # INVALID-ENT-SIZE-GNU-NEXT:    Num:    Value          Size Type    Bind   Vis       Ndx Name
 # INVALID-ENT-SIZE-GNU-NEXT: warning: '[[FILE]]': section [index 1] has invalid sh_entsize: expected 2, but got 3
 # INVALID-ENT-SIZE-GNU-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND @<corrupt>
 # INVALID-ENT-SIZE-GNU-NEXT:      1: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND foo@<corrupt>
 # INVALID-ENT-SIZE-GNU:      Version symbols section '.gnu.version' contains 1 entries:
 # INVALID-ENT-SIZE-GNU-NEXT:  Addr: 0000000000000000  Offset: 0x000040  Link: 0 ()
-# INVALID-ENT-SIZE-GNU-NEXT: warning: '[[FILE]]': cannot read content of SHT_GNU_versym section with index 1: section [index 1] has an invalid sh_entsize: 3
+# INVALID-ENT-SIZE-GNU-NEXT: warning: '[[FILE]]': cannot read content of SHT_GNU_versym section with index 1: section [index 1] has invalid sh_entsize: expected 2, but got 3
 
 # INVALID-ENT-SIZE-LLVM:      DynamicSymbols [
 # INVALID-ENT-SIZE-LLVM-NEXT: warning: '[[FILE]]': section [index 1] has invalid sh_entsize: expected 2, but got 3
 # INVALID-ENT-SIZE-LLVM-NEXT:   Symbol {
 # INVALID-ENT-SIZE-LLVM-NEXT:     Name: @<corrupt> (0)
 # INVALID-ENT-SIZE-LLVM-NEXT:     Value: 0x0
 # INVALID-ENT-SIZE-LLVM-NEXT:     Size: 0
 # INVALID-ENT-SIZE-LLVM-NEXT:     Binding: Local (0x0)
 # INVALID-ENT-SIZE-LLVM-NEXT:     Type: None (0x0)
 # INVALID-ENT-SIZE-LLVM-NEXT:     Other: 0
 # INVALID-ENT-SIZE-LLVM-NEXT:     Section: Undefined (0x0)
 # INVALID-ENT-SIZE-LLVM-NEXT:   }
 # INVALID-ENT-SIZE-LLVM-NEXT:   Symbol {
 # INVALID-ENT-SIZE-LLVM-NEXT:     Name: foo@<corrupt> (1)
 # INVALID-ENT-SIZE-LLVM-NEXT:     Value: 0x0
 # INVALID-ENT-SIZE-LLVM-NEXT:     Size: 0
 # INVALID-ENT-SIZE-LLVM-NEXT:     Binding: Local (0x0)
 # INVALID-ENT-SIZE-LLVM-NEXT:     Type: None (0x0)
 # INVALID-ENT-SIZE-LLVM-NEXT:     Other: 0
 # INVALID-ENT-SIZE-LLVM-NEXT:     Section: Undefined (0x0)
 # INVALID-ENT-SIZE-LLVM-NEXT:   }
 # INVALID-ENT-SIZE-LLVM-NEXT: ]
 # INVALID-ENT-SIZE-LLVM:      VersionSymbols [
-# INVALID-ENT-SIZE-LLVM-NEXT: warning: '[[FILE]]': cannot read content of SHT_GNU_versym section with index 1: section [index 1] has an invalid sh_entsize: 3
+# INVALID-ENT-SIZE-LLVM-NEXT: warning: '[[FILE]]': cannot read content of SHT_GNU_versym section with index 1: section [index 1] has invalid sh_entsize: expected 2, but got 3
 # INVALID-ENT-SIZE-LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:

llvm/test/tools/obj2yaml/ELF/dynamic-section.yaml

Entries:
         Value:           0x0000000000000001
 
 ## Test the behavior when sh_entsize is invalid.
 ## Here we use 0xFE as an arbitrary broken value instead of expected 0x16.
 
 # RUN: yaml2obj -DENTSIZE=0xff %s -o %t2
 # RUN: not obj2yaml %t2 2>&1 | FileCheck %s --check-prefix=ENTSIZE
 
-# ENTSIZE: section [index 1] has an invalid sh_entsize: 255
+# ENTSIZE: section [index 1] has invalid sh_entsize: expected 16, but got 255

llvm/test/tools/obj2yaml/ELF/rel-rela-section.yaml

- Name: .rel.dyn
     Type: SHT_REL
 ## Trigger the .dynsym emission.
 DynamicSymbols: []
 
 ## Test the behavior when the sh_entsize field is broken.
 ## Here we use the 0xFE value instead of expected 0x18/0x10.
 
 # RUN: yaml2obj -DTYPE=SHT_RELA --docnum=2 %s -o %t2.rela
-# RUN: not obj2yaml %t2.rela 2>&1 | FileCheck %s --check-prefix=ERR
+# RUN: not obj2yaml %t2.rela 2>&1 | FileCheck %s --check-prefix=ERR1
 # RUN: yaml2obj -DTYPE=SHT_REL  --docnum=2 %s -o %t2.rel
-# RUN: not obj2yaml %t2.rel 2>&1 | FileCheck %s --check-prefix=ERR
+# RUN: not obj2yaml %t2.rel 2>&1 | FileCheck %s --check-prefix=ERR2
 
-# ERR: section [index 1] has an invalid sh_entsize: 254
+# ERR1: section [index 1] has invalid sh_entsize: expected 24, but got 254
+# ERR2: section [index 1] has invalid sh_entsize: expected 16, but got 254
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:    .foo
     Type:    [[TYPE]]
     EntSize: 0xFE

llvm/test/tools/yaml2obj/ELF/sht-symtab-shndx.yaml

Symbols:
   - Type:  STT_SECTION
     Index: 65536
 
 ## Check we can set a custom sh_entsize for SHT_SYMTAB_SHNDX section.
 
 # RUN: yaml2obj --docnum=5 %s -o %t5
 # RUN: llvm-readelf -S 2>&1 %t5 | FileCheck %s -DFILE=%t5 --check-prefix=CASE5
 
-# CASE5: warning: '[[FILE]]': section [index 1] has an invalid sh_entsize: 2
+# CASE5: warning: '[[FILE]]': section [index 1] has invalid sh_entsize: expected 4, but got 2
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:    .symtab_shndx

llvm/tools/llvm-readobj/ELFDumper.cpp

 ELFDumper<ELFT>::getRelocationTarget(const Relocation<ELFT> &R,
                                      const Elf_Shdr *SymTab) const {
   if (R.Symbol == 0)
     return RelSymbol<ELFT>(nullptr, "");
 
   Expected<const Elf_Sym *> SymOrErr =
       Obj.template getEntry<Elf_Sym>(*SymTab, R.Symbol);
   if (!SymOrErr)
-    return SymOrErr.takeError();
+    return createError("unable to read an entry with index " + Twine(R.Symbol) +
+                       " from " + describe(*SymTab) + ": " +
+                       toString(SymOrErr.takeError()));
   const Elf_Sym *Sym = *SymOrErr;
   if (!Sym)
     return RelSymbol<ELFT>(nullptr, "");
 
   Expected<StringRef> StrTableOrErr = Obj.getStringTableForSymtab(*SymTab);
   if (!StrTableOrErr)
     return StrTableOrErr.takeError();
 
if (Parser.getPltModulePointer())
     PrintEntry(Parser.getPltModulePointer(), "Module pointer");
 
   if (!Parser.getPltEntries().empty()) {
     OS << "\n";
     OS << " Entries:\n";
     OS << "   Address  Initial Sym.Val. Type    Ndx Name\n";
     for (auto &E : Parser.getPltEntries()) {
       const Elf_Sym &Sym = *Parser.getPltSym(&E);
-      const Elf_Sym &FirstSym =
-          *cantFail(this->Obj.template getEntry<const Elf_Sym>(
-              *Parser.getPltSymTable(), 0));
+      const Elf_Sym &FirstSym = *cantFail(
+          this->Obj.template getEntry<Elf_Sym>(*Parser.getPltSymTable(), 0));
       std::string SymName = this->dumper().getFullSymbolName(
           Sym, &Sym - &FirstSym, this->dumper().getDynamicStringTable(), false);
 
       OS.PadToColumn(2);
       OS << to_string(format_hex_no_prefix(Parser.getPltAddress(&E), 8 + Bias));
       OS.PadToColumn(11 + Bias);
       OS << to_string(format_hex_no_prefix(E, 8 + Bias));
       OS.PadToColumn(20 + 2 * Bias);
for (auto &E : Parser.getPltEntries()) {
       DictScope D(W, "Entry");
       PrintEntry(&E);
 
       const Elf_Sym &Sym = *Parser.getPltSym(&E);
       W.printHex("Value", Sym.st_value);
       W.printEnum("Type", Sym.getType(), makeArrayRef(ElfSymbolTypes));
       printSymbolSection(Sym, &Sym - this->dumper().dynamic_symbols().begin());
 
-      const Elf_Sym *FirstSym =
-          cantFail(this->Obj.template getEntry<const Elf_Sym>(
-              *Parser.getPltSymTable(), 0));
+      const Elf_Sym *FirstSym = cantFail(
+          this->Obj.template getEntry<Elf_Sym>(*Parser.getPltSymTable(), 0));
       std::string SymName = this->dumper().getFullSymbolName(
           Sym, &Sym - FirstSym, Parser.getPltStrTable(), true);
       W.printNumber("Name", SymName, Sym.st_name);
     }
   }
 }
 
 template <class ELFT> void LLVMStyle<ELFT>::printMipsABIFlags() {

llvm/unittests/Object/ELFObjectFileTest.cpp

Sections:
   - Name:         .foo
     Type:         SHT_PROGBITS
     Address:      0x1000
     Offset:       0x3000
     ContentArray: [ 0x11 ]
   - Name:         .bar
     Type:         SHT_PROGBITS
     Address:      0x2000
     Offset:       0x4000
     ContentArray: [ 0x99 ]
 ProgramHeaders:
   - Type:     PT_LOAD
     VAddr:    0x2000
     FirstSec: .bar
     LastSec:  .bar
   - Type:     PT_LOAD
     VAddr:    0x1000
     FirstSec: .foo
)");
   ASSERT_THAT_EXPECTED(ElfOrErr, Succeeded());
   const ELFFile<ELF64LE> &Elf = ElfOrErr->getELFFile();
   const ELFObjectFile<ELF64LE> &Obj = *ElfOrErr;
 
   Expected<const typename ELF64LE::Shdr *> SymtabSecOrErr = Elf.getSection(1);
   ASSERT_THAT_EXPECTED(SymtabSecOrErr, Succeeded());
   ASSERT_EQ((*SymtabSecOrErr)->sh_type, ELF::SHT_SYMTAB);
 
-  // We create a symbol with an index that is too large to exist in the object.
-  constexpr unsigned BrokenSymIndex = 0xFFFFFFFF;
+  auto DoCheck = [&](unsigned BrokenSymIndex, const char *ErrMsg) {
     ELFSymbolRef BrokenSym = Obj.toSymbolRef(*SymtabSecOrErr, BrokenSymIndex);
 
-  const char *ErrMsg = "unable to access section [index 1] data at "
-                       "0x1800000028: offset goes past the end of file";
     // 1) Check the behavior of ELFObjectFile<ELFT>::getSymbolName().
     //    SymbolRef::getName() calls it internally. We can't test it directly,
     //    because it is protected.
-  EXPECT_THAT_ERROR(BrokenSym.getName().takeError(), FailedWithMessage(ErrMsg));
+    EXPECT_THAT_ERROR(BrokenSym.getName().takeError(),
+                      FailedWithMessage(ErrMsg));
 
     // 2) Check the behavior of ELFObjectFile<ELFT>::getSymbol().
     EXPECT_THAT_ERROR(Obj.getSymbol(BrokenSym.getRawDataRefImpl()).takeError(),
                       FailedWithMessage(ErrMsg));
 
     // 3) Check the behavior of ELFObjectFile<ELFT>::getSymbolSection().
-  //    SymbolRef::getSection() calls it internally. We can't test it directly,
-  //    because it is protected.
+    //    SymbolRef::getSection() calls it internally. We can't test it
+    //    directly, because it is protected.
     EXPECT_THAT_ERROR(BrokenSym.getSection().takeError(),
                       FailedWithMessage(ErrMsg));
 
     // 4) Check the behavior of ELFObjectFile<ELFT>::getSymbolFlags().
     //    SymbolRef::getFlags() calls it internally. We can't test it directly,
     //    because it is protected.
     EXPECT_THAT_ERROR(BrokenSym.getFlags().takeError(),
                       FailedWithMessage(ErrMsg));
 
     // 5) Check the behavior of ELFObjectFile<ELFT>::getSymbolType().
     //    SymbolRef::getType() calls it internally. We can't test it directly,
     //    because it is protected.
-  EXPECT_THAT_ERROR(BrokenSym.getType().takeError(), FailedWithMessage(ErrMsg));
+    EXPECT_THAT_ERROR(BrokenSym.getType().takeError(),
+                      FailedWithMessage(ErrMsg));
 
     // 6) Check the behavior of ELFObjectFile<ELFT>::getSymbolAddress().
-  //    SymbolRef::getAddress() calls it internally. We can't test it directly,
-  //    because it is protected.
+    //    SymbolRef::getAddress() calls it internally. We can't test it
+    //    directly, because it is protected.
     EXPECT_THAT_ERROR(BrokenSym.getAddress().takeError(),
                       FailedWithMessage(ErrMsg));
 
     // Finally, check the `ELFFile<ELFT>::getEntry` API. This is an underlying
     // method that generates errors for all cases above.
-  EXPECT_THAT_EXPECTED(Elf.getEntry<typename ELF64LE::Sym>(**SymtabSecOrErr, 0),
-                       Succeeded());
+    EXPECT_THAT_EXPECTED(
+        Elf.getEntry<typename ELF64LE::Sym>(**SymtabSecOrErr, 0), Succeeded());
     EXPECT_THAT_ERROR(
         Elf.getEntry<typename ELF64LE::Sym>(**SymtabSecOrErr, BrokenSymIndex)
             .takeError(),
         FailedWithMessage(ErrMsg));
+  };
+
+  // We create a symbol with an index that is too large to exist in the symbol
+  // table.
+  DoCheck(0x1, "can't read an entry at 0x18: it goes past the end of the "
+               "section (0x18)");
+
+  // We create a symbol with an index that is too large to exist in the object.
+  DoCheck(0xFFFFFFFF, "can't read an entry at 0x17ffffffe8: it goes past the "
+                      "end of the section (0x18)");
 }