## Check that we correctly display the contents of the .stack_sizes section ## in a relocatable object file. # RUN: yaml2obj --docnum=1 %s > %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. # RUN: yaml2obj --docnum=2 %s > %t02 # RUN: llvm-readelf --stack-sizes %t02 \ # RUN: | FileCheck %s --check-prefix=EXEC-GNU --strict-whitespace --match-full-lines # RUN: llvm-readobj --stack-sizes %t02 | FileCheck %s --check-prefix=EXEC-LLVM # EXEC-GNU: Size Function # EXEC-GNU-NEXT: 16 foo # EXEC-GNU-NEXT: 32 bar # EXEC-GNU-NOT:{{.}} # EXEC-LLVM: StackSizes [ # EXEC-LLVM-NEXT: Entry { # EXEC-LLVM-NEXT: Function: foo # EXEC-LLVM-NEXT: Size: 0x10 # EXEC-LLVM-NEXT: } # EXEC-LLVM-NEXT: Entry { # EXEC-LLVM-NEXT: Function: bar # EXEC-LLVM-NEXT: Size: 0x20 # EXEC-LLVM-NEXT: } # EXEC-LLVM-NEXT: ] --- !ELF FileHeader: Class: ELFCLASS64 Data: ELFDATA2LSB Type: ET_EXEC Machine: EM_X86_64 Sections: - Name: .text Type: SHT_PROGBITS Flags: [SHF_ALLOC] Size: 16 - Name: .stack_sizes Type: SHT_PROGBITS Entries: - Address: 0x10 Size: 0x10 - Address: 0x20 Size: 0x20 Link: .text Symbols: - Name: foo Section: .text Value: 0x10 Type: STT_FUNC Binding: STB_GLOBAL - Name: bar Section: .text Value: 0x20 Type: STT_FUNC Binding: STB_GLOBAL ## Check that we report an error when we find relocations whose offsets point outside ## of the .stack_sizes section. # RUN: yaml2obj --docnum=3 %s > %t03 # RUN: not llvm-readelf --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT -DFILE=%t03 # RUN: not llvm-readobj --stack-sizes %t03 2>&1 | FileCheck %s --check-prefix=SHORT -DFILE=%t03 # SHORT: error: '[[FILE]]': found invalid relocation offset into section .stack_sizes while trying to extract a stack size entry --- !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 Content: "00" Link: .text - Name: .rela.stack_sizes Type: SHT_RELA Info: .stack_sizes Relocations: - Offset: 1 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. # RUN: yaml2obj --docnum=4 %s > %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 an error when a stack sizes section ends with an incomplete stack size entry. # RUN: yaml2obj --docnum=5 %s > %t05 # RUN: not llvm-readelf --stack-sizes %t05 2>&1 | \ # RUN: FileCheck %s --check-prefix=SUDDENEND -DFILE=%t05 # RUN: not llvm-readobj --stack-sizes %t05 2>&1 | \ # RUN: FileCheck %s --check-prefix=SUDDENEND -DFILE=%t05 # SUDDENEND: error: '[[FILE]]': section .stack_sizes ended while trying to extract a stack size entry --- !ELF FileHeader: Class: ELFCLASS64 Data: ELFDATA2LSB Type: ET_EXEC Machine: EM_X86_64 Sections: - Name: .text Type: SHT_PROGBITS Flags: [SHF_ALLOC] Size: 16 - Name: .stack_sizes Type: SHT_PROGBITS Content: "10000000" Link: .text Symbols: - Name: foo Section: .text Value: 0x10 Type: STT_FUNC Binding: STB_GLOBAL ## 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 > %t06 # RUN: not llvm-readelf --stack-sizes %t06 2>&1 | FileCheck %s --check-prefix=BADSIZE -DFILE=%t06 # RUN: not llvm-readobj --stack-sizes %t06 2>&1 | FileCheck %s --check-prefix=BADSIZE -DFILE=%t06 # BADSIZE: error: '[[FILE]]': could not extract a valid stack size in section .stack_sizes --- !ELF FileHeader: Class: ELFCLASS64 Data: ELFDATA2LSB Type: ET_EXEC Machine: EM_X86_64 Sections: - Name: .text Type: SHT_PROGBITS Flags: [SHF_ALLOC] Size: 16 - Name: .stack_sizes 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. We expect a stack size entry with an unknown symbol in the ## output. # RUN: yaml2obj --docnum=7 %s > %t07 # RUN: llvm-readelf --stack-sizes %t07 2> %t07-gnu.err | FileCheck %s --check-prefix=BADSECTION-OUT-GNU # RUN: FileCheck %s < %t07-gnu.err --check-prefix=BADSECTION-ERR -DFILE=%t07 # RUN: llvm-readobj --stack-sizes %t07 2> %t07-llvm.err | FileCheck %s --check-prefix=BADSECTION-OUT-LLVM # RUN: FileCheck %s < %t07-llvm.err --check-prefix=BADSECTION-ERR -DFILE=%t07 # 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-OUT-GNU: Size Function # BADSECTION-OUT-GNU: 8 ? # BADSECTION-OUT-LLVM: StackSizes [ # BADSECTION-OUT-LLVM-NEXT: Entry { # BADSECTION-OUT-LLVM-NEXT: Function: ? # BADSECTION-OUT-LLVM-NEXT: Size: 0x8 # BADSECTION-OUT-LLVM-NEXT: } # BADSECTION-OUT-LLVM-NEXT: ] # BADSECTION-ERR: warning: '[[FILE]]': cannot identify the section for relocation symbol '_Z3foof' # 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: 8 - Name: .stack_sizes Type: SHT_PROGBITS Link: .text Entries: - Size: 0x8 - Name: .rela.stack_sizes Type: SHT_RELA Info: .stack_sizes Relocations: - Offset: 0 Symbol: _Z3foof 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 > %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]]': section .stack_sizes does not have a corresponding relocation section --- !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: 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 foo # MULTIPLE-GNU-NEXT: 32 bar # MULTIPLE-LLVM: StackSizes [ # MULTIPLE-LLVM-NEXT: Entry { # MULTIPLE-LLVM-NEXT: Function: foo # MULTIPLE-LLVM-NEXT: Size: 0x10 # MULTIPLE-LLVM-NEXT: } # MULTIPLE-LLVM-NEXT: Entry { # MULTIPLE-LLVM-NEXT: Function: bar # MULTIPLE-LLVM-NEXT: Size: 0x20 # 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 > %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 an error when we find an unsupported relocation ## in the section that contains the stack size entries' relocations. # RUN: yaml2obj --docnum=10 %s > %t15 # RUN: not llvm-readelf --stack-sizes %t15 2>&1 | FileCheck %s --check-prefix=UNSUPPRELOC -DFILE=%t15 # RUN: not llvm-readobj --stack-sizes %t15 2>&1 | FileCheck %s --check-prefix=UNSUPPRELOC -DFILE=%t15 # UNSUPPRELOC: error: '[[FILE]]': unsupported relocation type in section .rela.stack_sizes: R_X86_64_RELATIVE --- !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: [] - Name: .rela.stack_sizes Type: SHT_RELA Info: .stack_sizes Relocations: - 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 > %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 Machine: EM_X86_64 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 an error 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 > %t17 # RUN: not llvm-readelf --stack-sizes %t17 2>&1 | FileCheck %s -DFILE=%t17 --check-prefix=UNSUPPRELOC2 # RUN: not llvm-readobj --stack-sizes %t17 2>&1 | FileCheck %s -DFILE=%t17 --check-prefix=UNSUPPRELOC2 # UNSUPPRELOC2: error: '[[FILE]]': unsupported relocation type in section .rela.stack_sizes: 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 an error 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 > %t18 # RUN: not llvm-readelf --stack-sizes %t18 2>&1 | FileCheck %s -DFILE=%t18 --check-prefix=INVALID-TARGET # RUN: not llvm-readobj --stack-sizes %t18 2>&1 | FileCheck %s -DFILE=%t18 --check-prefix=INVALID-TARGET # INVALID-TARGET: error: '[[FILE]]': .rela.stack_sizes: failed to get a relocated section: invalid section index: 255 --- !ELF FileHeader: Class: ELFCLASS32 Data: ELFDATA2MSB Type: ET_REL Machine: EM_X86_64 Sections: - Name: .rela.stack_sizes Type: SHT_RELA Link: 0 Info: 0xFF Relocations: []