## Check llvm-readelf is able to dump the content of hash sections correctly.

## Check the output when both .hash and .gnu.hash sections are present.

# RUN: yaml2obj --docnum=1 -DBITS=32 %s -o %t1-32.so
# RUN: llvm-readelf --hash-symbols %t1-32.so \
# RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix HASH-32

# RUN: yaml2obj --docnum=1 -DBITS=64 %s -o %t1-64.so
# RUN: llvm-readelf --hash-symbols %t1-64.so | FileCheck %s --check-prefix HASH-64

# HASH-32: Symbol table of .hash for image:
# HASH-32-NEXT:  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# HASH-32-NEXT:    1   0: 00000000     0 NOTYPE  GLOBAL DEFAULT UND ccc
# HASH-32-NEXT:    5   0: 00001001     0 NOTYPE  WEAK   DEFAULT   1 bbb
# HASH-32-NEXT:    3   0: 00000001     0 NOTYPE  GLOBAL DEFAULT ABS ddd
# HASH-32-NEXT:    2   0: 00001000     0 NOTYPE  GLOBAL DEFAULT   1 aaa
# HASH-32-NEXT:    4   0: 00000000     0 NOTYPE  GLOBAL DEFAULT   2 eee
# HASH-32-EMPTY:
# HASH-32: Symbol table of .gnu.hash for image:
# HASH-32-NEXT:  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# HASH-32-NEXT:    2   1: 00001000     0 NOTYPE  GLOBAL DEFAULT   1 aaa
# HASH-32-NEXT:    3   1: 00000001     0 NOTYPE  GLOBAL DEFAULT ABS ddd
# HASH-32-NEXT:    4   2: 00000000     0 NOTYPE  GLOBAL DEFAULT   2 eee
# HASH-32-NEXT:    5   2: 00001001     0 NOTYPE  WEAK   DEFAULT   1 bbb
# HASH-32-NOT: {{.}}

# HASH-64:      Symbol table of .hash for image:
# HASH-64-NEXT:  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name
# HASH-64-NEXT:    1   0: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT UND ccc
# HASH-64-NEXT:    5   0: 0000000000001001     0 NOTYPE  WEAK   DEFAULT   1 bbb
# HASH-64-NEXT:    3   0: 0000000000000001     0 NOTYPE  GLOBAL DEFAULT ABS ddd
# HASH-64-NEXT:    2   0: 0000000000001000     0 NOTYPE  GLOBAL DEFAULT   1 aaa
# HASH-64-NEXT:    4   0: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT   2 eee
# HASH-64-EMPTY:
# HASH-64-NEXT: Symbol table of .gnu.hash for image:
# HASH-64-NEXT:  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name
# HASH-64-NEXT:    2   1: 0000000000001000     0 NOTYPE  GLOBAL DEFAULT   1 aaa
# HASH-64-NEXT:    3   1: 0000000000000001     0 NOTYPE  GLOBAL DEFAULT ABS ddd
# HASH-64-NEXT:    4   2: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT   2 eee
# HASH-64-NEXT:    5   2: 0000000000001001     0 NOTYPE  WEAK   DEFAULT   1 bbb
# HASH-64-NOT: {{.}}

--- !ELF
FileHeader:
  Class: ELFCLASS[[BITS]]
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:    .hash
    Type:    SHT_HASH
    Flags:   [ SHF_ALLOC ]
    Link:    .dynsym
    Bucket:  [ 1, 0, 0 ]
    Chain:   [ 0, 5, 4, 2, 0, 3 ]
  - Name:    .gnu.hash
    Type:    SHT_GNU_HASH
    Flags:   [ SHF_ALLOC ]
    Link:    .dynsym
    Header:
      SymNdx: 0x2
      Shift2: 0x0
    BloomFilter: [ 0x0 ]
    HashBuckets: [ 0x0, 0x2, 0x4 ]
    HashValues:  [ 0x0B885C68, 0x0B886991, 0x0B886DF4, 0x0B8860CB ]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Flags: [ SHF_ALLOC ]
    Link:  .dynstr
    Entries:
## PT_LOAD's p_vaddr is 0x0. DT_HASH value is 0x0. 
## llvm-readelf will read .hash content from PT_LOAD's p_offset + (DT_HASH value - p_vaddr).
## This matches the file offset of the .hash section.
      - Tag:   DT_HASH
        Value: 0x0000000000000000
      - Tag:   DT_GNU_HASH
## PT_LOAD's p_vaddr is 0x0. DT_GNU_HASH value is 0x2c (size of .hash = 0x2c).
## llvm-readelf will read .gnu.hash content from PT_LOAD's p_offset + (DT_GNU_HASH value - p_vaddr).
## This matches the file offset of the .gnu.hash section.
        Value: 0x000000000000002C
      - Tag:   DT_NULL
        Value: 0x0000000000000000
DynamicSymbols:
  - Name:    [[NAME=ccc]]
    Binding: STB_GLOBAL
    Type:    [[TYPE=STT_NOTYPE]]
  - Name:    [[NAME=aaa]]
    Section: .hash
    Binding: STB_GLOBAL
    Value:   0x0000000000001000
    Type:    [[TYPE=STT_NOTYPE]]
  - Name:    [[NAME=ddd]]
    Index:   SHN_ABS
    Binding: STB_GLOBAL
    Value:   0x0000000000000001
    Type:    [[TYPE=STT_NOTYPE]]
  - Name:    [[NAME=eee]]
    Section: .gnu.hash
    Binding: STB_GLOBAL
    Type:    [[TYPE=STT_NOTYPE]]
  - Name:    [[NAME=bbb]]
    Section: .hash
    Binding: STB_WEAK
    Value:   0x0000000000001001
    Type:    [[TYPE=STT_NOTYPE]]
ProgramHeaders:
  - Type:      PT_LOAD
    Flags:     [ PF_R, PF_X ]
    FirstSec:  .hash
    LastSec:   .dynamic

## Check what we print for unnamed section symbols.
# RUN: yaml2obj --docnum=1 -DBITS=64 -DTYPE=STT_SECTION -DNAME="''" %s -o %t1-sec-syms.so
# RUN: llvm-readelf --hash-symbols %t1-sec-syms.so 2>&1 | \
# RUN:   FileCheck %s -DFILE=%t1-sec-syms.so --check-prefix=UNNAMED-SEC-SYMS

# UNNAMED-SEC-SYMS:      Symbol table of .hash for image:
# UNNAMED-SEC-SYMS-NEXT:  Num   {{.*}} Ndx Name
# UNNAMED-SEC-SYMS-NEXT: warning: '[[FILE]]': unable to get section index for symbol with st_shndx = 0x0 (SHN_UNDEF)
# UNNAMED-SEC-SYMS-NEXT:    1   {{.*}} UND <?>
# UNNAMED-SEC-SYMS-NEXT:    5   {{.*}}   1 .hash
# UNNAMED-SEC-SYMS-NEXT: warning: '[[FILE]]': unable to get section index for symbol with st_shndx = 0xfff1 (SHN_ABS)
# UNNAMED-SEC-SYMS-NEXT:    3   {{.*}} ABS <?>
# UNNAMED-SEC-SYMS-NEXT:    2   {{.*}}   1 .hash
# UNNAMED-SEC-SYMS-NEXT:    4   {{.*}}   2 .gnu.hash
# UNNAMED-SEC-SYMS-EMPTY:
# UNNAMED-SEC-SYMS:      Symbol table of .gnu.hash for image:
# UNNAMED-SEC-SYMS-NEXT:  Num {{.*}} Ndx Name
# UNNAMED-SEC-SYMS-NEXT:    2 {{.*}}   1 .hash
# UNNAMED-SEC-SYMS-NEXT:    3 {{.*}} ABS <?>
# UNNAMED-SEC-SYMS-NEXT:    4 {{.*}}   2 .gnu.hash
# UNNAMED-SEC-SYMS-NEXT:    5 {{.*}}   1 .hash

## Check the output when only .hash section is present.

# RUN: yaml2obj --docnum=2 %s -o %t2-32.so
# RUN: llvm-readelf --hash-symbols %t2-32.so \
# RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ONLY-HASH-32

# ONLY-HASH-32: Symbol table of .hash for image:
# ONLY-HASH-32-NEXT:  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# ONLY-HASH-32-NEXT:    1   0: 00000000     0 NOTYPE  GLOBAL DEFAULT UND ccc
# ONLY-HASH-32-NEXT:    5   0: 00001001     0 NOTYPE  WEAK   DEFAULT   1 bbb
# ONLY-HASH-32-NEXT:    3   0: 00000001     0 NOTYPE  GLOBAL DEFAULT ABS ddd
# ONLY-HASH-32-NEXT:    2   0: 00001000     0 NOTYPE  GLOBAL DEFAULT   1 aaa
# ONLY-HASH-32-NEXT:    4   0: 00000000     0 NOTYPE  GLOBAL DEFAULT   2 eee
# ONLY-HASH-32-NOT: {{.}}

--- !ELF
FileHeader:
  Class: ELFCLASS32
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:    .hash
    Type:    SHT_HASH
    Flags:   [ SHF_ALLOC ]
    Link:    .dynsym
    Bucket: [ 1, 0, 0 ]
    Chain:  [ 0, 5, 4, 2, 0, 3 ]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Flags: [ SHF_ALLOC ]
    Link:  .dynstr
    Entries:
      - Tag:   DT_HASH
        Value: 0x0000000000000000
      - Tag:   DT_NULL
        Value: 0x0000000000000000
DynamicSymbols:
  - Name:    ccc
    Binding: STB_GLOBAL
  - Name:    aaa
    Section: .hash
    Binding: STB_GLOBAL
    Value:   0x0000000000001000
  - Name:    ddd
    Index:   SHN_ABS
    Binding: STB_GLOBAL
    Value:   0x0000000000000001
  - Name:    eee
    Section: .dynamic
    Binding: STB_GLOBAL
  - Name:    bbb
    Section: .hash
    Binding: STB_WEAK
    Value:   0x0000000000001001
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_R, PF_X ]
    FirstSec: .hash
    LastSec:  .dynamic

## Check the output when only .gnu.hash section is present.

# RUN: yaml2obj --docnum=3 %s -o %t3-32.so
# RUN: llvm-readelf --hash-symbols %t3-32.so \
# RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ONLY-GNUHASH-32

# ONLY-GNUHASH-32: Symbol table of .gnu.hash for image:
# ONLY-GNUHASH-32-NEXT:  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# ONLY-GNUHASH-32-NEXT:    2   1: 00001000     0 NOTYPE  GLOBAL DEFAULT   2 aaa
# ONLY-GNUHASH-32-NEXT:    3   1: 00000001     0 NOTYPE  GLOBAL DEFAULT ABS ddd
# ONLY-GNUHASH-32-NEXT:    4   2: 00000000     0 NOTYPE  GLOBAL DEFAULT   1 eee
# ONLY-GNUHASH-32-NEXT:    5   2: 00001001     0 NOTYPE  WEAK   DEFAULT   2 bbb
# ONLY-GNUHASH-32-NOT: {{.}}

--- !ELF
FileHeader:
  Class: ELFCLASS32
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:    .gnu.hash
    Type:    SHT_GNU_HASH
    Flags:   [ SHF_ALLOC ]
    Link:    .dynsym
    Header:
      SymNdx: 0x2
      Shift2: 0x0
    BloomFilter: [ 0x0 ]
    HashBuckets: [ 0x0, 0x2, 0x4 ]
    HashValues:  [ 0x0B885C68, 0x0B886991, 0x0B886DF4, 0x0B8860CB ]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Flags: [ SHF_ALLOC ]
    Link:  .dynstr
    Entries:
      - Tag:   DT_GNU_HASH
        Value: 0x0000000000000000
      - Tag:   DT_NULL
        Value: 0x0000000000000000
DynamicSymbols:
  - Name:    ccc
    Binding: STB_GLOBAL
  - Name:    aaa
    Section: .dynamic
    Binding: STB_GLOBAL
    Value:   0x0000000000001000
  - Name:    ddd
    Index:   SHN_ABS
    Binding: STB_GLOBAL
    Value:   0x0000000000000001
  - Name:    eee
    Section: .gnu.hash
    Binding: STB_GLOBAL
  - Name:    bbb
    Section: .dynamic
    Binding: STB_WEAK
    Value:   0x0000000000001001
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_R, PF_X ]
    FirstSec: .gnu.hash
    LastSec:  .dynamic

## Show that if there are no hash sections, we do not print anything.
# RUN: yaml2obj --docnum=4 %s -o %t4.so
# RUN: llvm-readelf --hash-symbols %t4.so \
# RUN:   | FileCheck %s --check-prefix NO-HASH --allow-empty

# NO-HASH-NOT: {{.}}

## Sanity check that we can still find the dynamic symbols (i.e. the above test
## doesn't pass due to a mistake in the dynamic section).
# RUN: llvm-readelf --dyn-symbols %t4.so | FileCheck %s --check-prefix DYNSYMS

# DYNSYMS: Symbol table '.dynsym' contains 2 entries:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:         .dynstr
    Type:         SHT_STRTAB
    Flags:        [ SHF_ALLOC ]
    AddressAlign: 0x100
    EntSize:      0x1
  - Name:         .dynsym
    Type:         SHT_DYNSYM
    Flags:        [ SHF_ALLOC ]
    Link:         .dynstr
    Address:      0x100
    AddressAlign: 0x100
    EntSize:      0x18
  - Name:         .dynamic
    Type:         SHT_DYNAMIC
    Flags:        [ SHF_ALLOC ]
    Address:      0x0000000000001000
    Link:         .dynstr
    AddressAlign: 0x0000000000001000
    EntSize:      0x0000000000000010
    Entries:
      - Tag:   DT_STRTAB
        Value: 0x0000000000000000
      - Tag:   DT_STRSZ
        Value: 0x0000000000000009
      - Tag:   DT_SYMTAB
        Value: 0x0000000000000100
      - Tag:   DT_SYMENT
        Value: 0x0000000000000018
      - Tag:   DT_NULL
        Value: 0x0000000000000000
  - Name:  .text.foo
    Type:  SHT_PROGBITS
    Flags: [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ]
    Size:  0x40
    Address: 0x2000
    AddressAlign: 0x2000
DynamicSymbols:
  - Name:    _Z3fooi
    Binding: STB_GLOBAL
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_R, PF_X ]
    VAddr:    0x0
    FirstSec: .dynstr
    LastSec:  .text.foo
  - Type:     PT_DYNAMIC
    Flags:    [ PF_R ]
    VAddr:    0x1000
    FirstSec: .dynamic
    LastSec:  .dynamic

## Show that we report a warning for a hash table which contains an entry of
## the bucket array pointing to a cycle.

# RUN: yaml2obj --docnum=5 %s -o %t5.so
# RUN: llvm-readelf --hash-symbols %t5.so 2>&1 | \
# RUN:   FileCheck %s -DFILE=%t5.so --check-prefix=BROKEN --implicit-check-not=warning:

# BROKEN:      Symbol table of .hash for image:
# BROKEN-NEXT:  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# BROKEN-NEXT:    1   0: 00000000     0 NOTYPE  LOCAL  DEFAULT UND aaa
# BROKEN: warning: '[[FILE]]': .hash section is invalid: bucket 1: a cycle was detected in the linked chain
# BROKEN-NEXT:    1   1: 00000000     0 NOTYPE  LOCAL  DEFAULT UND aaa
# BROKEN-NOT: {{.}}

--- !ELF
FileHeader:
  Class: ELFCLASS32
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:    .hash
    Type:    SHT_HASH
    Link:    .dynsym
    Bucket:  [ 1, 1 ]
    Chain:   [ 1, 1 ]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Entries:
## llvm-readelf will read the hash table from the file offset
## p_offset + (p_vaddr - DT_HASH) = p_offset + (0 - 0) = p_offset,
## which is the start of PT_LOAD, i.e. the file offset of .hash.
      - Tag:   DT_HASH
        Value: 0x0
DynamicSymbols:
  - Name: aaa
ProgramHeaders:
  - Type:     PT_LOAD
    FirstSec: .hash
    LastSec:  .dynamic

## Each SHT_HASH section starts with two 32-bit fields: nbucket and nchain.
## Check we report an error when a DT_HASH value points to data that has size less than 8 bytes.

# RUN: yaml2obj --docnum=6 %s -o %t6.o
# RUN: llvm-readelf --hash-symbols %t6.o 2>&1 | FileCheck %s --check-prefix=ERR1 -DFILE=%t6.o

# ERR1: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8){{$}}

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:   .hash
    Type:   SHT_HASH
    Flags:  [ SHF_ALLOC ]
    Bucket: [ 0 ]
    Chain:  [ 0 ]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Flags: [ SHF_WRITE, SHF_ALLOC ]
    Entries:
      - Tag:   DT_HASH
        Value: 0x239
      - Tag:   DT_NULL
        Value: 0x0
DynamicSymbols: []
ProgramHeaders:
  - Type:     PT_LOAD
    FileSize: 0x23a
    FirstSec: .hash
    LastSec:  .dynamic

## Check we report a warning when the hash table goes past the end of the file.

## Case A.1: the hash table ends right before the EOF. We have a broken nbucket
##           field that has a value larger than the number of buckets.
# RUN: yaml2obj --docnum=7 %s -o %t7.1.o -DNBUCKET=0x5d
# RUN: llvm-readelf --hash-symbols %t7.1.o 2>&1 | FileCheck %s --check-prefix=NOERR1
# NOERR1:            Symbol table of .hash for image:
# NOERR1-NEXT:         Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# NOERR1-NEXT-EMPTY:

## Case A.2: the hash table ends 1 byte past the EOF. We have a broken nbucket
##           field that has a value larger than the number of buckets.
# RUN: yaml2obj --docnum=7 %s -o %t7.2.o -DNBUCKET=0x5e
# RUN: llvm-readelf --hash-symbols %t7.2.o 2>&1 | FileCheck %s --check-prefix=ERR2 -DFILE=%t7.2.o
# ERR2:      Symbol table of .hash for image:
# ERR2-NEXT: warning: '[[FILE]]': the hash table at offset 0x54 goes past the end of the file (0x1d4), nbucket = 94, nchain = 1{{$}}
# ERR2-NOT:  {{.}}

## Case B.1: the hash table ends right before the EOF. We have a broken nchain
##           field that has a value larger than the number of chains.
# RUN: yaml2obj --docnum=7 %s -o %t7.3.o -DNCHAIN=0x5d
# RUN: llvm-readelf --hash-symbols %t7.3.o 2>&1 | \
# RUN:   FileCheck %s --implicit-check-not="warning:" --check-prefix=NOERR2 -DFILE=%t7.3.o
# NOERR2:      warning: '[[FILE]]': hash table nchain (93) differs from symbol count derived from SHT_DYNSYM section header (1)
# NOERR2:      warning: '[[FILE]]': the size (0x5d0) of the dynamic symbol table at 0x78, derived from the hash table, goes past the end of the file (0x1d4) and will be ignored
# NOERR2:      Symbol table of .hash for image:
# NOERR2-NEXT: Num Buc: Value Size Type Bind Vis Ndx Name
# NOERR2-NOT:  {{.}}

## Case B.2: the hash table ends 1 byte past the EOF. We have a broken nchain
##           field that has a value larger than the number of chains.
# RUN: yaml2obj --docnum=7 %s -o %t7.4.o -DNCHAIN=0x5e
# RUN: llvm-readelf --hash-symbols %t7.4.o 2>&1 | FileCheck %s --check-prefix=ERR3 -DFILE=%t7.4.o
# ERR3:      Symbol table of .hash for image:
# ERR3-NEXT: warning: '[[FILE]]': the hash table at offset 0x54 goes past the end of the file (0x1d4), nbucket = 1, nchain = 94{{$}}
# ERR3-NOT:  {{.}}

--- !ELF
FileHeader:
  Class: ELFCLASS32
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:    .hash
    Type:    SHT_HASH
    Flags:   [ SHF_ALLOC ]
    Bucket:  [ 0 ]
    NBucket: [[NBUCKET=1]]
    Chain:   [ 0 ]
    NChain:  [[NCHAIN=1]]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Flags: [ SHF_WRITE, SHF_ALLOC ]
    Entries:
      - Tag:   DT_HASH
        Value: 0x0
      - Tag:   DT_NULL
        Value: 0x0
DynamicSymbols: []
ProgramHeaders:
  - Type:     PT_LOAD
    FirstSec: .hash
    LastSec:  .dynamic

## Check we report a proper warning when a GNU hash table goes past the end of the file.

## Case A: the 'maskwords' field is set so that the table goes past the end of the file.
# RUN: yaml2obj --docnum=8 -D MASKWORDS=4294967295 %s -o %t.err.maskwords
# RUN: llvm-readelf --hash-symbols %t.err.maskwords 2>&1 | \
# RUN:   FileCheck %s -DFILE=%t.err.maskwords --check-prefix=ERR4

# ERR4:      Symbol table of .gnu.hash for image:
# ERR4-NEXT:  Num Buc: Value Size Type Bind Vis Ndx Name
# ERR4-NEXT: warning: '[[FILE]]': unable to dump the SHT_GNU_HASH section at 0x78: it goes past the end of the file

## Case B: the 'nbuckets' field is set so that the table goes past the end of the file.
# RUN: yaml2obj --docnum=8 -D NBUCKETS=4294967295 %s -o %t.err.nbuckets
# RUN: llvm-readelf --hash-symbols %t.err.nbuckets 2>&1 | \
# RUN:   FileCheck %s -DFILE=%t.err.nbuckets --check-prefix=ERR4

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:  .gnu.hash
    Type:  SHT_GNU_HASH
    Flags: [ SHF_ALLOC ]
    Header:
      SymNdx: 0x1
      Shift2: 0x2
## The number of words in the Bloom filter. The value of 2 is no-op.
      MaskWords: [[MASKWORDS=2]]
## The number of hash buckets. The value of 3 is no-op.
      NBuckets:  [[NBUCKETS=3]]
    BloomFilter: [0x3, 0x4]
    HashBuckets: [0x5, 0x6, 0x7]
    HashValues:  [0x8, 0x9, 0xA, 0xB]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Flags: [ SHF_ALLOC ]
    Link:  .dynstr
    Entries:
      - Tag:   DT_GNU_HASH
        Value: 0x0
      - Tag:   DT_NULL
        Value: 0x0
DynamicSymbols:
  - Name:    aaa
    Binding: STB_GLOBAL
  - Name:    bbb
    Binding: STB_GLOBAL
  - Name:    ccc
    Binding: STB_GLOBAL
  - Name:    ddd
    Binding: STB_GLOBAL
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_R, PF_X ]
    FirstSec: .gnu.hash
    LastSec:  .dynamic

## Check the behavior when the dynamic symbol table is empty or not found.

## Case A.1: Check we report a warning when the dynamic symbol table is empty and we attempt to print hash symbols
##         from the .hash table. The number of symbols in the dynamic symbol table can be calculated from its size
##         or derived from the Chain vector of the .hash table. Make both ways to return a zero to do the check.
# RUN: yaml2obj --docnum=9 %s -o %t9.1.so
# RUN: llvm-readelf --hash-symbols %t9.1.so 2>&1 | FileCheck %s -DFILE=%t9.1.so --check-prefix=DYNSYM-EMPTY-HASH

# DYNSYM-EMPTY-HASH:      Symbol table of .hash for image:
# DYNSYM-EMPTY-HASH-NEXT:   Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# DYNSYM-EMPTY-HASH-NEXT: warning: '[[FILE]]': unable to print symbols for the .hash table: the dynamic symbol table is empty
# DYNSYM-EMPTY-HASH-NOT:  {{.}}

--- !ELF
FileHeader:
  Class: ELFCLASS32
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:   .hash
    Type:   SHT_HASH
    Flags:  [ SHF_ALLOC ]
    Bucket: [ 0 ]
    Chain:  [ ]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Flags: [ SHF_ALLOC ]
    Entries:
      - Tag:   DT_HASH
        Value: 0x0
      - Tag:   DT_STRTAB
## PT_LOAD p_offset == .hash offset == 0x54.
## 0x54 + 0x2c == 0x80 == .dynstr offset.
        Value: 0x2c
      - Tag:   DT_STRSZ
        Value: 0x1
      - Tag:   DT_NULL
        Value: 0x0
  - Name:  .dynstr
    Type:  SHT_STRTAB
    Flags: [ SHF_ALLOC ]
  - Name:  .dynsym
    Type:  [[DYNSYMTYPE=SHT_DYNSYM]]
    Flags: [ SHF_ALLOC ]
    Size:  0
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_R, PF_X ]
    FirstSec: .hash
    LastSec:  .dynstr

## Case A.2: similar to A.1, but now check that we report a warning when the dynamic symbol table was not found.
##           To do that, set the type of the .dynsym to SHT_PROGBITS to hide it.
# RUN: yaml2obj --docnum=9 -DDYNSYMTYPE=SHT_PROGBITS %s -o %t9.2.so
# RUN: llvm-readelf --hash-symbols %t9.2.so 2>&1 | FileCheck %s -DFILE=%t9.2.so --check-prefix=DYNSYM-NOTFOUND-HASH

# DYNSYM-NOTFOUND-HASH:      Symbol table of .hash for image:
# DYNSYM-NOTFOUND-HASH-NEXT:   Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# DYNSYM-NOTFOUND-HASH-NEXT: warning: '[[FILE]]': unable to print symbols for the .hash table: the dynamic symbol table was not found
# DYNSYM-NOTFOUND-HASH-NOT:  {{.}}

## Case B.1: Check we report a warning when the dynamic symbol table is empty and we attempt to print
##           hash symbols from the .gnu.hash table.
# RUN: yaml2obj --docnum=10 %s -o %t10.1.so
# RUN: llvm-readelf --hash-symbols %t10.1.so 2>&1 | FileCheck %s -DFILE=%t10.1.so --check-prefix=DYNSYM-EMPTY-GNUHASH

# DYNSYM-EMPTY-GNUHASH:      Symbol table of .gnu.hash for image:
# DYNSYM-EMPTY-GNUHASH-NEXT:  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# DYNSYM-EMPTY-GNUHASH-NEXT: warning: '[[FILE]]': unable to print symbols for the .gnu.hash table: the dynamic symbol table is empty
# DYNSYM-EMPTY-GNUHASH-NOT:  {{.}}

## Case B.2: similar to B.1, but now check that we report a warning when the dynamic symbol table was not found.
##           To do that, set the type of the .dynsym to SHT_PROGBITS to hide it.
# RUN: yaml2obj --docnum=10 -DDYNSYMTYPE=SHT_PROGBITS %s -o %t10.2.so
# RUN: llvm-readelf --hash-symbols %t10.2.so 2>&1 | FileCheck %s -DFILE=%t10.2.so --check-prefix=DYNSYM-NOTFOUND-GNUHASH

# DYNSYM-NOTFOUND-GNUHASH:      Symbol table of .gnu.hash for image:
# DYNSYM-NOTFOUND-GNUHASH-NEXT:  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
# DYNSYM-NOTFOUND-GNUHASH-NEXT: warning: '[[FILE]]': unable to print symbols for the .gnu.hash table: the dynamic symbol table was not found
# DYNSYM-NOTFOUND-GNUHASH-NOT:  {{.}}

--- !ELF
FileHeader:
  Class: ELFCLASS32
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:  .gnu.hash
    Type:  SHT_GNU_HASH
    Flags: [ SHF_ALLOC ]
    Header:
      SymNdx: 0x0
      Shift2: 0x0
    BloomFilter: [ 0x0 ]
    HashBuckets: [ 0x1 ]
    HashValues:  [ 0x0 ]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Flags: [ SHF_ALLOC ]
    Entries:
      - Tag:   DT_GNU_HASH
        Value: 0x0
      - Tag:   DT_STRTAB
## PT_LOAD p_offset == .hash offset == 0x54.
## 0x54 + 0x3c == 0x80 == .dynstr offset.
        Value: 0x3c
      - Tag:   DT_STRSZ
        Value: 0x1
      - Tag:   DT_NULL
        Value: 0x0
  - Name: .dynstr
    Type: SHT_STRTAB
  - Name:  .dynsym
    Type:  [[DYNSYMTYPE=SHT_DYNSYM]]
    Flags: [ SHF_ALLOC ]
    Size:  0
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_R, PF_X ]
    FirstSec: .gnu.hash
    LastSec:  .dynstr

## In this case we have a broken value in the hash buckets array. Normally it contains an
## index into the dynamic symbol table and also is used to get a hash value from the hash values array.
## llvm-readelf attempts to read a symbol that is past the end of the dynamic symbol table.

# RUN: yaml2obj --docnum=11 -DVALUE=0x2 %s -o %t11.past.dynsym.so
# RUN: llvm-readelf --hash-symbols %t11.past.dynsym.so 2>&1 | \
# RUN:   FileCheck %s -DFILE=%t11.past.dynsym.so --check-prefix=BUCKET-PAST-DYNSYM

# BUCKET-PAST-DYNSYM:      Symbol table of .gnu.hash for image:
# BUCKET-PAST-DYNSYM-NEXT:   Num Buc:    Value          Size   Type   Bind Vis      Ndx Name
# BUCKET-PAST-DYNSYM-NEXT: warning: '[[FILE]]': unable to print hashed symbol with index 2, which is greater than or equal to the number of dynamic symbols (2)
# BUCKET-PAST-DYNSYM-NEXT:     1   2: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT UND foo
# BUCKET-PAST-DYNSYM-NOT:  {{.}}

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Sections:
  - Name:  .gnu.hash
    Type:  SHT_GNU_HASH
    Flags: [ SHF_ALLOC ]
    Link:  .dynsym
    Header:
      SymNdx: [[SYMNDX=0x0]]
      Shift2: 0x0
    BloomFilter: [ 0x0 ]
    HashBuckets: [ 0x0, [[VALUE]], 0x1 ]
    HashValues:  [ 0x0 ]
  - Name:  .dynamic
    Type:  SHT_DYNAMIC
    Flags: [ SHF_ALLOC ]
    Link:  .dynstr
    Entries:
      - Tag:   DT_GNU_HASH
        Value: 0x0
      - Tag:   DT_NULL
        Value: 0x0
DynamicSymbols:
  - Name:    foo
    Binding: STB_GLOBAL
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_R, PF_X ]
    FirstSec: .gnu.hash
    LastSec:  .dynamic

## In this case we are unable to read a hash value for a symbol with
## an index that is less than the index of the first hashed symbol.

# RUN: yaml2obj --docnum=11 -DSYMNDX=0x2 -DVALUE=0x1 %s -o %t11.first.hashed.so
# RUN: llvm-readelf --hash-symbols %t11.first.hashed.so 2>&1 | \
# RUN:   FileCheck %s -DFILE=%t11.first.hashed.so --check-prefix=FIRST-HASHED

# FIRST-HASHED:      Symbol table of .gnu.hash for image:
# FIRST-HASHED-NEXT:   Num Buc:    Value          Size   Type   Bind Vis      Ndx Name
# FIRST-HASHED-NEXT: warning: '[[FILE]]': unable to get hash values for the SHT_GNU_HASH section: the first hashed symbol index (2) is greater than or equal to the number of dynamic symbols (2)
# FIRST-HASHED-NEXT:     1   1: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT UND foo
# FIRST-HASHED-NEXT: warning: '[[FILE]]': unable to read the hash value for symbol with index 1, which is less than the index of the first hashed symbol (2)
# FIRST-HASHED-NEXT:     1   2: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT UND foo
# FIRST-HASHED-NOT:  {{.}}

## In this case one of the chain values doesn't end with a stopper bit and llvm-readelf attempts to read
## a dynamic symbol with an index that is equal to the number of dynamic symbols.

# RUN: yaml2obj --docnum=11 -DSYMNDX=0x1 -DVALUE=0x1 %s -o %t11.chain.bit.so
# RUN: llvm-readelf --hash-symbols %t11.chain.bit.so 2>&1 | \
# RUN:   FileCheck %s -DFILE=%t11.chain.bit.so --check-prefix=CHAIN-BIT

# CHAIN-BIT:      Symbol table of .gnu.hash for image:
# CHAIN-BIT-NEXT:   Num Buc:    Value          Size   Type   Bind Vis      Ndx Name
# CHAIN-BIT-NEXT:     1   1: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT UND foo
# CHAIN-BIT-NEXT: warning: '[[FILE]]': unable to print hashed symbol with index 2, which is greater than or equal to the number of dynamic symbols (2)
# CHAIN-BIT-NEXT:     1   2: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT UND foo
# CHAIN-BIT-NOT:  {{.}}