## A user should be able to specify any arbitrary string table as the section
## header string table, including the symbol string table. This test covers
## various cases to do with this.

## Case 1: custom name specified for string table.
# RUN: yaml2obj --docnum=1 %s -o %t1 -DSHSTRTAB=.strings
# RUN: llvm-readelf -S -p .strings %t1 | FileCheck %s --check-prefix=CASE1

# CASE1:      There are 5 section headers
# CASE1-EMPTY:
# CASE1-NEXT: Section Headers:
# CASE1-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg  Lk Inf Al
# CASE1-NEXT:   [ 0]              NULL
# CASE1-NEXT:   [ 1] .foo{{ }}
# CASE1-NEXT:   [ 2] .bar{{ }}
# CASE1-NEXT:   [ 3] .strtab{{ }}
# CASE1-NEXT:   [ 4] .strings     STRTAB 0000000000000000 [[#%x,]] 00001c 00       0   0  1

# CASE1:      String dump of section '.strings':
# CASE1-NEXT: [     1] .strings{{$}}
# CASE1-NEXT: [     a] .bar{{$}}
# CASE1-NEXT: [     f] .foo{{$}}
# CASE1-NEXT: [    14] .strtab{{$}}
# CASE1-EMPTY:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
  SectionHeaderStringTable: [[SHSTRTAB=<none>]]
Sections:
  - Name: .foo
    Type: SHT_PROGBITS
  - Name: [[OTHER=.bar]]
    Type: SHT_PROGBITS

## Case 2: reuse symbol string table.
# RUN: yaml2obj --docnum=2 %s -o %t2 -DSHSTRTAB=.strtab
# RUN: llvm-readelf -S -s -p .strtab %t2 | FileCheck %s --check-prefix=CASE2

# CASE2: There are 5 section headers
# CASE2-EMPTY:
# CASE2-NEXT: Section Headers:
# CASE2-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg Lk Inf Al
# CASE2-NEXT:   [ 0]              NULL
# CASE2-NEXT:   [ 1] .foo{{ }}
# CASE2-NEXT:   [ 2] .bar{{ }}
# CASE2-NEXT:   [ 3] .symtab{{ }}
# CASE2-NEXT:   [ 4] .strtab      STRTAB 0000000000000000 [[#%x,]] 000023 00      0   0  1

# CASE2:      Symbol table '.symtab' contains 3 entries:
# CASE2-NEXT:    Num: {{.*}} Ndx Name
# CASE2-NEXT:      0: {{.*}} UND {{$}}
# CASE2-NEXT:      1: {{.*}}     baz{{$}}
# CASE2-NEXT:      2: {{.*}}     bob{{$}}

# CASE2:      String dump of section '.strtab':
# CASE2-NEXT: [     1] baz{{$}}
# CASE2-NEXT: [     5] .bar{{$}}
# CASE2-NEXT: [     a] .foo{{$}}
# CASE2-NEXT: [     f] bob{{$}}
# CASE2-NEXT: [    13] .strtab{{$}}
# CASE2-NEXT: [    1b] .symtab{{$}}
# CASE2-EMPTY:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
  SectionHeaderStringTable: [[SHSTRTAB]]
Sections:
  - Name: .foo
    Type: SHT_PROGBITS
  - Name: .bar
    Type: SHT_PROGBITS
Symbols:
  - Name: baz
  - Name: bob

## Case 3: reuse dynamic string table.
# RUN: yaml2obj --docnum=3 %s -o %t3 -DSHSTRTAB=.dynstr
# RUN: llvm-readelf -S --dyn-syms -p .dynstr %t3 | FileCheck %s --check-prefix=CASE3

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
  SectionHeaderStringTable: [[SHSTRTAB]]
Sections:
  - Name: .foo
    Type: SHT_PROGBITS
  - Name: .bar
    Type: SHT_PROGBITS
DynamicSymbols:
  - Name: baz
  - Name: bob

# CASE3:      There are 6 section headers
# CASE3-EMPTY:
# CASE3-NEXT: Section Headers:
# CASE3-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg Lk Inf Al
# CASE3-NEXT:   [ 0]              NULL
# CASE3-NEXT:   [ 1] .foo{{ }}
# CASE3-NEXT:   [ 2] .bar{{ }}
# CASE3-NEXT:   [ 3] .dynsym{{ }}
# CASE3-NEXT:   [ 4] .dynstr      STRTAB 0000000000000048 [[#%x,]] 00002b 00   A  0   0  1
# CASE3-NEXT:   [ 5] .strtab{{ }}

# CASE3:      Symbol table '.dynsym' contains 3 entries:
# CASE3-NEXT:    Num: {{.*}} Ndx Name
# CASE3-NEXT:      0: {{.*}} UND {{$}}
# CASE3-NEXT:      1: {{.*}}     baz{{$}}
# CASE3-NEXT:      2: {{.*}}     bob{{$}}

# CASE3:      String dump of section '.dynstr':
# CASE3-NEXT: [     1] baz{{$}}
# CASE3-NEXT: [     5] .dynstr{{$}}
# CASE3-NEXT: [     d] .bar{{$}}
# CASE3-NEXT: [    12] .foo{{$}}
# CASE3-NEXT: [    17] .dynsym{{$}}
# CASE3-NEXT: [    1f] bob{{$}}
# CASE3-NEXT: [    23] .strtab{{$}}
# CASE3-EMPTY:

## Case 4: shstrtab specified to be otherwise ungenerated non-strtab implicit
##         section.
# RUN: yaml2obj --docnum=1 %s -o %t4 -DSHSTRTAB=.symtab
# RUN: llvm-readelf -S -p .symtab %t4 | FileCheck %s --check-prefix=CASE4

# CASE4:      There are 5 section headers
# CASE4-EMPTY:
# CASE4-NEXT: Section Headers:
# CASE4-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg Lk Inf Al
# CASE4-NEXT:   [ 0]              NULL
# CASE4-NEXT:   [ 1] .foo{{ }}
# CASE4-NEXT:   [ 2] .bar{{ }}
# CASE4-NEXT:   [ 3] .strtab{{ }}
# CASE4-NEXT:   [ 4] .symtab      STRTAB 0000000000000000 [[#%x,]] 00001b 00      0   0  1

# CASE4:      String dump of section '.symtab':
# CASE4-NEXT: [     1] .bar{{$}}
# CASE4-NEXT: [     6] .foo{{$}}
# CASE4-NEXT: [     b] .strtab{{$}}
# CASE4-NEXT: [    13] .symtab{{$}}

## Case 5: shstrtab specified to be otherwise ungenerated .dynstr section. In
##         this case, the SHF_ALLOC flag will be set.
# RUN: yaml2obj --docnum=1 %s -o %t5 -DSHSTRTAB=.dynstr
# RUN: llvm-readelf -S -p .dynstr %t5 | FileCheck %s --check-prefix=CASE5

# CASE5:      There are 5 section headers
# CASE5-EMPTY:
# CASE5-NEXT: Section Headers:
# CASE5-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg Lk Inf Al
# CASE5-NEXT:   [ 0]              NULL
# CASE5-NEXT:   [ 1] .foo{{ }}
# CASE5-NEXT:   [ 2] .bar{{ }}
# CASE5-NEXT:   [ 3] .strtab{{ }}
# CASE5-NEXT:   [ 4] .dynstr      STRTAB 0000000000000001 [[#%x,]] 00001b 00   A  0   0  1

# CASE5:      String dump of section '.dynstr':
# CASE5-NEXT: [     1] .dynstr{{$}}
# CASE5-NEXT: [     9] .bar{{$}}
# CASE5-NEXT: [     e] .foo{{$}}
# CASE5-NEXT: [    13] .strtab{{$}}

## Case 6: shstrtab specified to be otherwise ungenerated .debug_str section. In
##         this case, the sh_entsize will be set to 1.
# RUN: yaml2obj --docnum=1 %s -o %t6 -DSHSTRTAB=.debug_str
# RUN: llvm-readelf -S -p .debug_str %t6 | FileCheck %s --check-prefix=CASE6

# CASE6:      There are 5 section headers
# CASE6-EMPTY:
# CASE6-NEXT: Section Headers:
# CASE6-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg Lk Inf Al
# CASE6-NEXT:   [ 0]              NULL
# CASE6-NEXT:   [ 1] .foo{{ }}
# CASE6-NEXT:   [ 2] .bar{{ }}
# CASE6-NEXT:   [ 3] .strtab{{ }}
# CASE6-NEXT:   [ 4] .debug_str   STRTAB 0000000000000000 [[#%x,]] 00001e 01      0   0  1

# CASE6:      String dump of section '.debug_str':
# CASE6-NEXT: [     1] .debug_str{{$}}
# CASE6-NEXT: [     c] .bar{{$}}
# CASE6-NEXT: [    11] .foo{{$}}
# CASE6-NEXT: [    16] .strtab{{$}}

## Case 7: shstrtab specified to be the .symtab section, when there are symbols.
## This triggers an error (since the symbols cannot be represented in the
## section as section names).
# RUN: not yaml2obj --docnum=2 %s -o %t7 -DSHSTRTAB=.symtab 2>&1 | FileCheck %s --check-prefix=ERR1

# ERR1: error: cannot use '.symtab' as the section header name table when there are symbols

## Case 8: shstrtab specified to be the .dynsym section, when there are dynamic
## symbols. This triggers an error (since the symbols cannot be represented in
## the section as section names).
# RUN: not yaml2obj --docnum=3 %s -o %t8 -DSHSTRTAB=.dynsym 2>&1 | FileCheck %s --check-prefix=ERR2

# ERR2: error: cannot use '.dynsym' as the section header name table when there are dynamic symbols

## Case 9: shstrtab specified to be the .debug_str section, when there are DWARF
## debug strings. This triggers an error.
# RUN: not yaml2obj --docnum=4 %s -o %t9 2>&1 | FileCheck %s --check-prefix=ERR3

# ERR3: error: cannot use '.debug_str' as the section header name table when it is needed for DWARF output

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
  SectionHeaderStringTable: .debug_str
DWARF:
  debug_str:
    - a

## Case 10: can explicitly specifiy ".shstrtab" as shstrtab. Output will be the
##         same as if it wasn't sepcified at all.
# RUN: yaml2obj --docnum=1 %s -o %t10 -DSHSTRTAB=.shstrtab
# RUN: llvm-readelf -S -p .shstrtab %t10 | FileCheck %s --check-prefix=CASE10
# RUN: yaml2obj --docnum=1 %s -o %t10.default
# RUN: cmp %t10 %t10.default

# CASE10:      There are 5 section headers
# CASE10-EMPTY:
# CASE10-NEXT: Section Headers:
# CASE10-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg  Lk Inf Al
# CASE10-NEXT:   [ 0]              NULL
# CASE10-NEXT:   [ 1] .foo{{ }}
# CASE10-NEXT:   [ 2] .bar{{ }}
# CASE10-NEXT:   [ 3] .strtab{{ }}
# CASE10-NEXT:   [ 4] .shstrtab    STRTAB 0000000000000000 [[#%x,]] 00001d 00       0   0  1

# CASE10:      String dump of section '.shstrtab':
# CASE10-NEXT: [     1] .bar{{$}}
# CASE10-NEXT: [     6] .foo{{$}}
# CASE10-NEXT: [     b] .shstrtab{{$}}
# CASE10-NEXT: [    15] .strtab{{$}}
# CASE10-EMPTY:

## Case 11: can specify custom shstrtab properties.
## FIXME: when the section is listed explicitly, the sh_addralign value is 0 if
##        not overwritten, which is inconsistent with when the section is not
##        specified at all.
# RUN: yaml2obj --docnum=5 %s -o %t11 -DENTSIZE=2
# RUN: llvm-readelf -S -p .strings %t11 | FileCheck %s --check-prefix=CASE11

# CASE11:      There are 5 section headers
# CASE11-EMPTY:
# CASE11-NEXT: Section Headers:
# CASE11-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg  Lk Inf Al
# CASE11-NEXT:   [ 0]              NULL
# CASE11-NEXT:   [ 1] .foo{{ }}
# CASE11-NEXT:   [ 2] .strings     STRTAB 0000000000000000 [[#%x,]] 00001c 02       0   0  0
# CASE11-NEXT:   [ 3] .bar{{ }}
# CASE11-NEXT:   [ 4] .strtab{{ }}

# CASE11:      String dump of section '.strings':
# CASE11-NEXT: [     1] .strings{{$}}
# CASE11-NEXT: [     a] .bar{{$}}
# CASE11-NEXT: [     f] .foo{{$}}
# CASE11-NEXT: [    14] .strtab{{$}}
# CASE11-EMPTY:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
  SectionHeaderStringTable: .strings
Sections:
  - Name:         .foo
    Type:         SHT_PROGBITS
  - Name:         .strings
    Type:         [[TYPE=SHT_STRTAB]]
    EntSize:      [[ENTSIZE=<none>]]
    Size:         [[SIZE=<none>]]
    Content:      [[CONTENT=<none>]]
  - Name:         .bar
    Type:         SHT_PROGBITS

## Case 12: shstrtab does not have SHT_STRTAB type. Default properties will be
##          derived from the specified section type.
# RUN: yaml2obj --docnum=5 %s -o %t12 -DTYPE=SHT_RELA
# RUN: llvm-readelf -S %t12 | FileCheck %s --check-prefix=CASE12

# CASE12:      There are 5 section headers
# CASE12-EMPTY:
# CASE12-NEXT: Section Headers:
# CASE12-NEXT:   [Nr] Name         Type Address          Off      Size   ES Flg  Lk Inf Al
# CASE12-NEXT:   [ 0]              NULL
# CASE12-NEXT:   [ 1] .foo{{ }}
# CASE12-NEXT:   [ 2] .strings     RELA 0000000000000000 [[#%x,]] 00001c 18       0   0  0
# CASE12-NEXT:   [ 3] .bar{{ }}
# CASE12-NEXT:   [ 4] .strtab{{ }}

## Case 13: shstrtab has specified Content. The specified content overrides the
##          implicitly generated content.
# RUN: yaml2obj --docnum=5 %s -o %t13 -DCONTENT="00616263646566676800696a6b6c006d6e6f70007172737475767700787a7b7c00"
# RUN: llvm-readelf -S %t13 | FileCheck %s --check-prefix=CASE13

# CASE13:      There are 5 section headers
# CASE13-EMPTY:
# CASE13-NEXT: Section Headers:
# CASE13-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg  Lk Inf Al
# CASE13-NEXT:   [ 0]              NULL
# CASE13-NEXT:   [ 1] mnop{{ }}
# CASE13-NEXT:   [ 2] abcdefgh     STRTAB 0000000000000000 [[#%x,]] 000021 00       0   0  0
# CASE13-NEXT:   [ 3] ijkl{{ }}
# CASE13-NEXT:   [ 4] qrstuvw{{ }}

## Case 14: shstrtab has specified Size. The section will be filled with zeros
##          to the requested size.
# RUN: yaml2obj --docnum=5 %s -o %t14 -DSIZE=32
# RUN: llvm-readelf -S -p 2 %t14 | FileCheck %s --check-prefix=CASE14

# CASE14:      There are 5 section headers
# CASE14-EMPTY:
# CASE14-NEXT: Section Headers:
# CASE14-NEXT:   [Nr] Name Type     Address          Off      Size   ES Flg  Lk Inf Al
# CASE14-NEXT:   [ 0]      NULL
# CASE14-NEXT:   [ 1]      PROGBITS
# CASE14-NEXT:   [ 2]      STRTAB   0000000000000000 [[#%x,]] 000020 00       0   0  0
# CASE14-NEXT:   [ 3]      PROGBITS
# CASE14-NEXT:   [ 4]      STRTAB

# CASE14:      String dump of section '':
# CASE14-EMPTY:

## Case 15: custom shstrtab and no section header table. The section header
##          names shouldn't appear anywhere in the output file.
# RUN: yaml2obj --docnum=6 %s -o %t15
# RUN: FileCheck %s --input-file=%t15 \
# RUN:   --implicit-check-not=.strings --implicit-check-not=.foo \
# RUN:   --implicit-check-not=.bar

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
  SectionHeaderStringTable: .strings
Sections:
  - Name:      .foo
    Type:      SHT_PROGBITS
  - Name:      .bar
    Type:      SHT_PROGBITS
  - Type:      SectionHeaderTable
    NoHeaders: true

## Case 16: custom shstrtab can be reordered in the section header table.
# RUN: yaml2obj --docnum=7 %s -o %t16
# RUN: llvm-readelf -S %t16 | FileCheck %s --check-prefix=CASE16

# CASE16:      There are 5 section headers
# CASE16-EMPTY:
# CASE16-NEXT: Section Headers:
# CASE16-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg  Lk Inf Al
# CASE16-NEXT:   [ 0]              NULL
# CASE16-NEXT:   [ 1] .foo{{ }}
# CASE16-NEXT:   [ 2] .strings     STRTAB 0000000000000000 [[#%x,]] 00001c 00       0   0  1
# CASE16-NEXT:   [ 3] .bar{{ }}
# CASE16-NEXT:   [ 4] .strtab{{ }}

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
  SectionHeaderStringTable: .strings
Sections:
  - Name:      .foo
    Type:      SHT_PROGBITS
  - Name:      .bar
    Type:      SHT_PROGBITS
  - Type:      SectionHeaderTable
    Sections:
      - Name: .foo
      - Name: .strings
      - Name: .bar
      - Name: .strtab

## Case 17: custom shstrtab section header can be excluded.
# RUN: yaml2obj --docnum=8 %s -o %t17
# RUN: llvm-readelf -h -S %t17 | FileCheck %s --check-prefix=CASE17

# CASE17:      Section header string table index: 0
# CASE17:      There are 4 section headers
# CASE17-EMPTY:
# CASE17-NEXT: Section Headers:
# CASE17-NEXT:   [Nr] Name         Type
# CASE17-NEXT:   [ 0] <no-strings> NULL
# CASE17-NEXT:   [ 1] <no-strings> PROGBITS
# CASE17-NEXT:   [ 2] <no-strings> PROGBITS
# CASE17-NEXT:   [ 3] <no-strings> STRTAB

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
  SectionHeaderStringTable: .strings
Sections:
  - Name:      .foo
    Type:      SHT_PROGBITS
  - Name:      .bar
    Type:      SHT_PROGBITS
  - Type:      SectionHeaderTable
    Sections:
      - Name: .foo
      - Name: .bar
      - Name: .strtab
    Excluded:
      - Name: .strings

## Case 18: section name for excluded section does not appear in custom
##          shstrtab.
# RUN: yaml2obj --docnum=9 %s -o %t18
# RUN: llvm-readelf -S -p .strings %t18 | FileCheck %s --check-prefix=CASE18

# CASE18:      There are 4 section headers
# CASE18-EMPTY:
# CASE18-NEXT: Section Headers:
# CASE18-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg  Lk Inf Al
# CASE18-NEXT:   [ 0]              NULL
# CASE18-NEXT:   [ 1] .foo{{ }}
# CASE18-NEXT:   [ 2] .strings     STRTAB 0000000000000000 [[#%x,]] 000017 00       0   0  1
# CASE18-NEXT:   [ 3] .strtab{{ }}

# CASE18:      String dump of section '.strings':
# CASE18-NEXT: [     1] .strings
# CASE18-NEXT: [     a] .foo
# CASE18-NEXT: [     f] .strtab
# CASE18-EMPTY:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
  SectionHeaderStringTable: .strings
Sections:
  - Name:      .foo
    Type:      SHT_PROGBITS
  - Name:      .bar
    Type:      SHT_PROGBITS
  - Type:      SectionHeaderTable
    Sections:
      - Name: .foo
      - Name: .strings
      - Name: .strtab
    Excluded:
      - Name: .bar

## Case 19: custom shstrtab can have a uniqued name.
# RUN: yaml2obj --docnum=1 %s -o %t19 '-DSHSTRTAB=.strings (1)' '-DOTHER=.strings (0)'
# RUN: llvm-readelf -S -p 4 %t19 | FileCheck %s --check-prefix=CASE19

# CASE19:      There are 5 section headers
# CASE19-EMPTY:
# CASE19-NEXT: Section Headers:
# CASE19-NEXT:   [Nr] Name         Type     Address          Off      Size   ES Flg  Lk Inf Al
# CASE19-NEXT:   [ 0]              NULL
# CASE19-NEXT:   [ 1] .foo{{ }}
# CASE19-NEXT:   [ 2] .strings     PROGBITS
# CASE19-NEXT:   [ 3] .strtab{{ }}
# CASE19-NEXT:   [ 4] .strings     STRTAB   0000000000000000 [[#%x,]] 000017 00       0   0  1

# CASE19:      String dump of section '.strings':
# CASE19-NEXT: [     1] .strings{{$}}
# CASE19-NEXT: [     a] .foo{{$}}
# CASE19-NEXT: [     f] .strtab{{$}}
# CASE19-EMPTY:

## Case 20: custom shstrtab named ".strtab" with uniquifying ID.
# RUN: yaml2obj --docnum=2 %s -o %t20 '-DSHSTRTAB=.strtab (1)'
# RUN: llvm-readelf -S -s -p 4 -p 5 %t20 | FileCheck %s --check-prefix=CASE20

# CASE20: There are 6 section headers
# CASE20-EMPTY:
# CASE20-NEXT: Section Headers:
# CASE20-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg Lk Inf Al
# CASE20-NEXT:   [ 0]              NULL
# CASE20-NEXT:   [ 1] .foo{{ }}
# CASE20-NEXT:   [ 2] .bar{{ }}
# CASE20-NEXT:   [ 3] .symtab{{ }}
# CASE20-NEXT:   [ 4] .strtab      STRTAB [[#%x,]]         [[#%x,]] 000009 00      0   0  1
# CASE20-NEXT:   [ 5] .strtab      STRTAB 0000000000000000 [[#%x,]] 00001b 00      0   0  1

# CASE20:      Symbol table '.symtab' contains 3 entries:
# CASE20-NEXT:    Num: {{.*}} Ndx Name
# CASE20-NEXT:      0: {{.*}} UND {{$}}
# CASE20-NEXT:      1: {{.*}}     baz{{$}}
# CASE20-NEXT:      2: {{.*}}     bob{{$}}

# CASE20:      String dump of section '.strtab':
# CASE20-NEXT: [     1] baz
# CASE20-NEXT: [     5] bob
# CASE20-EMPTY:

# CASE20:      String dump of section '.strtab':
# CASE20-NEXT: [     1] .bar{{$}}
# CASE20-NEXT: [     6] .foo{{$}}
# CASE20-NEXT: [     b] .strtab{{$}}
# CASE20-NEXT: [    13] .symtab{{$}}
# CASE20-EMPTY:

## Case 21: custom shstrtab named ".dynstr" with uniquifying ID.
# RUN: yaml2obj --docnum=3 %s -o %t21 '-DSHSTRTAB=.dynstr (1)'
# RUN: llvm-readelf -S --dyn-syms -p 4 -p 6 %t21 | FileCheck %s --check-prefix=CASE21

# CASE21: There are 7 section headers
# CASE21-EMPTY:
# CASE21-NEXT: Section Headers:
# CASE21-NEXT:   [Nr] Name         Type   Address          Off      Size   ES Flg Lk Inf Al
# CASE21-NEXT:   [ 0]              NULL
# CASE21-NEXT:   [ 1] .foo{{ }}
# CASE21-NEXT:   [ 2] .bar{{ }}
# CASE21-NEXT:   [ 3] .dynsym{{ }}
# CASE21-NEXT:   [ 4] .dynstr      STRTAB [[#%x,]]         [[#%x,]] 000009 00   A  0   0  1
# CASE21-NEXT:   [ 5] .strtab{{ }}
# CASE21-NEXT:   [ 6] .dynstr      STRTAB 0000000000000000 [[#%x,]] 000023 00      0   0  1

# CASE21:      Symbol table '.dynsym' contains 3 entries:
# CASE21-NEXT:    Num: {{.*}} Ndx Name
# CASE21-NEXT:      0: {{.*}} UND {{$}}
# CASE21-NEXT:      1: {{.*}}     baz{{$}}
# CASE21-NEXT:      2: {{.*}}     bob{{$}}

# CASE21:      String dump of section '.dynstr':
# CASE21-NEXT: [     1] baz
# CASE21-NEXT: [     5] bob
# CASE21-EMPTY:

# CASE21:      String dump of section '.dynstr':
# CASE21-NEXT: [     1] .dynstr{{$}}
# CASE21-NEXT: [     9] .bar{{$}}
# CASE21-NEXT: [     e] .foo{{$}}
# CASE21-NEXT: [    13] .dynsym{{$}}
# CASE21-NEXT: [    1b] .strtab{{$}}
# CASE21-EMPTY: