RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-18 18:42:46 +02:00
Code Issues Projects Releases Wiki Activity

[llvm-objdump][test] Improve testing of some switches #3

Browse Source 
This is the third commit in a series of patches to improve test coverage
of llvm-objdump. In this patch I have added a number of tests testing
various aspects of disassembly.

Reviewed by: MaskRay, grimar, rupprecht

Differential Revision: https://reviews.llvm.org/D62255

llvm-svn: 361489
This commit is contained in:
James Henderson 2019-05-23 12:30:39 +00:00
parent c9b586c47a
commit 528a93d833
14 changed files with 604 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
test/tools/llvm-objdump/X86/disasm-specific-funcs-mangled-name.test Normal file
View File

@ -0,0 +1,27 @@
## Show that the --disassemble-functions switch takes mangled names, not
## demangled names.
# RUN: yaml2obj %s -o %t.o
# RUN: llvm-objdump -d --disassemble-functions=_Z3foov %t.o | FileCheck %s
# RUN: llvm-objdump -d --disassemble-functions='foo()' %t.o | FileCheck %s --check-prefix=NOFOO
# RUN: llvm-objdump -d -C --disassemble-functions='foo()' %t.o | FileCheck %s --check-prefix=NOFOO
# RUN: llvm-objdump -d --disassemble-functions=foo %t.o | FileCheck %s --check-prefix=NOFOO
# CHECK: _Z3foov:
# NOFOO-NOT: foo
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: '90'
Symbols:
- Name: _Z3foov
Section: .text

44
test/tools/llvm-objdump/X86/disasm-specific-funcs.test
View File

@ -1,21 +1,25 @@
// RUN: yaml2obj -o %t.out %p/Inputs/simple-executable-x86_64.yaml
// RUN: llvm-objdump -d %t.out -disassemble-functions=main | FileCheck %s
## Show that the --diassemble-functions switch disassembles only the specified
## functions.
// CHECK: Disassembly of section .anothertext:
// CHECK-EMPTY:
// CHECK-NEXT: main:
// CHECK-NEXT: 10: 55 pushq %rbp
// CHECK-NEXT: 11: 48 89 e5 movq %rsp, %rbp
// CHECK-NEXT: 14: 48 83 ec 20 subq $32, %rsp
// CHECK-NEXT: 18: 48 8d 04 25 a8 00 00 00 leaq 168, %rax
// CHECK-NEXT: 20: c7 45 fc 00 00 00 00 movl $0, -4(%rbp)
// CHECK-NEXT: 27: 48 89 45 f0 movq %rax, -16(%rbp)
// CHECK-NEXT: 2b: 48 8b 45 f0 movq -16(%rbp), %rax
// CHECK-NEXT: 2f: 8b 08 movl (%rax), %ecx
// CHECK-NEXT: 31: 89 4d ec movl %ecx, -20(%rbp)
// CHECK-NEXT: 34: e8 c7 ff ff ff callq -57
// CHECK-NEXT: 39: 8b 4d ec movl -20(%rbp), %ecx
// CHECK-NEXT: 3c: 01 c1 addl %eax, %ecx
// CHECK-NEXT: 3e: 89 c8 movl %ecx, %eax
// CHECK-NEXT: 40: 48 83 c4 20 addq $32, %rsp
// CHECK-NEXT: 44: 5d popq %rbp
# RUN: yaml2obj -o %t.out %p/Inputs/simple-executable-x86_64.yaml
# RUN: llvm-objdump -d %t.out --disassemble-functions=main \
# RUN: | FileCheck %s --check-prefix=MAIN --implicit-check-not=foo --implicit-check-not=somedata
# RUN: llvm-objdump -d %t.out --disassemble-functions=main,foo \
# RUN: | FileCheck %s --check-prefixes=MAIN,FOO --implicit-check-not=somedata
# FOO: foo:
# MAIN: main:
## Unknown symbol name.
# RUN: llvm-objdump -d %t.out --disassemble-functions=baz \
# RUN: | FileCheck %s --implicit-check-not=Disassembly
## Data symbol.
# RUN: llvm-objdump -d %t.out --disassemble-functions=a \
# RUN: | FileCheck %s --implicit-check-not=Disassembly
## Data symbol + --disassemble-all.
# RUN: llvm-objdump -D %t.out --disassemble-functions=a \
# RUN: | FileCheck %s --check-prefix=DATA
# DATA: a:

20
test/tools/llvm-objdump/X86/disassemble-invalid-byte-sequences.test Normal file
View File

@ -0,0 +1,20 @@
## Show that llvm-objdump handles invalid byte sequences, and continues.
# RUN: yaml2obj %s -o %t.o
# RUN: llvm-objdump %t.o -d | FileCheck %s
# CHECK: 0000000000000000 .text:
# CHECK: 0: d9 e2 <unknown>
# CHECK-NEXT: 2: 90 nop
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: 'd9e290'

17
test/tools/llvm-objdump/X86/disassemble-long-instructions.test Normal file
View File

@ -0,0 +1,17 @@
## This test shows that llvm-objdump can disassemble a long instruction.
# RUN: yaml2obj %s -o %t.o
# RUN: llvm-objdump -d %t.o | FileCheck %s --strict-whitespace
# CHECK: 0: 66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:(%rax,%rax)
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: '6666666666662E0F1F840000000000' # 15-byte nop

99
test/tools/llvm-objdump/X86/elf-disassemble-dynamic-symbols.test Normal file
View File

@ -0,0 +1,99 @@
## Show the disassembly behaviour when dynamic symbols are present.
# RUN: yaml2obj %s -o %t
## Case 1: Both static and dynamic symbols are present. Only static
## symbols are displayed.
# RUN: llvm-objdump -d %t | FileCheck %s --check-prefixes=CHECK,STATIC
## Case 2: Only the dynamic symbols are present. These should be displayed, if
## they meet the necessary criteria.
# RUN: llvm-objcopy --strip-all %t %t2
# RUN: llvm-objdump -d %t2 | FileCheck %s --check-prefixes=CHECK,DYN
# CHECK: Disassembly of section .text:
# CHECK-EMPTY:
# STATIC-NEXT: 0000000000001000 .text:
# DYN-NEXT: 0000000000001000 only_dyn:
# CHECK-NEXT: 1000:
# CHECK-EMPTY:
# STATIC-NEXT: 0000000000001001 both_static:
# DYN-NEXT: 0000000000001001 both_dyn:
# CHECK-NEXT: 1001:
# STATIC-EMPTY:
# STATIC-NEXT: 0000000000001002 only_static:
# CHECK-NEXT: 1002:
# CHECK-NEXT: 1003:
# CHECK-NEXT: 1004:
# CHECK-NEXT: 1005:{{.*}}
# CHECK-NOT: {{.}}
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_DYN
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Address: 0x1000
Content: 909090909090
ProgramHeaders:
- Type: PT_LOAD
VAddr: 0x1000
Sections:
- Section: .text
Symbols:
- Name: both_static
Value: 0x1001
Section: .text
Binding: STB_GLOBAL
- Name: only_static
Value: 0x1002
Section: .text
Binding: STB_GLOBAL
DynamicSymbols:
- Name: only_dyn
Value: 0x1000
Section: .text
Size: 1
Type: STT_FUNC
Binding: STB_GLOBAL
- Name: both_dyn
Value: 0x1001
Section: .text
Size: 1
Type: STT_FUNC
Binding: STB_GLOBAL
## The rest of the dynamic symbols won't be used for various reasons.
## FIXME: the first two symbols here should be dumped.
## See https://bugs.llvm.org/show_bug.cgi?id=41947
- Name: not_func
Value: 0x1003
Section: .text
Type: STT_OBJECT
Binding: STB_GLOBAL
- Name: zero_sized
Value: 0x1004
Section: .text
Type: STT_FUNC
Binding: STB_GLOBAL
- Name: '' # No name
Value: 0x1005
Section: .text
Size: 1
Type: STT_FUNC
Binding: STB_GLOBAL
- Name: absolute
Value: 0x1005
Index: SHN_ABS
Size: 1
Type: STT_FUNC
Binding: STB_GLOBAL
- Name: undefined
Value: 0x1005
Index: SHN_UNDEF
Size: 1
Type: STT_FUNC
Binding: STB_GLOBAL

24
test/tools/llvm-objdump/X86/elf-disassemble-no-symtab.test Normal file
View File

@ -0,0 +1,24 @@
## Show that llvm-objdump can handle a missing symbol table when printing
## references and labels.
# RUN: yaml2obj %s -o %t
# RUN: llvm-objcopy -R .symtab %t
# RUN: llvm-objdump %t -d | FileCheck %s
# CHECK: Disassembly of section .text:
# CHECK-EMPTY:
# CHECK-NEXT: 0000000000004000 .text:
# CHECK-NEXT: 4000: e8 42 00 00 00 callq 66 <.text+0x47>
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Address: 0x4000
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: 'e842000000'

42
test/tools/llvm-objdump/X86/elf-disassemble-relocs.test Normal file
View File

@ -0,0 +1,42 @@
## Show that --disassemble + --reloc prints relocations inline and does not dump
## the relocation sections.
# RUN: yaml2obj %s -o %t.o
# RUN: llvm-objdump %t.o -d -r | FileCheck %s --implicit-check-not="RELOCATION RECORDS"
# CHECK: 0: e8 00 00 00 00 callq 0 <.text+0x5>
# CHECK-NEXT: 0000000000000001: R_X86_64_PC32 foo-4
# CHECK-NEXT: 0000000000000002: R_X86_64_NONE bar+8
# CHECK-NEXT: 5: e8 00 00 00 00 callq 0 <.text+0xa>
# CHECK-NEXT: 0000000000000006: R_X86_64_PLT32 foo+1
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: 'e800000000e800000000'
- Name: .rela.text
Type: SHT_RELA
Info: .text
Relocations:
- Offset: 1
Symbol: foo
Type: R_X86_64_PC32
Addend: -4
- Offset: 2
Symbol: bar
Type: R_X86_64_NONE
Addend: 8
- Offset: 6
Symbol: foo
Type: R_X86_64_PLT32
Addend: 1
Symbols:
- Name: foo
- Name: bar

54
test/tools/llvm-objdump/X86/elf-disassemble-symbol-labels-exec.test Normal file
View File

@ -0,0 +1,54 @@
## Show which labels are printed in disassembly of an executable.
# RUN: yaml2obj %s -o %t
# RUN: llvm-objdump %t -d | FileCheck %s --implicit-check-not=stt_section \
# RUN: --implicit-check-not=fourth \
# RUN: --implicit-check-not=absolute \
# RUN: --implicit-check-not=other
# CHECK: 0000000000004000 first:
# CHECK: 0000000000004001 second:
# CHECK: 0000000000004002 third:
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Address: 0x4000
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: '9090909090'
- Name: .text2
Type: SHT_PROGBITS
Address: 0x4004
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Size: 0
Symbols:
- Name: first # Shows, with second, that symbol sizes are not used to delineate functions.
Value: 0x4000
Section: .text
Size: 0x2
- Name: second
Value: 0x4001
Size: 0x1
Section: .text
- Name: third # Shows, with fourth, that first symbol is picked.
Value: 0x4002
Section: .text
- Name: fourth
Value: 0x4002
Section: .text
- Name: stt_section # Shows that STT_SECTION symbols are ignored even if no other symbol present.
Value: 0x4003
Type: STT_SECTION
Section: .text
- Name: absolute # Show that absolute symbols are ignored.
Value: 0x4004
Index: SHN_ABS
- Name: other # Show that symbols from other sections are ignored.
Value: 0x4004
Section: .text2

58
test/tools/llvm-objdump/X86/elf-disassemble-symbol-labels-rel.test Normal file
View File

@ -0,0 +1,58 @@
## Show which labels are printed in disassembly of a relocatable object.
# RUN: yaml2obj %s -o %t
# RUN: llvm-objdump %t -d | FileCheck %s --implicit-check-not=stt_section \
# RUN: --implicit-check-not=first \
# RUN: --implicit-check-not=second \
# RUN: --implicit-check-not=third \
# RUN: --implicit-check-not=fourth \
# RUN: --implicit-check-not=absolute \
# RUN: --implicit-check-not=other
# CHECK: Disassembly of section .text:
# CHECK: 0000000000000000 first:
# CHECK: 0000000000000001 second:
# CHECK: 0000000000000002 third:
# CHECK: Disassembly of section .text2:
# CHECK: 0000000000000004 other:
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: '909090909090'
- Name: .text2
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: '9090909090'
Symbols:
- Name: first
Value: 0
Section: .text
Size: 2
- Name: second # Shows, with first, that symbol sizes are not used to delineate functions.
Value: 1
Size: 1
Section: .text
- Name: third # Shows, with fourth, that first symbol is picked.
Value: 2
Section: .text
- Name: fourth
Value: 2
Section: .text
- Name: stt_section # Shows that STT_SECTION symbols are ignored even if no other symbol present.
Value: 3
Type: STT_SECTION
Section: .text
- Name: absolute # Show that absolute symbols are ignored.
Value: 4
Index: SHN_ABS
- Name: other # Show that symbols in other sections are ignored.
Value: 4
Section: .text2

101
test/tools/llvm-objdump/X86/elf-disassemble-symbol-references.yaml Normal file
View File

@ -0,0 +1,101 @@
## Show that references in disassembly are labelled with the correct symbol.
# RUN: yaml2obj %s --docnum=1 -o %t
# RUN: llvm-objdump %t -d | FileCheck %s --check-prefix=EXEC
# EXEC: Disassembly of section .text1:
# EXEC: 4000: e8 00 00 00 00 callq 0 <third>
# EXEC: Disassembly of section .text2:
# EXEC: 4005: e8 12 34 56 78 callq 2018915346 <fourth+0x78563412>
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_EXEC
Machine: EM_X86_64
Sections:
- Name: .text1
Type: SHT_PROGBITS
Address: 0x4000
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: 'e800000000' # Case 1: Referencing an address with a symbol.
- Name: .text2
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Address: 0x4005
Content: 'e812345678' # Case 2: Referencing an address without a symbol.
- Name: .text3
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Address: 0x400A
Symbols:
- Name: first
Section: .text1
Value: 0x4000
- Name: second
Section: .text1
Value: 0x4005
- Name: third
Section: .text2
Value: 0x4005
- Name: fourth
Section: .text3
Value: 0x400A
# RUN: yaml2obj %s --docnum=2 -o %t.o
# RUN: llvm-objdump %t.o -d | FileCheck %s --check-prefix=REL
# REL: Disassembly of section .text1:
# REL-EMPTY:
# REL-NEXT: 0000000000000000 .text1:
# REL-NEXT: 0: e8 00 00 00 00 callq 0 <.text1+0x5>
# REL-EMPTY:
# REL-NEXT: Disassembly of section .text2:
# REL-EMPTY:
# REL-NEXT: 0000000000000000 .text2:
# REL-NEXT: 0: e8 00 00 00 00 callq 0 <sym2>
# REL-EMPTY:
# REL-NEXT: Disassembly of section .text3:
# REL-EMPTY:
# REL-NEXT: 0000000000000000 .text3:
# REL-NEXT: 0: e8 00 00 00 00 callq 0 <.text3+0x5>
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text1
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: 'e800000000' # Case 1: Instruction is patched by a relocation.
- Name: .rela.text1
Type: SHT_RELA
Info: .text1
Relocations:
- Offset: 1
Type: R_X86_64_PC32
Symbol: sym3
- Name: .text2
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: 'e800000000' # Case 2: Referencing an address with a matching symbol in that section.
- Name: .text3
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: 'e800000000' # Case 3: Referencing an address without a matching symbol in that section.
- Name: .other
Type: SHT_PROGBITS
Symbols:
# Shouldn't be picked, despite matching value, as not in right section.
- Name: sym1
Section: .other
Value: 5
# Symbol in correct section, with right value should be picked for disassembly of .text2.
- Name: sym2
Section: .text2
Value: 5
# Symbol referenced by relocation could be picked for disassembly of .text1, but isn't.
- Name: sym3

50
test/tools/llvm-objdump/X86/elf-disassemble.test Normal file
View File

@ -0,0 +1,50 @@
## Show that disassembly is printed correctly, for only the desired sections.
# RUN: yaml2obj %s -o %t.o
# RUN: llvm-objdump %t.o --disassemble | FileCheck %s --implicit-check-not=Disassembly
# RUN: llvm-objdump %t.o --disassemble-all | FileCheck %s --check-prefixes=CHECK,ALL
# CHECK: Disassembly of section .executable:
# CHECK-EMPTY:
# CHECK-NEXT: 0000000000001000 .executable:
# CHECK-NEXT: 0: 90 nop
# ALL-EMPTY:
# ALL-NEXT: Disassembly of section .writable:
# ALL-EMPTY:
# ALL-NEXT: 0000000000002000 .writable:
# ALL-NEXT: 0: c3 retq
# ALL-EMPTY:
# ALL-NEXT: Disassembly of section .readonly:
# ALL-EMPTY:
# ALL-NEXT: 0000000000003000 .readonly:
# ALL-NEXT: 0: 01 00 addl %eax, (%rax)
# ALL-EMPTY:
# ALL-NEXT: Disassembly of section .nobits:
# ALL-EMPTY:
# ALL-NEXT: 0000000000004000 .nobits:
# ALL-NEXT: ...
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .executable
Type: SHT_PROGBITS
Address: 0x1000
Flags: [SHF_EXECINSTR]
Content: '90'
- Name: .writable
Type: SHT_PROGBITS
Address: 0x2000
Flags: [SHF_WRITE]
Content: 'c3'
- Name: .readonly
Type: SHT_PROGBITS
Address: 0x3000
Content: '0100'
- Name: .nobits
Type: SHT_NOBITS
Address: 0x4000
Size: 4

46
test/tools/llvm-objdump/X86/start-stop-address-relocatable-object.test Normal file
View File

@ -0,0 +1,46 @@
## Show how --start-address and --stop-address work in a relocatable object.
## They limit the disassembly to the relative offset ranges within sections.
# RUN: yaml2obj %s -o %t.o
# RUN: llvm-objdump -d %t.o --start-address=1 --stop-address=2 | FileCheck %s --check-prefix=COMMON
# RUN: llvm-objdump -d %t.o --start-address=1 | FileCheck %s --check-prefixes=START,COMMON
# RUN: llvm-objdump -d %t.o --stop-address=2 | FileCheck %s --check-prefixes=STOP,COMMON
# COMMON: Disassembly of section .text:
# COMMON-EMPTY:
# COMMON-NEXT: 0000000000000000 .text:
# STOP-NEXT: 0: 90 nop
# COMMON-NEXT: 1: 90 nop
# START-NEXT: 2: 90 nop
# COMMON-EMPTY:
# COMMON-NEXT: Disassembly of section .text2:
# COMMON-EMPTY:
# COMMON-NEXT: 0000000000000000 .text2:
# STOP-NEXT: 0: c3 retq
# COMMON-NEXT: 1: c3 retq
# START-NEXT: 2: c3 retq
# STOP-EMPTY:
# STOP-NEXT: Disassembly of section .text3:
# STOP-EMPTY:
# STOP-NEXT: 0000000000000000 .text3:
# STOP-NEXT: 0: cc int3
# COMMON-NOT: {{.}}
--- !ELF
FileHeader:
Class: ELFCLASS64
Data: ELFDATA2LSB
Type: ET_REL
Machine: EM_X86_64
Sections:
- Name: .text
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: '909090'
- Name: .text2
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: 'c3c3c3'
- Name: .text3
Type: SHT_PROGBITS
Flags: [SHF_ALLOC, SHF_EXECINSTR]
Content: 'cc'

46
test/tools/llvm-objdump/X86/start-stop-address.test
View File

@ -1,8 +1,12 @@
// RUN: yaml2obj -o %t.out %p/Inputs/simple-executable-x86_64.yaml
// RUN: llvm-objdump -d %t.out --start-address=0x18 --stop-address=0x2f | FileCheck %s
// RUN: llvm-objdump -d %t.out --start-address=0xc --stop-address=0x11 | FileCheck %s --check-prefix "CROSSSECTION"
// RUN: llvm-objdump -d %t.out --start-address=0x40 --stop-address=0x47 | FileCheck %s --check-prefix "CROSSDATA"
// RUN: llvm-objdump -d %t.out --start-address=0xc --stop-address=0x11 | FileCheck %s --check-prefix CROSSSECTION
// RUN: llvm-objdump -d %t.out --start-address=0x40 --stop-address=0x47 | FileCheck %s --check-prefix CROSSDATA
// RUN: llvm-objdump -d %t.out --start-address=0x40 | FileCheck %s --check-prefix START
// RUN: llvm-objdump -d %t.out --stop-address=0x11 | FileCheck %s --check-prefix STOP
// RUN: llvm-objdump -d %t.out --start-address=0xffffffff | FileCheck %s --check-prefix OUT-OF-RANGE
// CHECK-NOT: Disassembly
// CHECK: Disassembly of section .anothertext:
// CHECK-EMPTY:
// CHECK-NEXT: main:
@ -10,8 +14,9 @@
// CHECK-NEXT: 20: c7 45 fc 00 00 00 00 movl $0, -4(%rbp)
// CHECK-NEXT: 27: 48 89 45 f0 movq %rax, -16(%rbp)
// CHECK-NEXT: 2b: 48 8b 45 f0 movq -16(%rbp), %rax
// CHECK-NOT: 2f:
// CHECK-NOT: {{.}}
// CROSSECTION-NOT: Disassembly
// CROSSSECTION: Disassembly of section .text:
// CROSSSECTION-EMPTY:
// CROSSSECTION-NEXT: foo:
@ -22,12 +27,45 @@
// CROSSSECTION-EMPTY:
// CROSSSECTION-NEXT: main:
// CROSSSECTION-NEXT: 10: 55 pushq %rbp
// CROSSSECTION-NOT: 11:
// CROSSSECTION-NOT: {{.}}
// CROSSDATA-NOT: Disassembly
// CROSSDATA: Disassembly of section .anothertext:
// CROSSDATA: main:
// CROSSDATA: 40: 48 83 c4 20 addq $32, %rsp
// CROSSDATA: 44: 5d popq %rbp
// CROSSDATA-DAG: somedata:
// CROSSDATA-NEXT: 45: 74 65 te
// CROSSDATA-NOT: {{.}}
// START-NOT: Disassembly
// START: Disassembly of section .anothertext:
// START-EMPTY:
// START-NEXT: 0000000000000010 main:
// START-NEXT: 40: 48 83 c4 20 addq $32, %rsp
// START-NEXT: 44: 5d popq %rbp
// START-EMPTY:
// START-NEXT: 0000000000000045 somedata:
// START-NEXT: 45: 74 65 73 74 20 73 74 72 test str
// START-NEXT: 4d: 00 c3 ..
// STOP: Disassembly of section .text:
// STOP-EMPTY:
// STOP-NEXT: 0000000000000000 foo:
// STOP-NEXT: 0: 55 pushq %rbp
// STOP-NEXT: 1: 48 89 e5 movq %rsp, %rbp
// STOP-NEXT: 4: 8b 04 25 a8 00 00 00 movl 168, %eax
// STOP-NEXT: b: 5d popq %rbp
// STOP-NEXT: c: c3 retq
// STOP-NEXT: d: 0f 1f 00 nopl (%rax)
// STOP-EMPTY:
// STOP-NEXT: Disassembly of section .anothertext:
// STOP-EMPTY:
// STOP-NEXT: 0000000000000010 main:
// STOP-NEXT: 10: 55 pushq %rbp
// STOP-NOT: {{.}}
// OUT-OF-RANGE-NOT: Disassembly
// RUN: not llvm-objdump -d %t.out --start-address=0x40 --stop-address=0x3f 2>&1 | FileCheck %s --check-prefix ERRMSG
// ERRMSG: error: Start address should be less than stop address.

10
test/tools/llvm-objdump/X86/stripped-shared.test
View File

@ -1,10 +0,0 @@
// This test checks that dynamic symbols are used when disassembling elf files.
// RUN: llvm-objdump -d %p/Inputs/stripped-elf.so | FileCheck %s
# CHECK: .init
# CHECK: .plt
# CHECK: .text
# CHECK: func0
# CHECK: func1
# CHECK: func2
# CHECK: .fini