caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
45ba2392d7e00aedd4d9fb04070dbae8a7fbbeeb
clang-p2996/llvm/test/tools/llvm-readobj/ELF/stack-sizes.test
Georgii Rymar 245052ac30 [llvm-readelf/obj] - Improve the error reporting in printStackSize(). 
This stops using `RelocationRef` API in the `printStackSize` method
and starts using the "regular" API that is used in almost all other places
in ELFDumper.cpp.

This is not only makes the code to be more consistent, but helps to diagnose
issues better, because the `ELFObjectFile` API, which is used
currently to implement stack sized dumping sometimes has a behavior
that just doesn't work well for broken inputs.

E.g see how it gets the `symbol_end` iterator. It will just not work
well for a case when the `sh_size` is broken.

```
template <class ELFT>
basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const {
...
  DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
  return basic_symbol_iterator(SymbolRef(Sym, this));
}
```

Differential revision: https://reviews.llvm.org/D91624
2020-11-24 11:49:00 +03:00

801 lines
26 KiB
Plaintext
Raw Blame History

## Check that we correctly display the contents of the .stack_sizes section
## in a relocatable object file.
# RUN: yaml2obj --docnum=1 %s -o %t01
# RUN: llvm-readelf --stack-sizes %t01 \
# RUN: | FileCheck %s --check-prefix=RELOC-GNU --strict-whitespace --match-full-lines
# RUN: llvm-readobj --stack-sizes %t01 | FileCheck %s --check-prefix=RELOC-LLVM
# RELOC-GNU: Size Function
# RELOC-GNU-NEXT: 16 referenced_by_symbol_foo
# RELOC-GNU-NEXT: 32 referenced_via_section_bar
# RELOC-GNU-NEXT: 8 separate_text_section_baz
# RELOC-GNU-NOT:{{.}}
# RELOC-LLVM: StackSizes [
# RELOC-LLVM-NEXT: Entry {
# RELOC-LLVM-NEXT: Function: referenced_by_symbol_foo
# RELOC-LLVM-NEXT: Size: 0x10
# RELOC-LLVM-NEXT: }
# RELOC-LLVM-NEXT: Entry {
# RELOC-LLVM-NEXT: Function: referenced_via_section_bar
# RELOC-LLVM-NEXT: Size: 0x20
# RELOC-LLVM-NEXT: }
# RELOC-LLVM-NEXT: Entry {
# RELOC-LLVM-NEXT: Function: separate_text_section_baz
# RELOC-LLVM-NEXT: Size: 0x8
# RELOC-LLVM-NEXT: }
# RELOC-LLVM-NEXT: ]
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC]
Size: 16
- Name: .text.baz
Type: SHT_PROGBITS
Flags: [SHF_ALLOC]
Size: 16
- Name: .stack_sizes
Type: SHT_PROGBITS
Entries:
- Size: 0x10
- Size: 0x20
Link: .text
- Name: '.stack_sizes (1)'
Type: SHT_PROGBITS
Entries:
- Address: 0x20
Size: 0x8
Link: .text.baz
- Name: .rela.stack_sizes
Type: SHT_RELA
Info: .stack_sizes
Relocations:
## A symbol relative reference.
- Offset: 0
Symbol: referenced_by_symbol_foo
Type: R_X86_64_64
## A section relative reference.
- Offset: 9
Addend: 16
Symbol: .text
Type: R_X86_64_64
- Name: '.rela.stack_sizes (1)'
Type: SHT_RELA
Info: '.stack_sizes (1)'
Relocations:
- Offset: 0
Symbol: separate_text_section_baz
Type: R_X86_64_64
Symbols:
- Name: separate_text_section_baz
Section: .text.baz
Type: STT_FUNC
- Name: .text
Section: .text
Type: STT_SECTION
- Name: referenced_by_symbol_foo
Section: .text
Type: STT_FUNC
Binding: STB_GLOBAL
- Name: referenced_via_section_bar
Section: .text
Value: 0x10
Type: STT_FUNC
Binding: STB_GLOBAL
## Check that we correctly report the stack sizes in an executable (non-relocatable)
## object file. This also shows that the sh_link field is ignored in this situation
## without warning.
# RUN: yaml2obj --docnum=2 %s -o %t02
# RUN: llvm-readelf --stack-sizes %t02 2>&1 \
# RUN: | FileCheck %s --check-prefix=EXEC-GNU --strict-whitespace \
# RUN: --match-full-lines --implicit-check-not=warning:
# RUN: llvm-readobj --stack-sizes %t02 2>&1 \
# RUN: | FileCheck %s --check-prefix=EXEC-LLVM --implicit-check-not=warning:
# EXEC-GNU: Size Function
# EXEC-GNU-NEXT: 16 other
# EXEC-GNU-NEXT: 32 other_end
# EXEC-GNU-NEXT: 48 bar
# EXEC-GNU-NOT:{{.}}
# EXEC-LLVM: StackSizes [
# EXEC-LLVM-NEXT: Entry {
# EXEC-LLVM-NEXT: Function: other
# EXEC-LLVM-NEXT: Size: 0x10
# EXEC-LLVM-NEXT: }
# EXEC-LLVM-NEXT: Entry {
# EXEC-LLVM-NEXT: Function: other_end
# EXEC-LLVM-NEXT: Size: 0x20
# EXEC-LLVM-NEXT: }
# EXEC-LLVM-NEXT: Entry {
# EXEC-LLVM-NEXT: Function: bar
# EXEC-LLVM-NEXT: Size: 0x30
# EXEC-LLVM-NEXT: }
# EXEC-LLVM-NEXT: ]
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC]
Size: 16
- Name: .text2
Type: SHT_PROGBITS
Flags: [SHF_ALLOC]
Size: 16
- Name: .stack_sizes
Type: SHT_PROGBITS
Entries:
- Address: 0x0
Size: 0x10
- Address: 0x10
Size: 0x20
- Address: 0x20
Size: 0x30
Link: .text2
Symbols:
## Undefined symbols are ignored.
- Name: undefined
Type: STT_FUNC
Binding: STB_GLOBAL
## sh_link of .stack_sizes is ignored for non-reloctable objects.
- Name: other
Section: .text
Value: 0
Type: STT_FUNC
Binding: STB_GLOBAL
## If two symbols have the same value, the first is picked, regardless of
## the sh_link value of the .stack_sizes section.
- Name: other_end
Section: .text
Value: 0x10
Type: STT_FUNC
Binding: STB_GLOBAL
- Name: foo
Section: .text2
Value: 0x10
Type: STT_FUNC
Binding: STB_GLOBAL
- Name: bar
Section: .text2
Value: 0x20
Type: STT_FUNC
Binding: STB_GLOBAL
## Check that we report a warning when we find relocations whose offsets point outside
## of the .stack_sizes section.
# RUN: yaml2obj --docnum=3 %s -o %t03
# RUN: llvm-readelf --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT-GNU -DFILE=%t03
# RUN: llvm-readobj --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT-LLVM -DFILE=%t03
# SHORT-GNU: Stack Sizes:
# SHORT-GNU-NEXT: Size Function
# SHORT-GNU-NEXT: 8 foo
# SHORT-GNU-NEXT: warning: '[[FILE]]': found invalid relocation offset (0x1) into SHT_PROGBITS section with index 2 while trying to extract a stack size entry
# SHORT-GNU-NEXT: 8 foo
# SHORT-LLVM: StackSizes [
# SHORT-LLVM-NEXT: Entry {
# SHORT-LLVM-NEXT: Function: foo
# SHORT-LLVM-NEXT: Size: 0x8
# SHORT-LLVM-NEXT: }
# SHORT-LLVM-NEXT: warning: '[[FILE]]': found invalid relocation offset (0x1) into SHT_PROGBITS section with index 2 while trying to extract a stack size entry
# SHORT-LLVM-NEXT: Entry {
# SHORT-LLVM-NEXT: Function: foo
# SHORT-LLVM-NEXT: Size: 0x8
# SHORT-LLVM-NEXT: }
# SHORT-LLVM-NEXT: ]
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC]
Size: 16
- Name: .stack_sizes
Type: SHT_PROGBITS
Link: .text
Entries:
- Size: 0x8
- Name: .rela.stack_sizes
Type: SHT_RELA
Info: .stack_sizes
Relocations:
- Offset: 0x0
Symbol: foo
Type: R_X86_64_64
- Offset: 0x1
Symbol: foo
Type: R_X86_64_64
- Offset: 0x1
Symbol: foo
Type: R_X86_64_64
- Offset: 0x0
Symbol: foo
Type: R_X86_64_64
Symbols:
- Name: foo
Section: .text
Type: STT_FUNC
Binding: STB_GLOBAL
## Check that we warn about a function symbol that is not in the section
## that is referenced by the stack sizes section's sh_link, for relocatable
## output.
# RUN: yaml2obj --docnum=4 %s -o %t04
# RUN: llvm-readelf --stack-sizes %t04 2> %t04-gnu.err | FileCheck %s --check-prefix=WRONGSECTION-GNU
# RUN: FileCheck %s < %t04-gnu.err --check-prefix=WRONGSECTION-ERR -DFILE=%t04
# RUN: llvm-readobj --stack-sizes %t04 2> %t04-llvm.err | FileCheck %s --check-prefix=WRONGSECTION-LLVM
# RUN: FileCheck %s < %t04-llvm.err --check-prefix=WRONGSECTION-ERR -DFILE=%t04
# RUN: llvm-readelf --stack-sizes --demangle %t04 2>&1 | FileCheck %s --check-prefix=WRONGSECTION-DEMANGLE-ERR -DFILE=%t04
# RUN: llvm-readobj --stack-sizes --demangle %t04 2>&1 | FileCheck %s --check-prefix=WRONGSECTION-DEMANGLE-ERR -DFILE=%t04
# WRONGSECTION-GNU: Size Function
# WRONGSECTION-GNU-NEXT: 8 _Z3foof
# WRONGSECTION-LLVM: StackSizes [
# WRONGSECTION-LLVM-NEXT: Entry {
# WRONGSECTION-LLVM-NEXT: Function: _Z3foof
# WRONGSECTION-LLVM-NEXT: Size: 0x8
# WRONGSECTION-LLVM-NEXT: }
# WRONGSECTION-LLVM-NEXT: ]
# WRONGSECTION-ERR: warning: '[[FILE]]': relocation symbol '_Z3foof' is not in the expected section
# WRONGSECTION-DEMANGLE-ERR: warning: '[[FILE]]': relocation symbol 'foo(float)' is not in the expected section
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Size: 8
- Name: .text2
Type: SHT_PROGBITS
Size: 8
Flags: [SHF_ALLOC]
- Name: .stack_sizes
Type: SHT_PROGBITS
Entries:
- Size: 0x8
Link: .text2
- Name: .rela.stack_sizes
Type: SHT_RELA
Info: .stack_sizes
Relocations:
- Offset: 0
Symbol: _Z3foof
Type: R_X86_64_64
Symbols:
- Name: _Z3foof
Section: .text
Type: STT_FUNC
Binding: STB_GLOBAL
## Check that we report a warning when a stack sizes section ends with an incomplete stack size entry.
# RUN: yaml2obj --docnum=5 %s -o %t05
# RUN: llvm-readelf --stack-sizes %t05 2>&1 | \
# RUN: FileCheck %s --check-prefix=SUDDENEND-GNU -DFILE=%t05
# RUN: llvm-readobj --stack-sizes %t05 2>&1 | \
# RUN: FileCheck %s --check-prefix=SUDDENEND-LLVM -DFILE=%t05
# SUDDENEND-GNU: Stack Sizes:
# SUDDENEND-GNU-NEXT: Size Function
# SUDDENEND-GNU-NEXT: 8 foo
# SUDDENEND-GNU-NEXT: warning: '[[FILE]]': SHT_PROGBITS section with index 2 ended while trying to extract a stack size entry
# SUDDENEND-GNU-NEXT: 8 foo
# SUDDENEND-GNU-NEXT: warning: '[[FILE]]': SHT_PROGBITS section with index 3 ended while trying to extract a stack size entry
# SUDDENEND-LLVM: StackSizes [
# SUDDENEND-LLVM-NEXT: Entry {
# SUDDENEND-LLVM-NEXT: Function: foo
# SUDDENEND-LLVM-NEXT: Size: 0x8
# SUDDENEND-LLVM-NEXT: }
# SUDDENEND-LLVM-NEXT: warning: '[[FILE]]': SHT_PROGBITS section with index 2 ended while trying to extract a stack size entry
# SUDDENEND-LLVM-NEXT: Entry {
# SUDDENEND-LLVM-NEXT: Function: foo
# SUDDENEND-LLVM-NEXT: Size: 0x8
# SUDDENEND-LLVM-NEXT: }
# SUDDENEND-LLVM-NEXT: warning: '[[FILE]]': SHT_PROGBITS section with index 3 ended while trying to extract a stack size entry
# SUDDENEND-LLVM-NEXT: ]
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
- Name: .stack_sizes
Type: SHT_PROGBITS
Link: .text
Entries:
- Size: 0x8
- Size: 0x10
## 0x11 == the normal size minus 1.
ShSize: 0x11
- Name: .stack_sizes (1)
Type: SHT_PROGBITS
Link: .text
Entries:
- Size: 0x8
- Size: 0x10
ShSize: 0x11
Symbols:
- Name: foo
Section: .text
Type: STT_FUNC
## Check that we report an invalid stack size, which is represented by a ULEB that
## ends in a byte with the high bit set.
# RUN: yaml2obj --docnum=6 %s -o %t06
# RUN: llvm-readelf --stack-sizes %t06 2>&1 | FileCheck %s --check-prefix=BADSIZE -DFILE=%t06
# RUN: llvm-readobj --stack-sizes %t06 2>&1 | FileCheck %s --check-prefix=BADSIZE -DFILE=%t06
# BADSIZE: warning: '[[FILE]]': could not extract a valid stack size in SHT_PROGBITS section with index 2
# BADSIZE: warning: '[[FILE]]': could not extract a valid stack size in SHT_PROGBITS section with index 3
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC]
Size: 16
- Name: .stack_sizes
Type: SHT_PROGBITS
Content: "100000000000000080"
Link: .text
- Name: .stack_sizes (1)
Type: SHT_PROGBITS
Content: "100000000000000080"
Link: .text
Symbols:
- Name: foo
Section: .text
Value: 0x10
Type: STT_FUNC
Binding: STB_GLOBAL
## Check that we report a warning when a relocation symbol does not belong to a
## valid section or when it has an invalid index. We expect a stack size entry
## with an unknown symbol in the output.
# RUN: yaml2obj --docnum=7 %s -o %t07
# RUN: llvm-readelf --stack-sizes %t07 2>&1 | \
# RUN: FileCheck %s -DFILE=%t07 --check-prefix=BADSECTION-OUT-GNU --implicit-check-not=warning:
# RUN: llvm-readobj --stack-sizes %t07 2>&1 | \
# 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]]': could not identify function symbol for stack size entry
# 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 0x1880: offset goes past the end of file
# BADSECTION-OUT-GNU-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry
# BADSECTION-OUT-GNU-NEXT: 22 ?
# 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]]': could not identify function symbol for stack size entry
# 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 0x1880: offset goes past the end of file
# BADSECTION-OUT-LLVM-NEXT: warning: '[[FILE]]': could not identify function symbol for stack size entry
# BADSECTION-OUT-LLVM-NEXT: Entry {
# BADSECTION-OUT-LLVM-NEXT: Function: ?
# BADSECTION-OUT-LLVM-NEXT: Size: 0x16
# 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
# BADSECTION-DEMANGLE-ERR: warning: '[[FILE]]': cannot identify the section for relocation symbol 'foo(float)'
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Size: 16
- Name: .stack_sizes
Type: SHT_PROGBITS
Link: .text
Entries:
- Size: 0x8
- Size: 0x16
- Name: .rela.stack_sizes
Type: SHT_RELA
Info: .stack_sizes
Relocations:
- Offset: 0
Symbol: _Z3foof
Type: R_X86_64_64
- Offset: 9
## An invalid symbol index.
Symbol: 0xff
Type: R_X86_64_64
Symbols:
- Name: _Z3foof
## An invalid section index.
Index: 10
Type: STT_FUNC
Binding: STB_GLOBAL
## Check that we report a warning when a stack sizes section does not come with
## a corresponding relocation section.
# RUN: yaml2obj --docnum=8 %s -o %t08
# RUN: llvm-readelf --stack-sizes %t08 2> %t08-gnu.err | FileCheck %s --check-prefix=NORELOCSECTION-OUT-GNU
# RUN: FileCheck %s < %t08-gnu.err --check-prefix=NORELOCSECTION-ERR -DFILE=%t08
# RUN: llvm-readobj --stack-sizes %t08 2> %t08-llvm.err | FileCheck %s --check-prefix=NORELOCSECTION-OUT-LLVM
# RUN: FileCheck %s < %t08-llvm.err --check-prefix=NORELOCSECTION-ERR -DFILE=%t08
# NORELOCSECTION-OUT-GNU: Size Function
# NORELOCSECTION-OUT-GNU-NOT: {{.}}
# NORELOCSECTION-OUT-LLVM: StackSizes [
# NORELOCSECTION-OUT-LLVM-NEXT: ]
# NORELOCSECTION-ERR: warning: '[[FILE]]': .stack_sizes (SHT_PROGBITS section with index 2) does not have a corresponding relocation section
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Sections:
- Name: .text
Type: SHT_PROGBITS
Size: 8
- Name: .stack_sizes
Type: SHT_PROGBITS
Link: .text
Entries:
- Size: 0x1
## Check that we handle multiple object files, separately and when they
## are in an archive. This also checks whether we have blank lines between the
## tables.
# RUN: llvm-ar rc %t1.a %t01 %t02
# RUN: llvm-readelf --stack-sizes %t01 %t02 \
# RUN: | FileCheck %s --check-prefixes=MULTIPLE-GNU,OBJECT -DFILE1=%t01 -DFILE2=%t02
# RUN: llvm-readelf --stack-sizes %t1.a \
# RUN: | FileCheck %s --check-prefixes=MULTIPLE-GNU,ARCHIVE --strict-whitespace\
# RUN: --match-full-lines -DFILE=%t1.a
# RUN: llvm-readobj --stack-sizes %t01 %t02 \
# RUN: | FileCheck %s --check-prefixes=MULTIPLE-LLVM,OBJECT -DFILE1=%t01 -DFILE2=%t02
# RUN: llvm-readobj --stack-sizes %t1.a \
# RUN: | FileCheck %s --check-prefixes=MULTIPLE-LLVM,ARCHIVE -DFILE=%t1.a
# OBJECT:File: [[FILE1]]
# ARCHIVE:File: [[FILE]]({{.*01}})
# MULTIPLE-GNU:Stack Sizes:
# MULTIPLE-GNU-NEXT: Size Function
# MULTIPLE-GNU-NEXT: 16 referenced_by_symbol_foo
# MULTIPLE-GNU-NEXT: 32 referenced_via_section_bar
# MULTIPLE-GNU-NEXT: 8 separate_text_section_baz
# MULTIPLE-GNU-EMPTY:
# MULTIPLE-LLVM: StackSizes [
# MULTIPLE-LLVM-NEXT: Entry {
# MULTIPLE-LLVM-NEXT: Function: referenced_by_symbol_foo
# MULTIPLE-LLVM-NEXT: Size: 0x10
# MULTIPLE-LLVM-NEXT: }
# MULTIPLE-LLVM-NEXT: Entry {
# MULTIPLE-LLVM-NEXT: Function: referenced_via_section_bar
# MULTIPLE-LLVM-NEXT: Size: 0x20
# MULTIPLE-LLVM-NEXT: }
# MULTIPLE-LLVM-NEXT: Entry {
# MULTIPLE-LLVM-NEXT: Function: separate_text_section_baz
# MULTIPLE-LLVM-NEXT: Size: 0x8
# MULTIPLE-LLVM-NEXT: }
# MULTIPLE-LLVM-NEXT: ]
# OBJECT:File: [[FILE2]]
# ARCHIVE:File: [[FILE]]({{.*02}})
# MULTIPLE-GNU-EMPTY:
# MULTIPLE-GNU-NEXT:Stack Sizes:
# MULTIPLE-GNU-NEXT: Size Function
# MULTIPLE-GNU-NEXT: 16 other
# MULTIPLE-GNU-NEXT: 32 other_end
# MULTIPLE-GNU-NEXT: 48 bar
# MULTIPLE-LLVM: StackSizes [
# MULTIPLE-LLVM-NEXT: Entry {
# MULTIPLE-LLVM-NEXT: Function: other
# MULTIPLE-LLVM-NEXT: Size: 0x10
# MULTIPLE-LLVM-NEXT: }
# MULTIPLE-LLVM-NEXT: Entry {
# MULTIPLE-LLVM-NEXT: Function: other_end
# MULTIPLE-LLVM-NEXT: Size: 0x20
# MULTIPLE-LLVM-NEXT: }
# MULTIPLE-LLVM-NEXT: Entry {
# MULTIPLE-LLVM-NEXT: Function: bar
# MULTIPLE-LLVM-NEXT: Size: 0x30
# MULTIPLE-LLVM-NEXT: }
# MULTIPLE-LLVM-NEXT: ]
## Check that we do not consider symbols that are not function symbols, even though
## a relocation references them.
# RUN: yaml2obj --docnum=9 %s -o %t14
# RUN: llvm-readelf --stack-sizes %t14 2> %t14-gnu.err | FileCheck %s --check-prefix=NONFUNCTIONSYM-GNU
# RUN: FileCheck %s < %t14-gnu.err --check-prefix=NONFUNCTIONSYM-ERR -DFILE=%t14
# RUN: llvm-readobj --stack-sizes %t14 2> %t14-llvm.err | FileCheck %s --check-prefix=NONFUNCTIONSYM-LLVM
# RUN: FileCheck %s < %t14-llvm.err --check-prefix=NONFUNCTIONSYM-ERR -DFILE=%t14
# NONFUNCTIONSYM-GNU: Stack Sizes:
# NONFUNCTIONSYM-GNU: 0 ?
# NONFUNCTIONSYM-LLVM: StackSizes [
# NONFUNCTIONSYM-LLVM-NEXT: Entry {
# NONFUNCTIONSYM-LLVM-NEXT: Function: ?
# NONFUNCTIONSYM-LLVM-NEXT: Size: 0x0
# NONFUNCTIONSYM-LLVM-NEXT: }
# NONFUNCTIONSYM-LLVM-NEXT: ]
# NONFUNCTIONSYM-ERR: warning: '[[FILE]]': could not identify function symbol for stack size entry
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Size: 16
- Name: .stack_sizes
Type: SHT_PROGBITS
Entries:
- Size: 0
Link: .text
- Name: .rela.stack_sizes
Type: SHT_RELA
Info: .stack_sizes
Relocations:
- Offset: 0
Symbol: foo
Type: R_X86_64_64
Symbols:
- Name: foo
Section: .text
Type: STT_OBJECT
Binding: STB_GLOBAL
## Check that we report a warning when we find an unsupported relocation
## in the section that contains the stack size entries' relocations.
# RUN: yaml2obj --docnum=10 %s -o %t15
# RUN: llvm-readelf --stack-sizes %t15 2>&1 | FileCheck %s --check-prefix=UNSUPPRELOC-GNU -DFILE=%t15
# RUN: llvm-readobj --stack-sizes %t15 2>&1 | FileCheck %s --check-prefix=UNSUPPRELOC-LLVM -DFILE=%t15
# UNSUPPRELOC-GNU: Stack Sizes:
# UNSUPPRELOC-GNU-NEXT: Size Function
# UNSUPPRELOC-GNU-NEXT: warning: '[[FILE]]': SHT_RELA section with index 3 contains an unsupported relocation with index 1: R_X86_64_RELATIVE
# UNSUPPRELOC-GNU-NEXT: 0 foo
# UNSUPPRELOC-GNU-NEXT: warning: '[[FILE]]': SHT_RELA section with index 3 contains an unsupported relocation with index 3: R_X86_64_RELATIVE
# UNSUPPRELOC-LLVM: StackSizes [
# UNSUPPRELOC-LLVM-NEXT: warning: '[[FILE]]': SHT_RELA section with index 3 contains an unsupported relocation with index 1: R_X86_64_RELATIVE
# UNSUPPRELOC-LLVM-NEXT: Entry {
# UNSUPPRELOC-LLVM-NEXT: Function: foo
# UNSUPPRELOC-LLVM-NEXT: Size: 0x0
# UNSUPPRELOC-LLVM-NEXT: }
# UNSUPPRELOC-LLVM-NEXT: warning: '[[FILE]]': SHT_RELA section with index 3 contains an unsupported relocation with index 3: R_X86_64_RELATIVE
# UNSUPPRELOC-LLVM-NEXT: ]
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Size: 8
- Name: .stack_sizes
Type: SHT_PROGBITS
Link: .text
Entries:
- Size: 0
- Name: .rela.stack_sizes
Type: SHT_RELA
Info: .stack_sizes
Relocations:
- Offset: 0
Symbol: foo
Type: R_X86_64_RELATIVE
- Offset: 0
Symbol: foo
Type: R_X86_64_64
- Offset: 0
Symbol: foo
Type: R_X86_64_RELATIVE
Symbols:
- Name: foo
Section: .text
Type: STT_FUNC
Binding: STB_GLOBAL
## Check that warning messages in archives do not impact other members. In the following
## test, the first archive member generates a warning and we make sure all the information
## is still dumped.
# RUN: llvm-ar rc %t2.a %t04 %t01
# RUN: llvm-readelf --stack-sizes %t2.a 2>&1 | FileCheck %s --check-prefix=ARCHIVEWARN-GNU \
# RUN: -DFILE=%t2.a --strict-whitespace --match-full-lines
# RUN: llvm-readobj --stack-sizes %t2.a 2>&1 | FileCheck %s --check-prefix=ARCHIVEWARN-LLVM -DFILE=%t2.a
# ARCHIVEWARN-GNU:File: [[FILE]]({{.*04}})
# ARCHIVEWARN-GNU:Stack Sizes:
# ARCHIVEWARN-GNU-NEXT: Size Function
# ARCHIVEWARN-GNU:{{.*}}: warning: '{{.*04}}': relocation symbol '_Z3foof' is not in the expected section
# ARCHIVEWARN-GNU: 8 _Z3foof
# ARCHIVEWARN-GNU:File: [[FILE]]({{.*01}})
# ARCHIVEWARN-GNU:Stack Sizes:
# ARCHIVEWARN-GNU-NEXT: Size Function
# ARCHIVEWARN-GNU-NEXT: 16 referenced_by_symbol_foo
# ARCHIVEWARN-GNU-NEXT: 32 referenced_via_section_bar
# ARCHIVEWARN-GNU-NEXT: 8 separate_text_section_baz
# ARCHIVEWARN-GNU-NOT:{{.}}
# ARCHIVEWARN-LLVM: File: [[FILE]]({{.*04}})
# ARCHIVEWARN-LLVM: StackSizes [
# ARCHIVEWARN-LLVM: warning: '{{.*04}}': relocation symbol '_Z3foof' is not in the expected section
# ARCHIVEWARN-LLVM-NEXT: Entry {
# ARCHIVEWARN-LLVM-NEXT: Function: _Z3foof
# ARCHIVEWARN-LLVM-NEXT: Size: 0x8
# ARCHIVEWARN-LLVM-NEXT: }
# ARCHIVEWARN-LLVM-NEXT: ]
# ARCHIVEWARN-LLVM: File: [[FILE]]({{.*01}})
# ARCHIVEWARN-LLVM: StackSizes [
# ARCHIVEWARN-LLVM-NEXT: Entry {
# ARCHIVEWARN-LLVM-NEXT: Function: referenced_by_symbol_foo
# ARCHIVEWARN-LLVM-NEXT: Size: 0x10
# ARCHIVEWARN-LLVM-NEXT: }
# ARCHIVEWARN-LLVM-NEXT: Entry {
# ARCHIVEWARN-LLVM-NEXT: Function: referenced_via_section_bar
# ARCHIVEWARN-LLVM-NEXT: Size: 0x20
# ARCHIVEWARN-LLVM-NEXT: }
# ARCHIVEWARN-LLVM-NEXT: Entry {
# ARCHIVEWARN-LLVM-NEXT: Function: separate_text_section_baz
# ARCHIVEWARN-LLVM-NEXT: Size: 0x8
# ARCHIVEWARN-LLVM-NEXT: }
# ARCHIVEWARN-LLVM-NEXT: ]
## Check that we demangle function names when requested.
# RUN: yaml2obj --docnum=11 %s -o %t16
# RUN: llvm-readelf --stack-sizes --demangle %t16 | FileCheck %s --check-prefix=DEMANGLE-GNU
# RUN: llvm-readobj --stack-sizes --demangle %t16 | FileCheck %s --check-prefix=DEMANGLE-LLVM
# DEMANGLE-GNU: 16 foo(float)
# DEMANGLE-LLVM: Function: foo(float)
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC]
Size: 16
- Name: .stack_sizes
Type: SHT_PROGBITS
Entries:
- Address: 0x10
Size: 0x10
Link: .text
Symbols:
- Name: _Z3foof
Section: .text
Value: 0x10
Type: STT_FUNC
Binding: STB_GLOBAL
## Check that we report a warning when we are unable to resolve a relocation for a given ELF architecture.
## Here we have a 64-bit relocation used in a 32-bit object.
# RUN: yaml2obj --docnum=12 %s -o %t17
# RUN: llvm-readelf --stack-sizes %t17 2>&1 | FileCheck %s -DFILE=%t17 --check-prefix=UNSUPPRELOC2
# RUN: llvm-readobj --stack-sizes %t17 2>&1 | FileCheck %s -DFILE=%t17 --check-prefix=UNSUPPRELOC2
# UNSUPPRELOC2: warning: '[[FILE]]': SHT_RELA section with index 2 contains an unsupported relocation with index 1: R_X86_64_64
--- !ELF
FileHeader:
Class: ELFCLASS32
Data: ELFDATA2MSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .stack_sizes
Type: SHT_PROGBITS
Content: "00"
- Name: .rela.stack_sizes
Type: SHT_RELA
Info: .stack_sizes
Relocations:
- Offset: 0
Type: R_X86_64_64
## Check we report a warning when dumping stack sizes if the relocated section
## identified by the sh_info field is invalid. Here the sh_info value is larger than
## the number of sections.
# RUN: yaml2obj --docnum=13 %s -o %t18
# RUN: llvm-readelf --stack-sizes %t18 2>&1 | \
# RUN: FileCheck %s --implicit-check-not="warning:" -DFILE=%t18 --check-prefix=INVALID-TARGET
# RUN: llvm-readobj --stack-sizes %t18 2>&1 | \
# RUN: FileCheck %s --implicit-check-not="warning:" -DFILE=%t18 --check-prefix=INVALID-TARGET
# INVALID-TARGET: warning: '[[FILE]]': SHT_RELA section with index 1: failed to get a relocated section: invalid section index: 255
# INVALID-TARGET: warning: '[[FILE]]': SHT_RELA section with index 2: failed to get a relocated section: invalid section index: 255
--- !ELF
FileHeader:
Class: ELFCLASS32
Data: ELFDATA2MSB
Type: ET_REL
Sections:
- Name: .rela.stack_sizes
Type: SHT_RELA
Link: 0
Info: 0xFF
Relocations: []
- Name: .rela.stack_sizes (1)
Type: SHT_RELA
Link: 0
Info: 0xFF
Relocations: []
Reference in New Issue View Git Blame Copy Permalink