[llvm-readobj] - Refine logic of the symbol table locating in printRelocationsHelper().

[grimar]

Summary

This removes the last unwrapOrError call from the printRelocationsHelper.

There is a little additional complexity because of SHT_RELR/SHT_ANDROID_RELR sections.
Such sections contains only relative relocations and they do not have a
symbol table associated with them, hence we should not try to treat
their sh_link field as a reference to a symbol table.

[jhenderson]

I'm not convinced that this is the right approach, although I suppose I can understand it for simplicity. I think the original SHT_RELR proposal was mistaken to say there's an associated symbol table, since as you've already highlighted, it represents relative relocations. In fact, later versions of the proposal dropped this (see e.g. https://groups.google.com/g/generic-abi/c/bX460iggiKg/m/Jnz1lgLJAgAJ):

The corresponding sh_link and sh_info values in the section header hold no special information.

I think it is actually therefore a mistake to try to treat sh_link as a symbol table reference, and as such, we shouldn't warn for SHT_RELR.

[grimar]

In D85430#2205933, @jhenderson wrote:

I think the original SHT_RELR proposal was mistaken to say there's an associated symbol table, since as you've already highlighted, it represents relative relocations. In fact, later versions of the proposal dropped this (see e.g. https://groups.google.com/g/generic-abi/c/bX460iggiKg/m/Jnz1lgLJAgAJ):

Ok, I've also supposed there is some mistake, but was not 100% sure. Thanks for the link, I've missed that sh_link description was dropped later.
I'll update the implementation after landing the parent diff (D85303).

[grimar]

• Reimplemented in according to the discussion.

[jhenderson]

LGTM, with nit.

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

198–201

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

FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:     .rela.dyn
     Type:     SHT_ANDROID_RELA
     Flags:    [ SHF_ALLOC ]
-    Link:     .symtab
+    Link:     [[LINK=.symtab]]
     Content:  41505332088020020108800280010202088180808010818080802002080181808080100802818080802004020C7E048180808010088180808020
     ShOffset: [[SHOFFSET=<none>]]
 Symbols:
   - Name:    sym1
     Binding: STB_GLOBAL
   - Name:    sym2
     Binding: STB_GLOBAL
 
 ## Check we report a warning when we are unable to dump relocations for a SHT_ANDROID_RELA section.
 
 # RUN: yaml2obj --docnum=1 -DSHOFFSET=0xffffffff %s -o %t1.broken
 # RUN: llvm-readobj --relocations %t1.broken 2>&1 | FileCheck -DFILE=%t1.broken --check-prefix=BROKEN-RELA-LLVM %s
 # RUN: not llvm-readelf --relocations %t1.broken 2>&1 | FileCheck -DFILE=%t1.broken --check-prefix=BROKEN-RELA-GNU %s
 
 # BROKEN-RELA-LLVM:      Relocations [
 # BROKEN-RELA-LLVM-NEXT:   Section (1) .rela.dyn {
 # BROKEN-RELA-LLVM-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_ANDROID_RELA section with index 1: section [index 1] has a sh_offset (0xffffffff) + sh_size (0x3a) that is greater than the file size (0x238)
 # BROKEN-RELA-LLVM-NEXT:   }
 # BROKEN-RELA-LLVM-NEXT: ]
 
 ## FIXME: GNU still reports an error before trying to dump relocations.
 # BROKEN-RELA-GNU: error: '[[FILE]]': section [index 1] has a sh_offset (0xffffffff) + sh_size (0x3a) that is greater than the file size (0x238)
 
+## Check we report a warning when the sh_link field of the SHT_ANDROID_RELA section is broken.
+
+# RUN: yaml2obj --docnum=1 -DLINK=0xffffffff %s -o %t1.broken.link
+# RUN: llvm-readobj --relocations %t1.broken.link 2>&1 | \
+# RUN:   FileCheck -DFILE=%t1.broken.link --check-prefix=BROKEN-RELA-LINK-LLVM %s
+# RUN: llvm-readelf --relocations %t1.broken.link 2>&1 | \
+# RUN:   FileCheck -DFILE=%t1.broken.link --check-prefix=BROKEN-RELA-LINK-GNU %s
+
+# BROKEN-RELA-LINK-LLVM:      Relocations [
+# BROKEN-RELA-LINK-LLVM-NEXT:   Section (1) .rela.dyn {
+# BROKEN-RELA-LINK-LLVM-NEXT: warning: '[[FILE]]': unable to locate a symbol table for SHT_ANDROID_RELA section with index 1: invalid section index: 4294967295
+# BROKEN-RELA-LINK-LLVM-NEXT:   }
+# BROKEN-RELA-LINK-LLVM-NEXT: ]
+
+# BROKEN-RELA-LINK-GNU:      Relocation section '.rela.dyn' at offset 0x40 contains 8 entries:
+# BROKEN-RELA-LINK-GNU-NEXT:  Offset   Info  Type  Symbol's Value  Symbol's Name + Addend
+# BROKEN-RELA-LINK-GNU-NEXT: warning: '[[FILE]]': unable to locate a symbol table for SHT_ANDROID_RELA section with index 1: invalid section index: 4294967295
+
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj --relocations %t2 | FileCheck --check-prefix=LLVM2 %s
 # LLVM2:      Section (1) .rel.dyn {
 # LLVM2-NEXT:   0x1008 R_386_32 sym1 0x0
 # LLVM2-NEXT:   0x1010 R_386_GOT32 sym2 0x0
 # LLVM2-NEXT:   0x100C R_386_RELATIVE - 0x0
 # LLVM2-NEXT:   0x1008 R_386_RELATIVE - 0x0
 # LLVM2-NEXT:   0x1004 R_386_RELATIVE - 0x0
FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_386
 Sections:
   - Name:     .rel.dyn
     Type:     SHT_ANDROID_REL
     Flags:    [ SHF_ALLOC ]
-    Link:     .symtab
+    Link:     [[LINK=.symtab]]
     Content:  415053320A80200202088102830408037C08
     ShOffset: [[SHOFFSET=<none>]]
 Symbols:
   - Name:    sym1
     Binding: STB_GLOBAL
   - Name:    sym2
     Binding: STB_GLOBAL
 
 ## Check we report a warning when we are unable to dump relocations for a SHT_ANDROID_REL section.
 
 # RUN: yaml2obj --docnum=2 -DSHOFFSET=0xffffffff %s -o %t2.broken
 # RUN: llvm-readobj --relocations %t2.broken 2>&1 | FileCheck -DFILE=%t2.broken --check-prefix=BROKEN-REL-LLVM %s
 # RUN: not llvm-readelf --relocations %t2.broken 2>&1 | FileCheck -DFILE=%t2.broken --check-prefix=BROKEN-REL-GNU %s
 
 # BROKEN-REL-LLVM:      Relocations [
 # BROKEN-REL-LLVM-NEXT:   Section (1) .rel.dyn {
 # BROKEN-REL-LLVM-NEXT: warning: '[[FILE]]': unable to read relocations from SHT_ANDROID_REL section with index 1: section [index 1] has a sh_offset (0xffffffff) + sh_size (0x12) that cannot be represented
 # BROKEN-REL-LLVM-NEXT:   }
 # BROKEN-REL-LLVM-NEXT: ]
 
 ## FIXME: GNU still reports an error before trying to dump relocations.
 # BROKEN-REL-GNU: error: '[[FILE]]': section [index 1] has a sh_offset (0xffffffff) + sh_size (0x12) that cannot be represented
 
+## Check we report a warning when the sh_link field of the SHT_ANDROID_REL section is broken.
+
+# RUN: yaml2obj --docnum=2 -DLINK=0xffffffff %s -o %t2.broken.link
+# RUN: llvm-readobj --relocations %t2.broken.link 2>&1 | \
+# RUN:   FileCheck -DFILE=%t2.broken.link --check-prefix=BROKEN-REL-LINK-LLVM %s
+# RUN: llvm-readelf --relocations %t2.broken.link 2>&1 | \
+# RUN:   FileCheck -DFILE=%t2.broken.link --check-prefix=BROKEN-REL-LINK-GNU %s
+
+# BROKEN-REL-LINK-LLVM:      Relocations [
+# BROKEN-REL-LINK-LLVM-NEXT:   Section (1) .rel.dyn {
+# BROKEN-REL-LINK-LLVM-NEXT: warning: '[[FILE]]': unable to locate a symbol table for SHT_ANDROID_REL section with index 1: invalid section index: 4294967295
+# BROKEN-REL-LINK-LLVM-NEXT:   }
+# BROKEN-REL-LINK-LLVM-NEXT: ]
+
+# BROKEN-REL-LINK-GNU:      Relocation section '.rel.dyn' at offset 0x34 contains 10 entries:
+# BROKEN-REL-LINK-GNU-NEXT:  Offset  Info  Type  Sym. Value  Symbol's Name
+# BROKEN-REL-LINK-GNU-NEXT: warning: '[[FILE]]': unable to locate a symbol table for SHT_ANDROID_REL section with index 1: invalid section index: 4294967295
+
 # RUN: yaml2obj --docnum=3 %s | llvm-readobj --relocations - | FileCheck --check-prefix=LLVM3 %s
 #
 # LLVM3:      Section (1) .rela.dyn {
 # LLVM3-NEXT:   0x1100 R_X86_64_RELATIVE - 0x0
 # LLVM3-NEXT:   0x1180 R_X86_64_RELATIVE - 0x8
 # LLVM3-NEXT:   0x1200 R_X86_64_64 sym1 0x0
 # LLVM3-NEXT:   0x1208 R_X86_64_64 sym2 0x0
 # LLVM3-NEXT:   0x1210 R_X86_64_64 sym1 0x0

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

FileHeader:
   Machine: EM_X86_64
 Sections:
   - Name: .text
     Type: SHT_PROGBITS
     Content: '00FFFFFFFF020000001234567890ABCDEF'
   - Name:    .rel.text
     Type:    SHT_REL
     Info:    .text
+    Link:    [[LINK=.symtab]]
     ShName:  [[SHNAME=<none>]]
     EntSize: [[ENTSIZEREL=<none>]]
     Relocations:
       - Symbol: rel_0
         Type:   R_X86_64_NONE
       - Offset: 0x1
         Symbol: rel_neg
         Type:   R_X86_64_PC32
       - Offset: 0x5
         Symbol: rel_pos
         Type:   R_X86_64_PLT32
       - Offset: 0x9
         Symbol: rel_64
         Type:   R_X86_64_64
   - Name:    .rela.text
     Type:    SHT_RELA
     Info:    .text
+    Link:    [[LINK=.symtab]]
     ShName:  [[SHNAME=<none>]]
     EntSize: [[ENTSIZERELA=<none>]]
     Relocations:
       - Symbol: rela_0
         Type:   R_X86_64_NONE
         Addend: 0
       - Offset: 0x1
         Symbol: rela_neg
Symbols:
   - Name:    rela_maxpos
     Section: .text
     Value:   0xFFFFFFFFFFFFFFFF
 
 ## Check we report a warning when we are unable to dump relocations for a section.
 ## Check we continue dumping other relocation sections if any.
 
 ## Case A: check the case when relocations can't be read from an SHT_REL section.
+##         because of broken sh_entsize field.
 # 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-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-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
 
+## 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
+
+# BROKEN-LINK-LLVM:      Relocations [
+# BROKEN-LINK-LLVM-NEXT:   Section (2) .rel.text {
+# BROKEN-LINK-LLVM-NEXT: warning: '[[FILE]]': unable to locate a symbol table for SHT_REL section with index 2: invalid section index: 65535
+# BROKEN-LINK-LLVM-NEXT:   }
+# BROKEN-LINK-LLVM-NEXT:   Section (3) .rela.text {
+# BROKEN-LINK-LLVM-NEXT: warning: '[[FILE]]': unable to locate a symbol table for SHT_RELA section with index 3: invalid section index: 65535
+# BROKEN-LINK-LLVM-NEXT:   }
+# BROKEN-LINK-LLVM-NEXT: ]
+
+# BROKEN-LINK-GNU:      Relocation section '.rel.text' at offset 0x51 contains 4 entries:
+# BROKEN-LINK-GNU-NEXT:     Offset             Info             Type               Symbol's Value  Symbol's Name
+# BROKEN-LINK-GNU-NEXT: warning: '[[FILE]]': unable to locate a symbol table for SHT_REL section with index 2: invalid section index: 65535
+# BROKEN-LINK-GNU-EMPTY:
+# BROKEN-LINK-GNU-NEXT: Relocation section '.rela.text' at offset 0x91 contains 5 entries:
+# BROKEN-LINK-GNU-NEXT:     Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
+# BROKEN-LINK-GNU-NEXT: warning: '[[FILE]]': unable to locate a symbol table for SHT_RELA section with index 3: invalid section index: 65535
+
 ## Show that ELF32 is dumped correctly.
 # RUN: yaml2obj %s --docnum=2 -o %t32
 # RUN: llvm-readobj -r %t32 \
 # RUN:   | FileCheck %s --check-prefix=LLVM-32 --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --relocs %t32 \
 # RUN:   | FileCheck %s --check-prefix=LLVM-32 --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --relocations %t32 \
 # RUN:   | FileCheck %s --check-prefix=LLVM-32 --strict-whitespace --match-full-lines

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

 Sections:
   - Name:    .relr.dyn
     Type:    SHT_RELR
     Flags:   [ SHF_ALLOC ]
     Entries: [ 0x00010D60, 0x00000103, 0x00020000,
                0x000F0501, 0x50400009 ]
     EntSize: [[ENTSIZE=<none>]]
     ShType:  [[SHTYPE=<none>]]
+    Link:    [[LINK=""]]
 
 ## Check we report a warning when we are unable to dump relocations
 ## for a SHT_RELR/SHT_ANDROID_RELR section.
 
 ## Case A: check the case when relocations can't be read from an SHT_RELR section.
 # 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

 ## 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: not llvm-readelf --relocations %t2.broken.android 2>&1 | \
 # RUN:   FileCheck -DFILE=%t2.broken.android --check-prefix=BROKEN-GNU %s
+
+## Check the behavior when the sh_link field of the SHT_RELR/SHT_ANDROID_RELR section
+## is set to an arbitrary value. Normally, it is set to 0, because such sections contains
+## only relative relocations and do not have an associated symbol table, like other
+## relocation sections.
+
+## Case A: check we do not report warnings when the sh_link field is set to an arbitrary value
+##         and the --relocations option is requested.
+# RUN: yaml2obj --docnum=2 -DLINK=0xff %s -o %t2.has.link
+# RUN: llvm-readobj --relocations %t2.has.link 2>&1 | \
+# RUN:   FileCheck -DFILE=%t2.has.link --check-prefix=LLVM2 %s --implicit-check-not=warning:
+# RUN: llvm-readelf --relocations %t2.has.link 2>&1 | \
+# RUN:   FileCheck -DFILE=%t2.has.link --check-prefix=GNU2 %s --implicit-check-not=warning:
+
+## Case B: check we do not report warnings when the sh_link field is set to an arbitrary value
+##         and --relocations and --raw-relr options are requested.
+# RUN: llvm-readobj --relocations --raw-relr %t2.has.link | \
+# RUN:   FileCheck -DFILE=%t2.has.link --check-prefix=RAW-LLVM2 %s
+# RUN: llvm-readelf --relocations --raw-relr %t2.has.link 2>&1 | \
+# RUN:   FileCheck -DFILE=%t2.has.link --check-prefix=RAW-GNU2 %s

llvm/tools/llvm-readobj/ELFDumper.cpp

for (const uint8_t *I = Contents.begin(), *E = Contents.end(); I < E;) {
       I += Lib.size() + 1;
     }
   }
 }
 
 template <class ELFT>
 void DumpStyle<ELFT>::printRelocationsHelper(const ELFFile<ELFT> *Obj,
                                              const Elf_Shdr &Sec) {
-  const Elf_Shdr *SymTab =
-      unwrapOrError(this->FileName, Obj->getSection(Sec.sh_link));
-  unsigned SecNdx = &Sec - &cantFail(Obj->sections()).front();
-  unsigned RelNdx = 0;
-
-  auto Warn = [&](Error &&E) {
-    this->reportUniqueWarning(createError("unable to read relocations from " +
-                                          describe(Obj, Sec) + ": " +
-                                          toString(std::move(E))));
+  auto Warn = [&](Error &&E,
+                  const Twine &Prefix = "unable to read relocations from") {
+    this->reportUniqueWarning(createError(Prefix + " " + describe(Obj, Sec) +
+                                          ": " + toString(std::move(E))));
   };
 
+  // SHT_RELR/SHT_ANDROID_RELR sections do not have an associated symbol table.
+  // For them we should not treat the value of the sh_link field as an index of
+  // a symbol table.
+  const Elf_Shdr *SymTab;
+  if (Sec.sh_type != ELF::SHT_RELR && Sec.sh_type != ELF::SHT_ANDROID_RELR) {
+    Expected<const Elf_Shdr *> SymTabOrErr = Obj->getSection(Sec.sh_link);
+    if (!SymTabOrErr) {
+      Warn(SymTabOrErr.takeError(), "unable to locate a symbol table for");
+      return;
+    }
+    SymTab = *SymTabOrErr;
+  }
+
+  unsigned SecNdx = &Sec - &cantFail(Obj->sections()).front();
+  unsigned RelNdx = 0;
   switch (Sec.sh_type) {
   case ELF::SHT_REL:
     if (Expected<Elf_Rel_Range> RangeOrErr = Obj->rels(&Sec)) {
       for (const Elf_Rel &R : *RangeOrErr)
         printRelReloc(Obj, SecNdx, SymTab, R, ++RelNdx);
     } else {
       Warn(RangeOrErr.takeError());
     }
case ELF::SHT_ANDROID_RELR: {
     }
     if (opts::RawRelr) {
       for (const Elf_Relr &R : *RangeOrErr)
         printRelrReloc(R);
       break;
     }
 
     for (const Elf_Rel &R : Obj->decode_relrs(*RangeOrErr))
-      printRelReloc(Obj, SecNdx, SymTab, R, ++RelNdx);
+      printRelReloc(Obj, SecNdx, /*SymTab=*/nullptr, R, ++RelNdx);
     break;
   }
   case ELF::SHT_ANDROID_REL:
   case ELF::SHT_ANDROID_RELA:
     if (Expected<std::vector<Elf_Rela>> RelasOrErr = Obj->android_relas(&Sec)) {
       for (const Elf_Rela &R : *RelasOrErr)
         printRelaReloc(Obj, SecNdx, SymTab, R, ++RelNdx);
     } else {