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

   1 ## Check that we correctly display the contents of the .stack_sizes section
   2 ## in a relocatable object file.
   3
   4 # RUN: yaml2obj --docnum=1 %s > %t01
   5 # RUN: llvm-readelf --stack-sizes %t01 \
   6 # RUN:   | FileCheck %s --check-prefix=RELOC-GNU --strict-whitespace --match-full-lines
   7 # RUN: llvm-readobj --stack-sizes %t01 | FileCheck %s --check-prefix=RELOC-LLVM
   8
   9 #      RELOC-GNU:         Size     Function
  10 # RELOC-GNU-NEXT:           16     referenced_by_symbol_foo
  11 # RELOC-GNU-NEXT:           32     referenced_via_section_bar
  12 # RELOC-GNU-NEXT:            8     separate_text_section_baz
  13 #  RELOC-GNU-NOT:{{.}}
  14
  15 # RELOC-LLVM:      StackSizes [
  16 # RELOC-LLVM-NEXT:   Entry {
  17 # RELOC-LLVM-NEXT:     Function: referenced_by_symbol_foo
  18 # RELOC-LLVM-NEXT:     Size: 0x10
  19 # RELOC-LLVM-NEXT:   }
  20 # RELOC-LLVM-NEXT:   Entry {
  21 # RELOC-LLVM-NEXT:     Function: referenced_via_section_bar
  22 # RELOC-LLVM-NEXT:     Size: 0x20
  23 # RELOC-LLVM-NEXT:   }
  24 # RELOC-LLVM-NEXT:   Entry {
  25 # RELOC-LLVM-NEXT:     Function: separate_text_section_baz
  26 # RELOC-LLVM-NEXT:     Size: 0x8
  27 # RELOC-LLVM-NEXT:   }
  28 # RELOC-LLVM-NEXT: ]
  29
  30 --- !ELF
  31 FileHeader:
  32   Class:   ELFCLASS64
  33   Data:    ELFDATA2LSB
  34   Type:    ET_REL
  35   Machine: EM_X86_64
  36 Sections:
  37   - Name:    .text
  38     Type:    SHT_PROGBITS
  39     Flags:   [SHF_ALLOC]
  40     Size:    16
  41   - Name:    .text.baz
  42     Type:    SHT_PROGBITS
  43     Flags:   [SHF_ALLOC]
  44     Size:    16
  45   - Name:    .stack_sizes
  46     Type:    SHT_PROGBITS
  47 ## 2 stack size entries. Each consists of an address (subject to relocation)
  48 ## followed by a ULEB for the size.
  49     Content: "000000000000000010000000000000000020"
  50     Link:    .text
  51   - Name:    '.stack_sizes [1]'
  52     Type:    SHT_PROGBITS
  53 ## One stack size entry.
  54     Content: "200000000000000008"
  55     Link:    .text.baz
  56   - Name:    .rela.stack_sizes
  57     Type:    SHT_RELA
  58     Info:    .stack_sizes
  59     Relocations:
  60 ## A symbol relative reference.
  61       - Offset: 0
  62         Symbol: referenced_by_symbol_foo
  63         Type:   R_X86_64_64
  64 ## A section relative reference.
  65       - Offset: 9
  66         Addend: 16
  67         Symbol: .text
  68         Type:   R_X86_64_64
  69   - Name:   '.rela.stack_sizes [1]'
  70     Type:   SHT_RELA
  71     Info:   '.stack_sizes [1]'
  72     Relocations:
  73       - Offset: 0
  74         Symbol: separate_text_section_baz
  75         Type:   R_X86_64_64
  76 Symbols:
  77   - Name:    separate_text_section_baz
  78     Section: .text.baz
  79     Type:    STT_FUNC
  80   - Name:    .text
  81     Section: .text
  82     Type:    STT_SECTION
  83   - Name:    referenced_by_symbol_foo
  84     Section: .text
  85     Type:    STT_FUNC
  86     Binding: STB_GLOBAL
  87   - Name:    referenced_via_section_bar
  88     Section: .text
  89     Value:   0x10
  90     Type:    STT_FUNC
  91     Binding: STB_GLOBAL
  92
  93 ## Check that we correctly report the stack sizes in an executable (non-relocatable)
  94 ## object file.
  95
  96 # RUN: yaml2obj --docnum=2 %s > %t02
  97 # RUN: llvm-readelf --stack-sizes %t02 \
  98 # RUN:   | FileCheck %s --check-prefix=EXEC-GNU --strict-whitespace --match-full-lines
  99 # RUN: llvm-readobj --stack-sizes %t02 | FileCheck %s --check-prefix=EXEC-LLVM
 100
 101 #      EXEC-GNU:         Size     Function
 102 # EXEC-GNU-NEXT:           16     foo
 103 # EXEC-GNU-NEXT:           32     bar
 104 #  EXEC-GNU-NOT:{{.}}
 105
 106 # EXEC-LLVM:      StackSizes [
 107 # EXEC-LLVM-NEXT:   Entry {
 108 # EXEC-LLVM-NEXT:     Function: foo
 109 # EXEC-LLVM-NEXT:     Size: 0x10
 110 # EXEC-LLVM-NEXT:   }
 111 # EXEC-LLVM-NEXT:   Entry {
 112 # EXEC-LLVM-NEXT:     Function: bar
 113 # EXEC-LLVM-NEXT:     Size: 0x20
 114 # EXEC-LLVM-NEXT:   }
 115 # EXEC-LLVM-NEXT: ]
 116
 117 --- !ELF
 118 FileHeader:
 119   Class:   ELFCLASS64
 120   Data:    ELFDATA2LSB
 121   Type:    ET_EXEC
 122   Machine: EM_X86_64
 123 Sections:
 124   - Name:    .text
 125     Type:    SHT_PROGBITS
 126     Flags:   [SHF_ALLOC]
 127     Size:    16
 128   - Name:    .stack_sizes
 129     Type:    SHT_PROGBITS
 130     Content: "100000000000000010200000000000000020"
 131     Link:    .text
 132 Symbols:
 133   - Name:    foo
 134     Section: .text
 135     Value:   0x10
 136     Type:    STT_FUNC
 137     Binding: STB_GLOBAL
 138   - Name:    bar
 139     Section: .text
 140     Value:   0x20
 141     Type:    STT_FUNC
 142     Binding: STB_GLOBAL
 143
 144 ## Check that we report an error when we find relocations whose offsets point outside
 145 ## of the .stack_sizes section.
 146
 147 # RUN: yaml2obj --docnum=3 %s > %t03
 148 # RUN: not llvm-readelf --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT -DFILE=%t03
 149 # RUN: not llvm-readobj --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT -DFILE=%t03
 150
 151 # SHORT: error: '[[FILE]]': found invalid relocation offset into section .stack_sizes while trying to extract a stack size entry
 152
 153 --- !ELF
 154 FileHeader:
 155   Class:   ELFCLASS64
 156   Data:    ELFDATA2LSB
 157   Type:    ET_REL
 158   Machine: EM_X86_64
 159 Sections:
 160   - Name:    .text
 161     Type:    SHT_PROGBITS
 162     Flags:   [SHF_ALLOC]
 163     Size:    16
 164   - Name:    .stack_sizes
 165     Type:    SHT_PROGBITS
 166     Size:    1
 167     Link:    .text
 168   - Name:    .rela.stack_sizes
 169     Type:    SHT_RELA
 170     Info:    .stack_sizes
 171     Relocations:
 172       - Offset: 1
 173         Symbol: foo
 174         Type:   R_X86_64_64
 175 Symbols:
 176   - Name:    foo
 177     Section: .text
 178     Type:    STT_FUNC
 179     Binding: STB_GLOBAL
 180
 181 ## Check that we warn about a function symbol that is not in the section
 182 ## that is referenced by the stack sizes section's sh_link.
 183
 184 # RUN: yaml2obj --docnum=4 %s > %t04
 185 # RUN: llvm-readelf --stack-sizes %t04 2> %t04-gnu.err | FileCheck %s --check-prefix=WRONGSECTION-GNU
 186 # RUN: FileCheck %s < %t04-gnu.err --check-prefix=WRONGSECTION-ERR -DFILE=%t04
 187 # RUN: llvm-readobj --stack-sizes %t04 2> %t04-llvm.err | FileCheck %s --check-prefix=WRONGSECTION-LLVM
 188 # RUN: FileCheck %s < %t04-llvm.err --check-prefix=WRONGSECTION-ERR -DFILE=%t04
 189
 190 # WRONGSECTION-GNU:      Size Function
 191 # WRONGSECTION-GNU-NEXT: 8 foo
 192
 193 # WRONGSECTION-LLVM:      StackSizes [
 194 # WRONGSECTION-LLVM-NEXT:   Entry {
 195 # WRONGSECTION-LLVM-NEXT:     Function: foo
 196 # WRONGSECTION-LLVM-NEXT:     Size: 0x8
 197 # WRONGSECTION-LLVM-NEXT:   }
 198 # WRONGSECTION-LLVM-NEXT: ]
 199
 200 # WRONGSECTION-ERR:  warning: '[[FILE]]': relocation symbol foo is not in the expected section
 201
 202 --- !ELF
 203 FileHeader:
 204   Class:   ELFCLASS64
 205   Data:    ELFDATA2LSB
 206   Type:    ET_REL
 207   Machine: EM_X86_64
 208 Sections:
 209   - Name:    .text
 210     Type:    SHT_PROGBITS
 211     Size:    8
 212   - Name:    .text2
 213     Type:    SHT_PROGBITS
 214     Size:    8
 215     Flags:   [SHF_ALLOC]
 216   - Name:    .stack_sizes
 217     Type:    SHT_PROGBITS
 218     Content: "000000000000000008"
 219     Link:    .text2
 220   - Name:    .rela.stack_sizes
 221     Type:    SHT_RELA
 222     Info:    .stack_sizes
 223     Relocations:
 224       - Offset: 0
 225         Symbol: foo
 226         Type:   R_X86_64_64
 227 Symbols:
 228   - Name:    foo
 229     Section: .text
 230     Type:    STT_FUNC
 231     Binding: STB_GLOBAL
 232
 233 ## Check that we report an error when a stack sizes section ends with an incomplete stack size entry.
 234
 235 # RUN: yaml2obj --docnum=5 %s > %t05
 236 # RUN: not llvm-readelf --stack-sizes %t05 2>&1 | \
 237 # RUN:    FileCheck %s --check-prefix=SUDDENEND -DFILE=%t05
 238 # RUN: not llvm-readobj --stack-sizes %t05 2>&1 | \
 239 # RUN:    FileCheck %s --check-prefix=SUDDENEND -DFILE=%t05
 240
 241 # SUDDENEND: error: '[[FILE]]': section .stack_sizes ended while trying to extract a stack size entry
 242
 243 --- !ELF
 244 FileHeader:
 245   Class:   ELFCLASS64
 246   Data:    ELFDATA2LSB
 247   Type:    ET_EXEC
 248   Machine: EM_X86_64
 249 Sections:
 250   - Name:    .text
 251     Type:    SHT_PROGBITS
 252     Flags:   [SHF_ALLOC]
 253     Size:    16
 254   - Name:    .stack_sizes
 255     Type:    SHT_PROGBITS
 256     Content: "10000000"
 257     Link:    .text
 258 Symbols:
 259   - Name:    foo
 260     Section: .text
 261     Value:   0x10
 262     Type:    STT_FUNC
 263     Binding: STB_GLOBAL
 264
 265 ## Check that we report an invalid stack size, which is represented by a ULEB that
 266 ## ends in a byte with the high bit set.
 267
 268 # RUN: yaml2obj --docnum=6 %s > %t06
 269 # RUN: not llvm-readelf --stack-sizes %t06 2>&1 | FileCheck %s --check-prefix=BADSIZE -DFILE=%t06
 270 # RUN: not llvm-readobj --stack-sizes %t06 2>&1 | FileCheck %s --check-prefix=BADSIZE -DFILE=%t06
 271
 272 # BADSIZE: error: '[[FILE]]': could not extract a valid stack size in section .stack_sizes
 273
 274 --- !ELF
 275 FileHeader:
 276   Class:   ELFCLASS64
 277   Data:    ELFDATA2LSB
 278   Type:    ET_EXEC
 279   Machine: EM_X86_64
 280 Sections:
 281   - Name:    .text
 282     Type:    SHT_PROGBITS
 283     Flags:   [SHF_ALLOC]
 284     Size:    16
 285   - Name:    .stack_sizes
 286     Type:    SHT_PROGBITS
 287     Content: "100000000000000080"
 288     Link:    .text
 289 Symbols:
 290   - Name:    foo
 291     Section: .text
 292     Value:   0x10
 293     Type:    STT_FUNC
 294     Binding: STB_GLOBAL
 295
 296 ## Check that we report a warning when a relocation symbol does not belong to a
 297 ## valid section. We expect a stack size entry with an unknown symbol in the
 298 ## output.
 299
 300 # RUN: yaml2obj --docnum=7 %s > %t07
 301 # RUN: llvm-readelf --stack-sizes %t07 2> %t07-gnu.err | FileCheck %s --check-prefix=BADSECTION-OUT-GNU
 302 # RUN: FileCheck %s < %t07-gnu.err --check-prefix=BADSECTION-ERR -DFILE=%t07
 303 # RUN: llvm-readobj --stack-sizes %t07 2> %t07-llvm.err | FileCheck %s --check-prefix=BADSECTION-OUT-LLVM
 304 # RUN: FileCheck %s < %t07-llvm.err --check-prefix=BADSECTION-ERR -DFILE=%t07
 305
 306 # BADSECTION-OUT-GNU: Size Function
 307 # BADSECTION-OUT-GNU:    8 ?
 308
 309 # BADSECTION-OUT-LLVM:      StackSizes [
 310 # BADSECTION-OUT-LLVM-NEXT:   Entry {
 311 # BADSECTION-OUT-LLVM-NEXT:     Function: ?
 312 # BADSECTION-OUT-LLVM-NEXT:     Size: 0x8
 313 # BADSECTION-OUT-LLVM-NEXT:   }
 314 # BADSECTION-OUT-LLVM-NEXT: ]
 315
 316 # BADSECTION-ERR: warning: '[[FILE]]': cannot identify the section for relocation symbol foo
 317
 318 --- !ELF
 319 FileHeader:
 320   Class:   ELFCLASS64
 321   Data:    ELFDATA2LSB
 322   Type:    ET_REL
 323   Machine: EM_X86_64
 324 Sections:
 325   - Name:    .text
 326     Type:    SHT_PROGBITS
 327     Size:    8
 328   - Name:    .stack_sizes
 329     Type:    SHT_PROGBITS
 330     Link:    .text
 331     Content: "000000000000000008"
 332   - Name:    .rela.stack_sizes
 333     Type:    SHT_RELA
 334     Info:    .stack_sizes
 335     Relocations:
 336     - Offset: 0
 337       Symbol: foo
 338       Type:   R_X86_64_64
 339 Symbols:
 340   - Name:    foo
 341 ## An invalid section index.
 342     Index:   10
 343     Type:    STT_FUNC
 344     Binding: STB_GLOBAL
 345
 346 ## Check that we report a warning when a stack sizes section does not come with
 347 ## a corresponding relocation section.
 348
 349 # RUN: yaml2obj --docnum=8 %s > %t08
 350 # RUN: llvm-readelf --stack-sizes %t08 2> %t08-gnu.err | FileCheck %s --check-prefix=NORELOCSECTION-OUT-GNU
 351 # RUN: FileCheck %s < %t08-gnu.err --check-prefix=NORELOCSECTION-ERR -DFILE=%t08
 352 # RUN: llvm-readobj --stack-sizes %t08 2> %t08-llvm.err | FileCheck %s --check-prefix=NORELOCSECTION-OUT-LLVM
 353 # RUN: FileCheck %s < %t08-llvm.err --check-prefix=NORELOCSECTION-ERR -DFILE=%t08
 354
 355 # NORELOCSECTION-OUT-GNU:     Size Function
 356 # NORELOCSECTION-OUT-GNU-NOT: {{.}}
 357
 358 # NORELOCSECTION-OUT-LLVM:      StackSizes [
 359 # NORELOCSECTION-OUT-LLVM-NEXT: ]
 360
 361 # NORELOCSECTION-ERR: warning: '[[FILE]]': section .stack_sizes does not have a corresponding relocation section
 362
 363 --- !ELF
 364 FileHeader:
 365   Class:   ELFCLASS64
 366   Data:    ELFDATA2LSB
 367   Type:    ET_REL
 368   Machine: EM_X86_64
 369 Sections:
 370   - Name:    .text
 371     Type:    SHT_PROGBITS
 372     Size:    8
 373   - Name:    .stack_sizes
 374     Type:    SHT_PROGBITS
 375     Link:    .text
 376     Content: "000000000000000008"
 377
 378 ## Check that we handle multiple object files, separately and when they
 379 ## are in an archive. This also checks whether we have blank lines between the
 380 ## tables.
 381
 382 # RUN: llvm-ar rc %t1.a %t01 %t02
 383 # RUN: llvm-readelf --stack-sizes %t01 %t02 \
 384 # RUN:   | FileCheck %s --check-prefixes=MULTIPLE-GNU,OBJECT -DFILE1=%t01 -DFILE2=%t02
 385 # RUN: llvm-readelf --stack-sizes %t1.a \
 386 # RUN:   | FileCheck %s --check-prefixes=MULTIPLE-GNU,ARCHIVE --strict-whitespace\
 387 # RUN:   --match-full-lines -DFILE=%t1.a
 388 # RUN: llvm-readobj --stack-sizes %t01 %t02 \
 389 # RUN:   | FileCheck %s --check-prefixes=MULTIPLE-LLVM,OBJECT -DFILE1=%t01 -DFILE2=%t02
 390 # RUN: llvm-readobj --stack-sizes %t1.a \
 391 # RUN:   | FileCheck %s --check-prefixes=MULTIPLE-LLVM,ARCHIVE -DFILE=%t1.a
 392
 393 #        OBJECT:File: [[FILE1]]
 394 #       ARCHIVE:File: [[FILE]]({{.*01}})
 395
 396 #      MULTIPLE-GNU:Stack Sizes:
 397 # MULTIPLE-GNU-NEXT:         Size     Function
 398 # MULTIPLE-GNU-NEXT:           16     referenced_by_symbol_foo
 399 # MULTIPLE-GNU-NEXT:           32     referenced_via_section_bar
 400 # MULTIPLE-GNU-NEXT:            8     separate_text_section_baz
 401 # MULTIPLE-GNU-EMPTY:
 402
 403 # MULTIPLE-LLVM:      StackSizes [
 404 # MULTIPLE-LLVM-NEXT:   Entry {
 405 # MULTIPLE-LLVM-NEXT:     Function: referenced_by_symbol_foo
 406 # MULTIPLE-LLVM-NEXT:     Size: 0x10
 407 # MULTIPLE-LLVM-NEXT:   }
 408 # MULTIPLE-LLVM-NEXT:   Entry {
 409 # MULTIPLE-LLVM-NEXT:     Function: referenced_via_section_bar
 410 # MULTIPLE-LLVM-NEXT:     Size: 0x20
 411 # MULTIPLE-LLVM-NEXT:   }
 412 # MULTIPLE-LLVM-NEXT:   Entry {
 413 # MULTIPLE-LLVM-NEXT:     Function: separate_text_section_baz
 414 # MULTIPLE-LLVM-NEXT:     Size: 0x8
 415 # MULTIPLE-LLVM-NEXT:   }
 416 # MULTIPLE-LLVM-NEXT: ]
 417
 418 #        OBJECT:File: [[FILE2]]
 419 #       ARCHIVE:File: [[FILE]]({{.*02}})
 420
 421 # MULTIPLE-GNU-EMPTY:
 422 # MULTIPLE-GNU-NEXT:Stack Sizes:
 423 # MULTIPLE-GNU-NEXT:         Size     Function
 424 # MULTIPLE-GNU-NEXT:           16     foo
 425 # MULTIPLE-GNU-NEXT:           32     bar
 426
 427 # MULTIPLE-LLVM:      StackSizes [
 428 # MULTIPLE-LLVM-NEXT:   Entry {
 429 # MULTIPLE-LLVM-NEXT:     Function: foo
 430 # MULTIPLE-LLVM-NEXT:     Size: 0x10
 431 # MULTIPLE-LLVM-NEXT:   }
 432 # MULTIPLE-LLVM-NEXT:   Entry {
 433 # MULTIPLE-LLVM-NEXT:     Function: bar
 434 # MULTIPLE-LLVM-NEXT:     Size: 0x20
 435 # MULTIPLE-LLVM-NEXT:   }
 436 # MULTIPLE-LLVM-NEXT: ]
 437
 438 ## Check that we do not consider symbols that are not function symbols, even though
 439 ## a relocation references them.
 440
 441 # RUN: yaml2obj --docnum=9 %s > %t14
 442 # RUN: llvm-readelf --stack-sizes %t14 2> %t14-gnu.err | FileCheck %s --check-prefix=NONFUNCTIONSYM-GNU
 443 # RUN: FileCheck %s < %t14-gnu.err --check-prefix=NONFUNCTIONSYM-ERR -DFILE=%t14
 444 # RUN: llvm-readobj --stack-sizes %t14 2> %t14-llvm.err | FileCheck %s --check-prefix=NONFUNCTIONSYM-LLVM
 445 # RUN: FileCheck %s < %t14-llvm.err --check-prefix=NONFUNCTIONSYM-ERR -DFILE=%t14
 446
 447 # NONFUNCTIONSYM-GNU:     Stack Sizes:
 448 # NONFUNCTIONSYM-GNU:     0 ?
 449
 450 # NONFUNCTIONSYM-LLVM:      StackSizes [
 451 # NONFUNCTIONSYM-LLVM-NEXT:   Entry {
 452 # NONFUNCTIONSYM-LLVM-NEXT:     Function: ?
 453 # NONFUNCTIONSYM-LLVM-NEXT:     Size: 0x0
 454 # NONFUNCTIONSYM-LLVM-NEXT:   }
 455 # NONFUNCTIONSYM-LLVM-NEXT: ]
 456
 457 # NONFUNCTIONSYM-ERR: warning: '[[FILE]]': could not identify function symbol for stack size entry
 458
 459 --- !ELF
 460 FileHeader:
 461   Class:   ELFCLASS64
 462   Data:    ELFDATA2LSB
 463   Type:    ET_REL
 464   Machine: EM_X86_64
 465 Sections:
 466   - Name: .text
 467     Type: SHT_PROGBITS
 468     Size: 16
 469   - Name: .stack_sizes
 470     Type: SHT_PROGBITS
 471     Size: 9
 472     Link: .text
 473   - Name: .rela.stack_sizes
 474     Type: SHT_RELA
 475     Info: .stack_sizes
 476     Relocations:
 477       - Offset: 0
 478         Symbol: foo
 479         Type:   R_X86_64_64
 480 Symbols:
 481   - Name:    foo
 482     Section: .text
 483     Type:    STT_OBJECT
 484     Binding: STB_GLOBAL
 485
 486 ## Check that we report an error when we find an unsupported relocation
 487 ## in the section that contains the stack size entries' relocations.
 488
 489 # RUN: yaml2obj --docnum=10 %s > %t15
 490 # RUN: not llvm-readelf --stack-sizes %t15 2>&1 | FileCheck %s --check-prefix=UNSUPPRELOC -DFILE=%t15
 491 # RUN: not llvm-readobj --stack-sizes %t15 2>&1 | FileCheck %s --check-prefix=UNSUPPRELOC -DFILE=%t15
 492
 493 # UNSUPPRELOC: error: '[[FILE]]': unsupported relocation type in section .rela.stack_sizes: R_X86_64_RELATIVE
 494
 495 --- !ELF
 496 FileHeader:
 497   Class:   ELFCLASS64
 498   Data:    ELFDATA2LSB
 499   Type:    ET_REL
 500   Machine: EM_X86_64
 501 Sections:
 502   - Name: .text
 503     Type: SHT_PROGBITS
 504     Size: 8
 505   - Name: .stack_sizes
 506     Type: SHT_PROGBITS
 507     Size: 16
 508     Link: .text
 509   - Name: .rela.stack_sizes
 510     Type: SHT_RELA
 511     Info: .stack_sizes
 512     Relocations:
 513       - Offset: 0
 514         Symbol: foo
 515         Type:   R_X86_64_RELATIVE
 516 Symbols:
 517   - Name:    foo
 518     Section: .text
 519     Type:    STT_FUNC
 520     Binding: STB_GLOBAL
 521
 522 ## Check that warning messages in archives do not impact other members. In the following
 523 ## test, the first archive member generates a warning and we make sure all the information
 524 ## is still dumped.
 525
 526 # RUN: llvm-ar rc %t2.a %t04 %t01
 527 # RUN: llvm-readelf --stack-sizes %t2.a 2>&1 | FileCheck %s --check-prefix=ARCHIVEWARN-GNU \
 528 # RUN:   -DFILE=%t2.a --strict-whitespace --match-full-lines
 529 # RUN: llvm-readobj --stack-sizes %t2.a 2>&1 | FileCheck %s --check-prefix=ARCHIVEWARN-LLVM -DFILE=%t2.a
 530
 531 #      ARCHIVEWARN-GNU:File: [[FILE]]({{.*04}})
 532 #      ARCHIVEWARN-GNU:Stack Sizes:
 533 # ARCHIVEWARN-GNU-NEXT:         Size     Function
 534 #      ARCHIVEWARN-GNU:{{.*}}: warning: '{{.*04}}': relocation symbol foo is not in the expected section
 535 #      ARCHIVEWARN-GNU:            8     foo
 536 #      ARCHIVEWARN-GNU:File: [[FILE]]({{.*01}})
 537 #      ARCHIVEWARN-GNU:Stack Sizes:
 538 # ARCHIVEWARN-GNU-NEXT:         Size     Function
 539 # ARCHIVEWARN-GNU-NEXT:           16     referenced_by_symbol_foo
 540 # ARCHIVEWARN-GNU-NEXT:           32     referenced_via_section_bar
 541 # ARCHIVEWARN-GNU-NEXT:            8     separate_text_section_baz
 542 #  ARCHIVEWARN-GNU-NOT:{{.}}
 543
 544
 545 # ARCHIVEWARN-LLVM:      File: [[FILE]]({{.*04}})
 546 # ARCHIVEWARN-LLVM:      StackSizes [
 547 # ARCHIVEWARN-LLVM:      warning: '{{.*04}}': relocation symbol foo is not in the expected section
 548 # ARCHIVEWARN-LLVM-NEXT:   Entry {
 549 # ARCHIVEWARN-LLVM-NEXT:     Function: foo
 550 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x8
 551 # ARCHIVEWARN-LLVM-NEXT:   }
 552 # ARCHIVEWARN-LLVM-NEXT: ]
 553 # ARCHIVEWARN-LLVM:      File: [[FILE]]({{.*01}})
 554 # ARCHIVEWARN-LLVM:      StackSizes [
 555 # ARCHIVEWARN-LLVM-NEXT:   Entry {
 556 # ARCHIVEWARN-LLVM-NEXT:     Function: referenced_by_symbol_foo
 557 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x10
 558 # ARCHIVEWARN-LLVM-NEXT:   }
 559 # ARCHIVEWARN-LLVM-NEXT:   Entry {
 560 # ARCHIVEWARN-LLVM-NEXT:     Function: referenced_via_section_bar
 561 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x20
 562 # ARCHIVEWARN-LLVM-NEXT:   }
 563 # ARCHIVEWARN-LLVM-NEXT:   Entry {
 564 # ARCHIVEWARN-LLVM-NEXT:     Function: separate_text_section_baz
 565 # ARCHIVEWARN-LLVM-NEXT:     Size: 0x8
 566 # ARCHIVEWARN-LLVM-NEXT:   }
 567 # ARCHIVEWARN-LLVM-NEXT: ]
 568
 569 ## Check that we demangle function names when requested.
 570
 571 # RUN: yaml2obj --docnum=11 %s > %t16
 572 # RUN: llvm-readelf --stack-sizes --demangle %t16 | FileCheck %s --check-prefix=DEMANGLE-GNU
 573 # RUN: llvm-readobj --stack-sizes --demangle %t16 | FileCheck %s --check-prefix=DEMANGLE-LLVM
 574
 575 # DEMANGLE-GNU:  16 foo(float)
 576 # DEMANGLE-LLVM: Function: foo(float)
 577
 578 --- !ELF
 579 FileHeader:
 580   Class:   ELFCLASS64
 581   Data:    ELFDATA2LSB
 582   Type:    ET_EXEC
 583   Machine: EM_X86_64
 584 Sections:
 585   - Name:    .text
 586     Type:    SHT_PROGBITS
 587     Flags:   [SHF_ALLOC]
 588     Size:    16
 589   - Name:    .stack_sizes
 590     Type:    SHT_PROGBITS
 591     Content: "100000000000000010"
 592     Link:    .text
 593 Symbols:
 594   - Name:    _Z3foof
 595     Section: .text
 596     Value:   0x10
 597     Type:    STT_FUNC
 598     Binding: STB_GLOBAL