This is an archive of the discontinued LLVM Phabricator instance.

Differential D127538

[BOLT][TEST] Use double dash flags in tests
ClosedPublic

Authored by maksfb on Jun 10 2022, 2:24 PM.

Details

Reviewers
yota9
Amir
ayermolo
rafauler
zr33
nhuhuan
Commits
rGd648aa1b8e93: [BOLT][TEST] Use double dash flags in tests
Summary

Replace a single dash with a double dash for options that have more
than a single letter.

llvm-bolt-wrapper.py has special treatment for output options such as
"-o" and "-w" causing issues when a single dash is used, e.g. for
"-write-dwp". The wrapper can be fixed as well, but using a double dash
has other advantages as well.

Diff Detail

Event Timeline

maksfb created this revision.Jun 10 2022, 2:24 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 10 2022, 2:24 PM
Herald added subscribers: ormris, arphaman, steven_wu, hiraditya. · View Herald Transcript
maksfb requested review of this revision.Jun 10 2022, 2:24 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 10 2022, 2:24 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B169165: Diff 436049.Jun 10 2022, 2:30 PM
rafauler accepted this revision.Jun 10 2022, 4:13 PM

LGTM

This revision is now accepted and ready to land.Jun 10 2022, 4:13 PM
This revision was landed with ongoing or failed builds.Jun 10 2022, 4:29 PM
Closed by commit rGd648aa1b8e93: [BOLT][TEST] Use double dash flags in tests (authored by maksfb). · Explain Why
This revision was automatically updated to reflect the committed changes.
maksfb added a commit: rGd648aa1b8e93: [BOLT][TEST] Use double dash flags in tests.

Revision Contents

PathSize
bolt/
test/
AArch64/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
8 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
X86/
4 lines
4 lines
2 lines
4 lines
4 lines
6 lines
2 lines
8 lines
2 lines
2 lines
4 lines
6 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
6 lines
2 lines
2 lines
3 lines
5 lines
4 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
16 lines
2 lines
2 lines
7 lines
6 lines
15 lines
5 lines
2 lines
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
6 lines
2 lines
3 lines
4 lines
4 lines
2 lines
6 lines
6 lines
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
9 lines
4 lines
5 lines
6 lines
5 lines
6 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
runtime/
AArch64/
2 lines
2 lines
2 lines
2 lines
X86/
8 lines
9 lines
2 lines
4 lines
8 lines
4 lines
4 lines
2 lines
8 lines
8 lines
14 lines
6 lines
6 lines
2 lines
2 lines
3 lines
2 lines
2 lines
4 lines
4 lines
4 lines
6 lines
4 lines
4 lines
2 lines
2 lines
19 lines
2 lines
4 lines

Diff 436049

bolt/test/AArch64/asm-func-debug.test

# Verify that we update DW_TAG_compile_unit' ranges and .debug_aranges # Verify that we update DW_TAG_compile_unit' ranges and .debug_aranges
# for assembly function that doesn't have corresponding DIE. # for assembly function that doesn't have corresponding DIE.
# #
# The input test case foo() contains nops that we remove. # The input test case foo() contains nops that we remove.
RUN: %clang %cflags -no-pie -gdwarf-4 %p/../Inputs/asm_foo.s %p/../Inputs/asm_main.c -o %t.exe RUN: %clang %cflags -no-pie -gdwarf-4 %p/../Inputs/asm_foo.s %p/../Inputs/asm_main.c -o %t.exe
RUN: llvm-bolt %t.exe -o %t -update-debug-sections RUN: llvm-bolt %t.exe -o %t --update-debug-sections
RUN: llvm-dwarfdump -all %t | FileCheck %s RUN: llvm-dwarfdump -all %t | FileCheck %s
# Check ranges were created/updated for asm compile unit # Check ranges were created/updated for asm compile unit
CHECK: 0x0000000b: DW_TAG_compile_unit CHECK: 0x0000000b: DW_TAG_compile_unit
CHECK-NEXT: DW_AT_stmt_list (0x00000000) CHECK-NEXT: DW_AT_stmt_list (0x00000000)
CHECK-NEXT: DW_AT_low_pc (0x0000000000000000) CHECK-NEXT: DW_AT_low_pc (0x0000000000000000)
CHECK-NEXT: DW_AT_ranges CHECK-NEXT: DW_AT_ranges
CHECK-NEXT: [0x0000000000[[#%x,ADDR:]], CHECK-NEXT: [0x0000000000[[#%x,ADDR:]],
Show All 11 Lines

bolt/test/AArch64/constant-island-alignment.s

// This test checks that the constant island is aligned after BOLT tool. // This test checks that the constant island is aligned after BOLT tool.
// In case the nop before .Lci will be removed the pointer to exit function // In case the nop before .Lci will be removed the pointer to exit function
// won't be alinged and the test will fail. // won't be alinged and the test will fail.
# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags -fPIC -pie %t.o -o %t.exe -Wl,-q \ # RUN: %clang %cflags -fPIC -pie %t.o -o %t.exe -Wl,-q \
# RUN: -nostartfiles -nodefaultlibs -Wl,-z,notext # RUN: -nostartfiles -nodefaultlibs -Wl,-z,notext
# RUN: llvm-bolt %t.exe -o %t.bolt -use-old-text=0 -lite=0 -trap-old-code # RUN: llvm-bolt %t.exe -o %t.bolt --use-old-text=0 --lite=0 --trap-old-code
# RUN: llvm-objdump -d --disassemble-symbols='$d' %t.bolt | FileCheck %s # RUN: llvm-objdump -d --disassemble-symbols='$d' %t.bolt | FileCheck %s
.text .text
.align 4 .align 4
.global .global
.type dummy, %function .type dummy, %function
dummy: dummy:
add x0, x0, #1 add x0, x0, #1
Show All 21 Lines

bolt/test/AArch64/constant_island_pie_update.s

// This test checks that the constant island value is updated if it // This test checks that the constant island value is updated if it
// has dynamic relocation. // has dynamic relocation.
# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags -fPIC -pie %t.o -o %t.exe -Wl,-q -nostdlib -Wl,-z,notext # RUN: %clang %cflags -fPIC -pie %t.o -o %t.exe -Wl,-q -nostdlib -Wl,-z,notext
# RUN: llvm-bolt %t.exe -o %t.bolt -use-old-text=0 -lite=0 # RUN: llvm-bolt %t.exe -o %t.bolt --use-old-text=0 --lite=0
# RUN: llvm-objdump -j .text -dR %t.bolt | FileCheck %s # RUN: llvm-objdump -j .text -dR %t.bolt | FileCheck %s
# CHECK: R_AARCH64_RELATIVE *ABS*+0x[[#%x,ADDR:]] # CHECK: R_AARCH64_RELATIVE *ABS*+0x[[#%x,ADDR:]]
# CHECK: [[#ADDR]] <exitLocal>: # CHECK: [[#ADDR]] <exitLocal>:
# CHECK: {{.*}} <$d>: # CHECK: {{.*}} <$d>:
# CHECK-NEXT: {{.*}} .word 0x{{[0]+}}[[#ADDR]] # CHECK-NEXT: {{.*}} .word 0x{{[0]+}}[[#ADDR]]
# CHECK-NEXT: {{.*}} .word 0x00000000 # CHECK-NEXT: {{.*}} .word 0x00000000
Show All 23 Lines

bolt/test/AArch64/double_jump.cpp

// A contrived example to test the double jump removal peephole. // A contrived example to test the double jump removal peephole.
// RUN: %clang %cflags -O0 %s -o %t.exe // RUN: %clang %cflags -O0 %s -o %t.exe
// RUN: llvm-bolt %t.exe -o %t.bolt -peepholes=double-jumps | \ // RUN: llvm-bolt %t.exe -o %t.bolt --peepholes=double-jumps | \
// RUN: FileCheck %s -check-prefix=CHECKBOLT // RUN: FileCheck %s -check-prefix=CHECKBOLT
// RUN: llvm-objdump -d %t.bolt | FileCheck %s // RUN: llvm-objdump -d %t.bolt | FileCheck %s
// CHECKBOLT: BOLT-INFO: Peephole: 1 double jumps patched. // CHECKBOLT: BOLT-INFO: Peephole: 1 double jumps patched.
// CHECK: <_Z3foom>: // CHECK: <_Z3foom>:
// CHECK-NEXT: sub sp, sp, #16 // CHECK-NEXT: sub sp, sp, #16
// CHECK-NEXT: str x0, [sp, #8] // CHECK-NEXT: str x0, [sp, #8]
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

bolt/test/AArch64/ext-double-jump.s

# This test checks that remove double jumps pass works properly with # This test checks that remove double jumps pass works properly with
# non-local branches. # non-local branches.
# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown %s -o %t.o
# RUN: %clang %cflags -nostartfiles -nodefaultlibs %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -nostartfiles -nodefaultlibs %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -peepholes=double-jumps # RUN: llvm-bolt %t.exe -o %t.bolt --peepholes=double-jumps
.text .text
.align 4 .align 4
.global dummy1 .global dummy1
.type dummy1, %function .type dummy1, %function
dummy1: dummy1:
mov x2, x0 mov x2, x0
ret ret
Show All 17 Lines

bolt/test/AArch64/go_dwarf.test

# Check that the llvm-bolt update the dwarf information correctly in case: # Check that the llvm-bolt update the dwarf information correctly in case:
# - DW_AT_low_pc is nullified in case the DW_AT_ranges tag already exists. # - DW_AT_low_pc is nullified in case the DW_AT_ranges tag already exists.
# - DW_AT_high_pc is in the form of DW_FORM_addr. # - DW_AT_high_pc is in the form of DW_FORM_addr.
RUN: yaml2obj %p/Inputs/go_dwarf.yaml &> %t.exe RUN: yaml2obj %p/Inputs/go_dwarf.yaml &> %t.exe
RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# Check the original binary values. # Check the original binary values.
RUN: llvm-dwarfdump -debug-info %t.exe 2>&1 | \ RUN: llvm-dwarfdump -debug-info %t.exe 2>&1 | \
RUN: FileCheck %s -check-prefix=CHECKORIG RUN: FileCheck %s -check-prefix=CHECKORIG
CHECKORIG: DW_TAG_compile_unit CHECKORIG: DW_TAG_compile_unit
CHECKORIG-NEXT: DW_AT_producer CHECKORIG-NEXT: DW_AT_producer
CHECKORIG-NEXT: DW_AT_language CHECKORIG-NEXT: DW_AT_language
Show All 40 Lines

bolt/test/AArch64/plt-gnu-ld.test

// This test checks that the PLT symbols are properly recognized // This test checks that the PLT symbols are properly recognized
// by the BOLT tool. // by the BOLT tool.
// The test is using bfd linker, since it may add versioning string // The test is using bfd linker, since it may add versioning string
// to the symbol name e.g. memcpy@@GLIBC_2.17 // to the symbol name e.g. memcpy@@GLIBC_2.17
// RUN: yaml2obj %p/Inputs/plt-gnu-ld.yaml &> %t.exe // RUN: yaml2obj %p/Inputs/plt-gnu-ld.yaml &> %t.exe
// RUN: llvm-bolt %t.exe -o %t.bolt.exe -use-old-text=0 -lite=0 \ // RUN: llvm-bolt %t.exe -o %t.bolt.exe --use-old-text=0 --lite=0 \
// RUN: -print-cfg -print-only=main | FileCheck %s // RUN: --print-cfg --print-only=main | FileCheck %s
// CHECK: memcpy@PLT // CHECK: memcpy@PLT
// CHECK: memset@PLT // CHECK: memset@PLT
// CHECK: printf@PLT // CHECK: printf@PLT

bolt/test/AArch64/runtime-relocs.test

// This test checks dynamic relocations support for aarch64. // This test checks dynamic relocations support for aarch64.
RUN: yaml2obj %p/Inputs/rels-so.yaml &> %t.so RUN: yaml2obj %p/Inputs/rels-so.yaml &> %t.so
RUN: yaml2obj %p/Inputs/rels-exe.yaml &> %t.exe RUN: yaml2obj %p/Inputs/rels-exe.yaml &> %t.exe
RUN: llvm-bolt %t.so -o %t.bolt.so -use-old-text=0 -lite=0 RUN: llvm-bolt %t.so -o %t.bolt.so --use-old-text=0 --lite=0
RUN: llvm-bolt %t.exe -o %t.bolt.exe -use-old-text=0 -lite=0 RUN: llvm-bolt %t.exe -o %t.bolt.exe --use-old-text=0 --lite=0
// Check relocations in library: // Check relocations in library:
RUN: llvm-readelf -rW %t.bolt.so | FileCheck %s -check-prefix=CHECKLIB RUN: llvm-readelf -rW %t.bolt.so | FileCheck %s -check-prefix=CHECKLIB
CHECKLIB: {{.*}} R_AARCH64_GLOB_DAT {{.*}} a + 0 CHECKLIB: {{.*}} R_AARCH64_GLOB_DAT {{.*}} a + 0
CHECKLIB: {{.*}} R_AARCH64_TLSDESC {{.*}} t1 + 0 CHECKLIB: {{.*}} R_AARCH64_TLSDESC {{.*}} t1 + 0
CHECKLIB: {{.*}} R_AARCH64_ABS64 {{.*}} a + 0 CHECKLIB: {{.*}} R_AARCH64_ABS64 {{.*}} a + 0
// Check relocations in executable: // Check relocations in executable:
RUN: llvm-readelf -rW %t.bolt.exe | FileCheck %s -check-prefix=CHECKEXE RUN: llvm-readelf -rW %t.bolt.exe | FileCheck %s -check-prefix=CHECKEXE
CHECKEXE: {{.*}} R_AARCH64_TLS_TPREL64 {{.*}} t1 + 0 CHECKEXE: {{.*}} R_AARCH64_TLS_TPREL64 {{.*}} t1 + 0
CHECKEXE: {{.*}} R_AARCH64_COPY {{.*}} a + 0 CHECKEXE: {{.*}} R_AARCH64_COPY {{.*}} a + 0
CHECKEXE: {{.*}} R_AARCH64_JUMP_SLOT {{.*}} inc + 0 CHECKEXE: {{.*}} R_AARCH64_JUMP_SLOT {{.*}} inc + 0
// Check traditional TLS relocations R_AARCH64_TLS_DTPMOD64 and // Check traditional TLS relocations R_AARCH64_TLS_DTPMOD64 and
// R_AARCH64_TLS_DTPREL64 emitted correctly after bolt. Since these // R_AARCH64_TLS_DTPREL64 emitted correctly after bolt. Since these
// relocations are obsolete and clang and lld does not support them, // relocations are obsolete and clang and lld does not support them,
// the initial binary was built with gcc and ld with -mtls-dialect=trad flag. // the initial binary was built with gcc and ld with -mtls-dialect=trad flag.
RUN: yaml2obj %p/Inputs/tls-trad.yaml &> %t.trad.so RUN: yaml2obj %p/Inputs/tls-trad.yaml &> %t.trad.so
RUN: llvm-bolt %t.trad.so -o %t.trad.bolt.so -use-old-text=0 -lite=0 RUN: llvm-bolt %t.trad.so -o %t.trad.bolt.so --use-old-text=0 --lite=0
RUN: llvm-readelf -rW %t.trad.so | FileCheck %s -check-prefix=CHECKTRAD RUN: llvm-readelf -rW %t.trad.so | FileCheck %s -check-prefix=CHECKTRAD
CHECKTRAD: {{.*}} R_AARCH64_TLS_DTPMOD64 {{.*}} t1 + 0 CHECKTRAD: {{.*}} R_AARCH64_TLS_DTPMOD64 {{.*}} t1 + 0
CHECKTRAD: {{.*}} R_AARCH64_TLS_DTPREL64 {{.*}} t1 + 0 CHECKTRAD: {{.*}} R_AARCH64_TLS_DTPREL64 {{.*}} t1 + 0
// The ld linker emits R_AARCH64_TLSDESC to .rela.plt section, check that // The ld linker emits R_AARCH64_TLSDESC to .rela.plt section, check that
// it is emitted correctly. // it is emitted correctly.
RUN: yaml2obj %p/Inputs/tls-ld.yaml &> %t.ld.so RUN: yaml2obj %p/Inputs/tls-ld.yaml &> %t.ld.so
RUN: llvm-bolt %t.ld.so -o %t.ld.bolt.so -use-old-text=0 -lite=0 RUN: llvm-bolt %t.ld.so -o %t.ld.bolt.so --use-old-text=0 --lite=0
RUN: llvm-readelf -rW %t.ld.bolt.so | FileCheck %s -check-prefix=CHECKLD RUN: llvm-readelf -rW %t.ld.bolt.so | FileCheck %s -check-prefix=CHECKLD
CHECKLD: {{.*}} R_AARCH64_TLSDESC {{.*}} t1 + 0 CHECKLD: {{.*}} R_AARCH64_TLSDESC {{.*}} t1 + 0

bolt/test/AArch64/skip-got-rel.test

// This test checks that the binary with relaxed ADRP+LDR instructions is // This test checks that the binary with relaxed ADRP+LDR instructions is
// processed normally with BOLT and the ADR instruction address is recognized // processed normally with BOLT and the ADR instruction address is recognized
// normally. // normally.
RUN: yaml2obj %p/Inputs/skip-got-rel.yaml &> %t.exe RUN: yaml2obj %p/Inputs/skip-got-rel.yaml &> %t.exe
RUN: llvm-bolt %t.exe -o /dev/null -print-cfg -print-only=_start | FileCheck %s RUN: llvm-bolt %t.exe -o /dev/null --print-cfg --print-only=_start | FileCheck %s
CHECK: adr x0, foo2 CHECK: adr x0, foo2

bolt/test/AArch64/tailcall_traps.s

## Tests the peephole that adds trap instructions following indirect tail calls. ## Tests the peephole that adds trap instructions following indirect tail calls.
# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -peepholes=tailcall-traps \ # RUN: llvm-bolt %t.exe -o %t.bolt --peepholes=tailcall-traps \
# RUN: -print-peepholes -funcs=foo,bar 2>&1 | FileCheck %s # RUN: --print-peepholes --funcs=foo,bar 2>&1 | FileCheck %s
# CHECK: Binary Function "foo" # CHECK: Binary Function "foo"
# CHECK: br x0 # TAILCALL # CHECK: br x0 # TAILCALL
# CHECK-NEXT: brk #0x1 # CHECK-NEXT: brk #0x1
# CHECK: End of Function "foo" # CHECK: End of Function "foo"
# CHECK: Binary Function "bar" # CHECK: Binary Function "bar"
# CHECK: b foo # TAILCALL # CHECK: b foo # TAILCALL
Show All 22 Lines

bolt/test/AArch64/text-data.c

// This test checks that the data object located in text section // This test checks that the data object located in text section
// is properly emitted in the new section. // is properly emitted in the new section.
// RUN: %clang %cflags %s -o %t.exe -Wl,-q // RUN: %clang %cflags %s -o %t.exe -Wl,-q
// RUN: llvm-bolt %t.exe -o %t.bolt -lite=0 -use-old-text=0 // RUN: llvm-bolt %t.exe -o %t.bolt --lite=0 --use-old-text=0
// RUN: llvm-objdump -j .text -d --disassemble-symbols=arr %t.bolt | \ // RUN: llvm-objdump -j .text -d --disassemble-symbols=arr %t.bolt | \
// RUN: FileCheck %s // RUN: FileCheck %s
// CHECK: {{.*}} <arr>: // CHECK: {{.*}} <arr>:
extern void exit(int); extern void exit(int);
typedef void (*FooPtr)(); typedef void (*FooPtr)();
Show All 9 Lines

bolt/test/AArch64/unmarked-data.test

// This test checks that multiple data objects in text of which only first is marked get disassembled properly // This test checks that multiple data objects in text of which only first is marked get disassembled properly
// RUN: yaml2obj %S/Inputs/unmarked-data.yaml -o %t.exe // RUN: yaml2obj %S/Inputs/unmarked-data.yaml -o %t.exe
// RUN: llvm-bolt %t.exe -o %t.bolt -lite=0 -use-old-text=0 2>&1 | FileCheck %s // RUN: llvm-bolt %t.exe -o %t.bolt --lite=0 --use-old-text=0 2>&1 | FileCheck %s
// CHECK-NOT: BOLT-WARNING // CHECK-NOT: BOLT-WARNING
// RUN: llvm-objdump -j .text -d --disassemble-symbols=first,second %t.bolt | FileCheck %s -check-prefix=CHECK-SYMBOL // RUN: llvm-objdump -j .text -d --disassemble-symbols=first,second %t.bolt | FileCheck %s -check-prefix=CHECK-SYMBOL
// CHECK-SYMBOL: <first>: // CHECK-SYMBOL: <first>:
// CHECK-SYMBOL: <second>: // CHECK-SYMBOL: <second>:
// YAML is based in the following assembly: // YAML is based in the following assembly:
.equ val, 0x070b0f03 // we use constant that is not a valid instruction so that it can't be silently dissassembled .equ val, 0x070b0f03 // we use constant that is not a valid instruction so that it can't be silently dissassembled
Show All 22 Lines

bolt/test/AArch64/update-debug-reloc.test

# Verify that bolt correctly handle AArch64 relocations in case of enabling # Verify that bolt correctly handle AArch64 relocations in case of enabling
# update-debug-sections option. # update-debug-sections option.
RUN: %clang %cflags -g %p/../Inputs/asm_foo.s %p/../Inputs/asm_main.c -o %t.exe RUN: %clang %cflags -g %p/../Inputs/asm_foo.s %p/../Inputs/asm_main.c -o %t.exe
RUN: llvm-bolt %t.exe -o %t -update-debug-sections RUN: llvm-bolt %t.exe -o %t --update-debug-sections
CHECK: BOLT-INFO: Target architecture: aarch64 CHECK: BOLT-INFO: Target architecture: aarch64
CHECK-NOT: Reloc num: 10 CHECK-NOT: Reloc num: 10
CHECK-NOT: unsupported relocation type CHECK-NOT: unsupported relocation type

bolt/test/R_ABS.pic.lld.cpp

/* /*
* Check that we don't assert on a duplicate static relocation added by lld * Check that we don't assert on a duplicate static relocation added by lld
* against _Z6myfuncv. The same address has a dynamic relocation against it. * against _Z6myfuncv. The same address has a dynamic relocation against it.
* *
* RUN: %clang %cflags -fPIC -shared %s -o %t.so -Wl,-q -fuse-ld=lld * RUN: %clang %cflags -fPIC -shared %s -o %t.so -Wl,-q -fuse-ld=lld
* RUN: llvm-bolt %t.so -o %t.so.bolt -relocs * RUN: llvm-bolt %t.so -o %t.so.bolt --relocs
*/ */
unsigned long long myfunc(); unsigned long long myfunc();
unsigned long long (*myglobal)() = myfunc; unsigned long long (*myglobal)() = myfunc;
unsigned long long myfunc() { unsigned long long myfunc() {
return reinterpret_cast<unsigned long long>(myglobal); return reinterpret_cast<unsigned long long>(myglobal);
} }

bolt/test/X86/addr32.s

# Check that we don't accidentally strip addr32 prefix # Check that we don't accidentally strip addr32 prefix
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: ld.lld %t.o -o %t.exe -nostdlib # RUN: ld.lld %t.o -o %t.exe -nostdlib
# RUN: llvm-objdump -d %t.exe | FileCheck %s # RUN: llvm-objdump -d %t.exe | FileCheck %s
# RUN: llvm-bolt %t.exe -o %t.out -lite=0 -x86-strip-redundant-address-size=false # RUN: llvm-bolt %t.exe -o %t.out --lite=0 --x86-strip-redundant-address-size=false
# RUN: llvm-objdump -d %t.out | FileCheck %s # RUN: llvm-objdump -d %t.out | FileCheck %s
# CHECK: 67 e8 {{.*}} addr32 callq {{.*}} <foo> # CHECK: 67 e8 {{.*}} addr32 callq {{.*}} <foo>
# RUN: llvm-bolt %t.exe -o %t.out -lite=0 -x86-strip-redundant-address-size=true # RUN: llvm-bolt %t.exe -o %t.out --lite=0 --x86-strip-redundant-address-size=true
# remove test name from objdump output, to only search for addr32 in disassembly # remove test name from objdump output, to only search for addr32 in disassembly
# RUN: llvm-objdump -d %t.out | grep -v addr32.s | FileCheck %s --check-prefix=CHECK-STRIP # RUN: llvm-objdump -d %t.out | grep -v addr32.s | FileCheck %s --check-prefix=CHECK-STRIP
# CHECK-STRIP-NOT: addr32 # CHECK-STRIP-NOT: addr32
.globl _start .globl _start
.type _start, @function .type _start, @function
_start: _start:
.code64 .code64
addr32 callq foo addr32 callq foo
ret ret
.size _start, .-_start .size _start, .-_start
.globl foo .globl foo
.type foo, @function .type foo, @function
foo: foo:
ud2 ud2

bolt/test/X86/asm-dump.c

/** /**
* Test for asm-dump functionality. * Test for asm-dump functionality.
* *
* REQUIRES: system-linux,bolt-runtime * REQUIRES: system-linux,bolt-runtime
* *
* Compile the source * Compile the source
* RUN: %clang -fPIC %s -o %t.exe -Wl,-q * RUN: %clang -fPIC %s -o %t.exe -Wl,-q
* *
* Profile collection: instrument the binary * Profile collection: instrument the binary
* RUN: llvm-bolt %t.exe -instrument -instrumentation-file=%t.fdata -o %t.instr * RUN: llvm-bolt %t.exe --instrument --instrumentation-file=%t.fdata -o %t.instr
* *
* Profile collection: run instrumented binary (and capture output) * Profile collection: run instrumented binary (and capture output)
* RUN: %t.instr > %t.result * RUN: %t.instr > %t.result
* *
* Run BOLT with asm-dump * Run BOLT with asm-dump
* RUN: llvm-bolt %t.exe -p %t.fdata -funcs=main -asm-dump=%t -o /dev/null \ * RUN: llvm-bolt %t.exe -p %t.fdata --funcs=main --asm-dump=%t -o /dev/null \
* RUN: | FileCheck %s --check-prefix=CHECK-BOLT * RUN: | FileCheck %s --check-prefix=CHECK-BOLT
* *
* Check asm file contents * Check asm file contents
* RUN: cat %t/main.s | FileCheck %s --check-prefix=CHECK-FILE * RUN: cat %t/main.s | FileCheck %s --check-prefix=CHECK-FILE
* *
* Now check if asm-dump file can be consumed by BOLT infra * Now check if asm-dump file can be consumed by BOLT infra
* Strip dot from compiler-local symbols: * Strip dot from compiler-local symbols:
* RUN: sed -i 's/\.L/L/g' %t/main.s * RUN: sed -i 's/\.L/L/g' %t/main.s
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

bolt/test/X86/asm-func-debug.test

# Verify that we update DW_TAG_compile_unit' ranges and .debug_aranges # Verify that we update DW_TAG_compile_unit' ranges and .debug_aranges
# for assembly function that doesn't have corresponding DIE. # for assembly function that doesn't have corresponding DIE.
# #
# The input test case foo() contains nops that we remove. # The input test case foo() contains nops that we remove.
RUN: %clang -gdwarf-4 %cflags -no-pie %p/../Inputs/asm_foo.s %p/../Inputs/asm_main.c -o %t.exe RUN: %clang -gdwarf-4 %cflags -no-pie %p/../Inputs/asm_foo.s %p/../Inputs/asm_main.c -o %t.exe
RUN: llvm-bolt %t.exe -o %t -update-debug-sections RUN: llvm-bolt %t.exe -o %t --update-debug-sections
RUN: llvm-dwarfdump -all %t | FileCheck %s RUN: llvm-dwarfdump -all %t | FileCheck %s
# Check ranges were created/updated for asm compile unit # Check ranges were created/updated for asm compile unit
CHECK: 0x0000000b: DW_TAG_compile_unit CHECK: 0x0000000b: DW_TAG_compile_unit
CHECK-NEXT: DW_AT_stmt_list (0x00000000) CHECK-NEXT: DW_AT_stmt_list (0x00000000)
CHECK-NEXT: DW_AT_low_pc (0x0000000000000000) CHECK-NEXT: DW_AT_low_pc (0x0000000000000000)
CHECK-NEXT: DW_AT_ranges CHECK-NEXT: DW_AT_ranges
CHECK-NEXT: [0x0000000000[[#%x,ADDR:]], CHECK-NEXT: [0x0000000000[[#%x,ADDR:]],
Show All 11 Lines

bolt/test/X86/avx512-trap.test

# Check that BOLT inserts trap instruction at entry to functions that use AVX-512. # Check that BOLT inserts trap instruction at entry to functions that use AVX-512.
# Check that AVX-512 instruction is updated correctly when -trap-avx512=0 is passed. # Check that AVX-512 instruction is updated correctly when -trap-avx512=0 is passed.
RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-unknown -o %t.o \ RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-unknown -o %t.o \
RUN: %S/Inputs/avx512.s RUN: %S/Inputs/avx512.s
RUN: ld.lld %t.o -o %t -q RUN: ld.lld %t.o -o %t -q
RUN: llvm-objdump -d --disassemble-symbols=use_avx512 %t | \ RUN: llvm-objdump -d --disassemble-symbols=use_avx512 %t | \
RUN: FileCheck %s --check-prefix=CHECK-DIS-NO-TRAP RUN: FileCheck %s --check-prefix=CHECK-DIS-NO-TRAP
RUN: llvm-bolt %t -trap-avx512=1 -o %t.bolt -lite=0 2>&1 | FileCheck %s RUN: llvm-bolt %t --trap-avx512=1 -o %t.bolt --lite=0 2>&1 | FileCheck %s
RUN: llvm-objdump -d --disassemble-symbols=use_avx512 %t.bolt | \ RUN: llvm-objdump -d --disassemble-symbols=use_avx512 %t.bolt | \
RUN: FileCheck %s --check-prefix=CHECK-DIS RUN: FileCheck %s --check-prefix=CHECK-DIS
RUN: llvm-bolt %t -trap-avx512=0 -o %t.bolt -lite=0 RUN: llvm-bolt %t --trap-avx512=0 -o %t.bolt --lite=0
RUN: llvm-objdump -d --disassemble-symbols=use_avx512 %t.bolt | \ RUN: llvm-objdump -d --disassemble-symbols=use_avx512 %t.bolt | \
RUN: FileCheck %s --check-prefix=CHECK-DIS-NO-TRAP RUN: FileCheck %s --check-prefix=CHECK-DIS-NO-TRAP
CHECK: BOLT-WARNING: 1 function will trap on entry CHECK: BOLT-WARNING: 1 function will trap on entry
# Check that we have two ud2 instructions - one per entry. # Check that we have two ud2 instructions - one per entry.
CHECK-DIS: use_avx512 CHECK-DIS: use_avx512
CHECK-DIS-NEXT: ud2 CHECK-DIS-NEXT: ud2
CHECK-DIS-NEXT: ud2 CHECK-DIS-NEXT: ud2
# Check that we generate correct AVX-512 # Check that we generate correct AVX-512
CHECK-DIS-NO-TRAP: use_avx512 CHECK-DIS-NO-TRAP: use_avx512
CHECK-DIS-NO-TRAP: 62 e2 f5 70 2c da vscalefpd CHECK-DIS-NO-TRAP: 62 e2 f5 70 2c da vscalefpd

bolt/test/X86/bb-with-two-tail-calls.s

# This reproduces a bug with dynostats when trying to compute branch stats # This reproduces a bug with dynostats when trying to compute branch stats
# at a block with two tails calls (one conditional and one unconditional). # at a block with two tails calls (one conditional and one unconditional).
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib
# RUN: llvm-bolt %t.exe -o %t.out -data %t.fdata -lite=0 -dyno-stats \ # RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata --lite=0 --dyno-stats \
# RUN: -print-sctc -print-only=_start 2>&1 | FileCheck %s # RUN: --print-sctc --print-only=_start 2>&1 | FileCheck %s
# CHECK-NOT: Assertion `BranchInfo.size() == 2 && "could only be called for blocks with 2 successors"' failed. # CHECK-NOT: Assertion `BranchInfo.size() == 2 && "could only be called for blocks with 2 successors"' failed.
# Two tail calls in the same basic block after SCTC: # Two tail calls in the same basic block after SCTC:
# CHECK: {{.*}}: ja {{.*}} # TAILCALL # CTCTakenCount: {{.*}} # CHECK: {{.*}}: ja {{.*}} # TAILCALL # CTCTakenCount: {{.*}}
# CHECK-NEXT: {{.*}}: jmp {{.*}} # TAILCALL # CHECK-NEXT: {{.*}}: jmp {{.*}} # TAILCALL
.globl _start .globl _start
_start: _start:
je x je x
Show All 14 Lines

bolt/test/X86/block-reordering.test

# Tests whether llvm-bolt is able to reorder blocks and fix branches # Tests whether llvm-bolt is able to reorder blocks and fix branches
# according to the new function layout. # according to the new function layout.
RUN: yaml2obj %p/Inputs/blarge.yaml &> %t.exe RUN: yaml2obj %p/Inputs/blarge.yaml &> %t.exe
RUN: llvm-bolt %t.exe -o /dev/null -data %p/Inputs/blarge.fdata \ RUN: llvm-bolt %t.exe -o /dev/null --data %p/Inputs/blarge.fdata \
RUN: -reorder-blocks=normal -print-finalized 2>&1 | FileCheck %s \ RUN: --reorder-blocks=normal --print-finalized 2>&1 | FileCheck %s \
RUN: -check-prefix=CHECK RUN: --check-prefix=CHECK
CHECK: Binary Function "usqrt" CHECK: Binary Function "usqrt"
CHECK: BB Layout : .LBB{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .LFT{{.*}}, .LFT{{.*}} CHECK: BB Layout : .LBB{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .LFT{{.*}}, .LFT{{.*}}
CHECK: .LBB{{.*}} CHECK: .LBB{{.*}}
CHECK: Exec Count : 199 CHECK: Exec Count : 199
CHECK: {{.*}}: movl $0x20, %r8d CHECK: {{.*}}: movl $0x20, %r8d
CHECK: {{.*}}: xorl %eax, %eax CHECK: {{.*}}: xorl %eax, %eax
CHECK: {{.*}}: xorl %edx, %edx CHECK: {{.*}}: xorl %edx, %edx
Show All 34 Lines

bolt/test/X86/branch-data.test

# Checks that llvm-bolt is able to read data generated by perf2bolt and update # Checks that llvm-bolt is able to read data generated by perf2bolt and update
# the CFG edges accordingly with absolute number of branches and mispredictions. # the CFG edges accordingly with absolute number of branches and mispredictions.
# Also checks that llvm-bolt disassembler and CFG builder is working properly. # Also checks that llvm-bolt disassembler and CFG builder is working properly.
RUN: yaml2obj %p/Inputs/blarge.yaml &> %t.exe RUN: yaml2obj %p/Inputs/blarge.yaml &> %t.exe
RUN: llvm-bolt %t.exe -o /dev/null -data %p/Inputs/blarge.fdata -print-cfg RUN: llvm-bolt %t.exe -o /dev/null --data %p/Inputs/blarge.fdata --print-cfg
CHECK: Binary Function "usqrt" CHECK: Binary Function "usqrt"
CHECK: State : CFG constructed CHECK: State : CFG constructed
CHECK: Address : 0x401170 CHECK: Address : 0x401170
CHECK: Size : 0x43 CHECK: Size : 0x43
CHECK: MaxSize : 0x50 CHECK: MaxSize : 0x50
CHECK: Offset : 0x1170 CHECK: Offset : 0x1170
CHECK: Section : .text CHECK: Section : .text
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

bolt/test/X86/bug-reorder-bb-jrcxz.s

# Test performs a BB reordering with unsupported # Test performs a BB reordering with unsupported
# instruction jrcxz. Reordering works correctly with the # instruction jrcxz. Reordering works correctly with the
# follow options: None, Normal or Reverse. Other strategies # follow options: None, Normal or Reverse. Other strategies
# are completed with Assertion `isIntN(Size * 8 + 1, Value). # are completed with Assertion `isIntN(Size * 8 + 1, Value).
# The cause is the distance between BB where one contains # The cause is the distance between BB where one contains
# jrcxz instruction. # jrcxz instruction.
# Example: OpenSSL # Example: OpenSSL
# https://github.com/openssl/openssl/blob/master/crypto/bn/asm/x86_64-mont5.pl#L3319 # https://github.com/openssl/openssl/blob/master/crypto/bn/asm/x86_64-mont5.pl#L3319
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: %clang %cflags %t.o -falign-labels -march=native -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -falign-labels -march=native -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolted -data %t.fdata \ # RUN: llvm-bolt %t.exe -o %t.bolted --data %t.fdata \
# RUN: -reorder-blocks=ext-tsp -reorder-functions=hfsort \ # RUN: --reorder-blocks=ext-tsp --reorder-functions=hfsort \
# RUN: -split-functions=2 -split-all-cold -split-eh -dyno-stats \ # RUN: --split-functions=2 --split-all-cold --split-eh --dyno-stats \
# RUN: -print-finalized 2>&1 | FileCheck %s # RUN: --print-finalized 2>&1 | FileCheck %s
# CHECK-NOT: value of -2105 is too large for field of 1 byte. # CHECK-NOT: value of -2105 is too large for field of 1 byte.
.text .text
.section .text.startup,"ax",@progbits .section .text.startup,"ax",@progbits
.p2align 5,,31 .p2align 5,,31
.globl main .globl main
.type main, @function .type main, @function
▲ Show 20 Lines • Show All 612 Lines • Show Last 20 Lines

bolt/test/X86/cfi-expr-rewrite.s

# Check that llvm-bolt is able to parse DWARF expressions in CFI instructions, # Check that llvm-bolt is able to parse DWARF expressions in CFI instructions,
# store them in memory and correctly write them back to the output binary. # store them in memory and correctly write them back to the output binary.
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: %clang %cflags %t.o -o %t.exe # RUN: %clang %cflags %t.o -o %t.exe
# RUN: llvm-bolt %t.exe -o %t && llvm-dwarfdump -eh-frame %t | FileCheck %s # RUN: llvm-bolt %t.exe -o %t && llvm-dwarfdump --eh-frame %t | FileCheck %s
# #
# CHECK: DW_CFA_advance_loc: 5 # CHECK: DW_CFA_advance_loc: 5
# CHECK-NEXT: DW_CFA_def_cfa: R10 +0 # CHECK-NEXT: DW_CFA_def_cfa: R10 +0
# CHECK-NEXT: DW_CFA_advance_loc: 9 # CHECK-NEXT: DW_CFA_advance_loc: 9
# CHECK-NEXT: DW_CFA_expression: RBP DW_OP_breg6 RBP+0 # CHECK-NEXT: DW_CFA_expression: RBP DW_OP_breg6 RBP+0
# CHECK-NEXT: DW_CFA_advance_loc: 5 # CHECK-NEXT: DW_CFA_advance_loc: 5
# CHECK-NEXT: DW_CFA_def_cfa_expression: DW_OP_breg6 RBP-8, DW_OP_deref # CHECK-NEXT: DW_CFA_def_cfa_expression: DW_OP_breg6 RBP-8, DW_OP_deref
# CHECK-NEXT: DW_CFA_advance_loc2: 3174 # CHECK-NEXT: DW_CFA_advance_loc2: 3174
▲ Show 20 Lines • Show All 681 Lines • Show Last 20 Lines

bolt/test/X86/cfi-instrs-count.s

# Check that llvm-bolt is able to read a file with DWARF Exception CFI # Check that llvm-bolt is able to read a file with DWARF Exception CFI
# information and annotate this into a disassembled function. # information and annotate this into a disassembled function.
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: %clang %cflags %t.o -o %t.exe # RUN: %clang %cflags %t.o -o %t.exe
# RUN: llvm-bolt %t.exe -o /dev/null -print-cfg 2>&1 | FileCheck %s # RUN: llvm-bolt %t.exe -o /dev/null --print-cfg 2>&1 | FileCheck %s
# #
# CHECK: Binary Function "_Z7catchitv" after building cfg { # CHECK: Binary Function "_Z7catchitv" after building cfg {
# CHECK: CFI Instrs : 6 # CHECK: CFI Instrs : 6
# CHECK: } # CHECK: }
# CHECK: DWARF CFI Instructions: # CHECK: DWARF CFI Instructions:
# CHECK: 0: OpDefCfaOffset # CHECK: 0: OpDefCfaOffset
# CHECK: 1: OpOffset # CHECK: 1: OpOffset
# CHECK: 2: OpDefCfaRegister # CHECK: 2: OpDefCfaRegister
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

bolt/test/X86/cfi-instrs-reordered.s

# Check that llvm-bolt is able to read a file with DWARF Exception CFI # Check that llvm-bolt is able to read a file with DWARF Exception CFI
# information and fix CFI information after reordering. # information and fix CFI information after reordering.
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clangxx %cflags %t.o -o %t.exe # RUN: %clangxx %cflags %t.o -o %t.exe
# RUN: llvm-bolt %t.exe -o %t -reorder-blocks=cache -print-after-lowering \ # RUN: llvm-bolt %t.exe -o %t --reorder-blocks=cache --print-after-lowering \
# RUN: -print-only=_Z10SolveCubicddddPiPd 2>&1 | FileCheck %s # RUN: --print-only=_Z10SolveCubicddddPiPd 2>&1 | FileCheck %s
# #
# Entry BB # Entry BB
# CHECK: divsd %xmm0, %xmm1 # CHECK: divsd %xmm0, %xmm1
# CHECK: pushq %rbx # CHECK: pushq %rbx
# CHECK: !CFI $0 ; OpDefCfaOffset # CHECK: !CFI $0 ; OpDefCfaOffset
# CHECK: !CFI $1 ; OpOffset # CHECK: !CFI $1 ; OpOffset
# CHECK: movq %rsi, %rbx # CHECK: movq %rsi, %rbx
# CHECK: subq $0x70, %rsp # CHECK: subq $0x70, %rsp
▲ Show 20 Lines • Show All 994 Lines • Show Last 20 Lines

bolt/test/X86/cmov-conversion.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib
# RUN: llvm-bolt %t.exe -data %t.fdata -o %t -lite=0 -v=2 \ # RUN: llvm-bolt %t.exe --data %t.fdata -o %t --lite=0 -v=2 \
# RUN: -cmov-conversion -cmov-conversion-misprediction-threshold=-1 \ # RUN: --cmov-conversion --cmov-conversion-misprediction-threshold=-1 \
# RUN: -cmov-conversion-bias-threshold=-1 -print-all | FileCheck %s # RUN: --cmov-conversion-bias-threshold=-1 --print-all | FileCheck %s
# CHECK: BOLT-INFO: CMOVConversion: CmovInHotPath, converted static 1/1 # CHECK: BOLT-INFO: CMOVConversion: CmovInHotPath, converted static 1/1
# CHECK: BOLT-INFO: CMOVConversion: CmovNotInHotPath, converted static 1/1 # CHECK: BOLT-INFO: CMOVConversion: CmovNotInHotPath, converted static 1/1
# CHECK: BOLT-INFO: CMOVConversion: MaxIndex, converted static 1/1 # CHECK: BOLT-INFO: CMOVConversion: MaxIndex, converted static 1/1
# CHECK: BOLT-INFO: CMOVConversion: MaxIndex_unpredictable, converted static 1/1 # CHECK: BOLT-INFO: CMOVConversion: MaxIndex_unpredictable, converted static 1/1
# CHECK: BOLT-INFO: CMOVConversion: MaxValue, converted static 1/1 # CHECK: BOLT-INFO: CMOVConversion: MaxValue, converted static 1/1
# CHECK: BOLT-INFO: CMOVConversion: BinarySearch, converted static 0/0 # CHECK: BOLT-INFO: CMOVConversion: BinarySearch, converted static 0/0
# CHECK: BOLT-INFO: CMOVConversion: Transform, converted static 0/0 # CHECK: BOLT-INFO: CMOVConversion: Transform, converted static 0/0
# CHECK: BOLT-INFO: CMOVConversion: test_cmov_memoperand, converted static 0/0 # CHECK: BOLT-INFO: CMOVConversion: test_cmov_memoperand, converted static 0/0
▲ Show 20 Lines • Show All 550 Lines • Show Last 20 Lines

bolt/test/X86/ctc-and-unreachable.test

# Check that we don't fail processing a function with conditional tail call and # Check that we don't fail processing a function with conditional tail call and
# a fall-through to a next function (result of builtin_unreachable()). # a fall-through to a next function (result of builtin_unreachable()).
RUN: %clang %cflags %p/Inputs/ctc_and_unreachable.s -o %t.exe -Wl,-q RUN: %clang %cflags %p/Inputs/ctc_and_unreachable.s -o %t.exe -Wl,-q
RUN: llvm-bolt %t.exe -o %t -print-after-lowering -print-only=foo 2>&1 | FileCheck %s RUN: llvm-bolt %t.exe -o %t --print-after-lowering --print-only=foo 2>&1 | FileCheck %s
CHECK: Binary Function "foo" CHECK: Binary Function "foo"
CHECK: cmpq $0x1, %rdi CHECK: cmpq $0x1, %rdi
CHECK: je bar # TAILCALL CHECK: je bar # TAILCALL
CHECK: retq CHECK: retq
CHECK: cmpq $0x1, %rdi CHECK: cmpq $0x1, %rdi
CHECK: jmp .Ltmp[[#]] CHECK: jmp .Ltmp[[#]]
CHECK: End of Function "foo" CHECK: End of Function "foo"

bolt/test/X86/data-to-data-pcrel.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: ld.lld %t.o -o %t.exe -q --unresolved-symbols=ignore-all # RUN: ld.lld %t.o -o %t.exe -q --unresolved-symbols=ignore-all
# RUN: llvm-readelf -Wr %t.exe | FileCheck %s # RUN: llvm-readelf -Wr %t.exe | FileCheck %s
# RUN: llvm-bolt -strict %t.exe -relocs -o /dev/null # RUN: llvm-bolt --strict %t.exe --relocs -o /dev/null
.text .text
.globl _start .globl _start
.type _start,@function .type _start,@function
_start: _start:
.cfi_startproc .cfi_startproc
retq retq
Show All 25 Lines

bolt/test/X86/debug-fission-single.s

Show All 37 Lines
# CHECK-DWO-DWO: DW_TAG_subprogram # CHECK-DWO-DWO: DW_TAG_subprogram
# CHECK-DWO-DWO-NEXT: DW_AT_low_pc [DW_FORM_GNU_addr_index] (indexed (00000000) # CHECK-DWO-DWO-NEXT: DW_AT_low_pc [DW_FORM_GNU_addr_index] (indexed (00000000)
# CHECK-DWO-DWO-NEXT: DW_AT_ranges [DW_FORM_sec_offset] (0x00000040 # CHECK-DWO-DWO-NEXT: DW_AT_ranges [DW_FORM_sec_offset] (0x00000040
# CHECK-ADDR-SEC: .debug_addr contents: # CHECK-ADDR-SEC: .debug_addr contents:
# CHECK-ADDR-SEC: 0x00000000: Addrs: [ # CHECK-ADDR-SEC: 0x00000000: Addrs: [
# CHECK-ADDR-SEC: 0x0000000000601000 # CHECK-ADDR-SEC: 0x0000000000601000
# RUN: llvm-bolt %t.exe --reorder-blocks=reverse -update-debug-sections -dwarf-output-path=%T -o %t.bolt.2.exe --write-dwp=true # RUN: llvm-bolt %t.exe --reorder-blocks=reverse --update-debug-sections --dwarf-output-path=%T -o %t.bolt.2.exe --write-dwp=true
# RUN: not llvm-dwarfdump --show-form --verbose --debug-info %t.bolt.2.exe.dwp &> %tAddrIndexTestDwp # RUN: not llvm-dwarfdump --show-form --verbose --debug-info %t.bolt.2.exe.dwp &> %tAddrIndexTestDwp
# RUN: cat %tAddrIndexTestDwp | FileCheck %s --check-prefix=CHECK-DWP-DEBUG # RUN: cat %tAddrIndexTestDwp | FileCheck %s --check-prefix=CHECK-DWP-DEBUG
# CHECK-DWP-DEBUG: DW_TAG_compile_unit [1] * # CHECK-DWP-DEBUG: DW_TAG_compile_unit [1] *
# CHECK-DWP-DEBUG: DW_AT_producer [DW_FORM_GNU_str_index] (indexed (0000000a) string = "clang version 13.0.0") # CHECK-DWP-DEBUG: DW_AT_producer [DW_FORM_GNU_str_index] (indexed (0000000a) string = "clang version 13.0.0")
# CHECK-DWP-DEBUG: DW_AT_language [DW_FORM_data2] (DW_LANG_C_plus_plus) # CHECK-DWP-DEBUG: DW_AT_language [DW_FORM_data2] (DW_LANG_C_plus_plus)
# CHECK-DWP-DEBUG: DW_AT_name [DW_FORM_GNU_str_index] (indexed (0000000b) string = "foo") # CHECK-DWP-DEBUG: DW_AT_name [DW_FORM_GNU_str_index] (indexed (0000000b) string = "foo")
# CHECK-DWP-DEBUG: DW_AT_GNU_dwo_name [DW_FORM_GNU_str_index] (indexed (0000000c) string = "foo") # CHECK-DWP-DEBUG: DW_AT_GNU_dwo_name [DW_FORM_GNU_str_index] (indexed (0000000c) string = "foo")
Show All 20 Lines

bolt/test/X86/double-jump.test

# Test the double jump removqal peephole. # Test the double jump removqal peephole.
RUN: %clang %cflags %p/Inputs/double_jump.cpp -o %t.exe RUN: %clang %cflags %p/Inputs/double_jump.cpp -o %t.exe
RUN: (llvm-bolt %t.exe -peepholes=double-jumps \ RUN: (llvm-bolt %t.exe --peepholes=double-jumps \
RUN: -eliminate-unreachable -o %t 2>&1 \ RUN: --eliminate-unreachable -o %t 2>&1 \
RUN: && llvm-objdump -d %t --print-imm-hex --no-show-raw-insn) | FileCheck %s RUN: && llvm-objdump -d %t --print-imm-hex --no-show-raw-insn) | FileCheck %s
CHECK: BOLT-INFO: Peephole: 1 double jumps patched. CHECK: BOLT-INFO: Peephole: 1 double jumps patched.
CHECK: <_Z3foom>: CHECK: <_Z3foom>:
CHECK-NEXT: pushq %rbp CHECK-NEXT: pushq %rbp
CHECK-NEXT: movq %rsp, %rbp CHECK-NEXT: movq %rsp, %rbp
CHECK-NEXT: movq %rdi, -0x8(%rbp) CHECK-NEXT: movq %rdi, -0x8(%rbp)
Show All 13 Lines

bolt/test/X86/double-rel.s

## Check that BOLT can correctly use relocations to symbolize instruction ## Check that BOLT can correctly use relocations to symbolize instruction
## operands when an instruction can have up to two relocations associated ## operands when an instruction can have up to two relocations associated
## with it. ## with it.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o
# RUN: ld.lld %t.o -o %t.exe -q --Tdata=0x80000 # RUN: ld.lld %t.o -o %t.exe -q --Tdata=0x80000
# RUN: llvm-bolt %t.exe -relocs -o /dev/null -print-only=_start -print-disasm \ # RUN: llvm-bolt %t.exe --relocs -o /dev/null --print-only=_start --print-disasm \
# RUN: | FileCheck %s --check-prefix=CHECK-BOLT # RUN: | FileCheck %s --check-prefix=CHECK-BOLT
# RUN: llvm-objdump -d --print-imm-hex %t.exe \ # RUN: llvm-objdump -d --print-imm-hex %t.exe \
# RUN: | FileCheck %s --check-prefix=CHECK-OBJDUMP # RUN: | FileCheck %s --check-prefix=CHECK-OBJDUMP
.data .data
.globl VAR .globl VAR
VAR: VAR:
.quad .quad
Show All 25 Lines

bolt/test/X86/dwarf-handle-visit-loclist-error.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=4 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o # RUN: llvm-mc -dwarf-version=4 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o
# RUN: %clang %cflags -dwarf-4 %t1.o -o %t.exe # RUN: %clang %cflags -dwarf-4 %t1.o -o %t.exe
# RUN: llvm-objcopy --remove-section=.debug_loc %t.exe # RUN: llvm-objcopy --remove-section=.debug_loc %t.exe
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections &> file # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections &> file
# RUN: cat file | FileCheck --check-prefix=CHECK %s # RUN: cat file | FileCheck --check-prefix=CHECK %s
# Making sure we handle error returned by visitLocationList correctly. # Making sure we handle error returned by visitLocationList correctly.
# CHECK: BOLT-WARNING: empty location list detected at # CHECK: BOLT-WARNING: empty location list detected at
# CHECK-NEXT: BOLT-WARNING: empty location list detected at # CHECK-NEXT: BOLT-WARNING: empty location list detected at
# CHECK-NEXT: BOLT: # CHECK-NEXT: BOLT:
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

bolt/test/X86/dwarf4-ftypes-dwo-input-dwp-output.test

# REQUIRES: system-linux # REQUIRES: system-linux
; RUN: rm -rf %t ; RUN: rm -rf %t
; RUN: mkdir %t ; RUN: mkdir %t
; RUN: cd %t ; RUN: cd %t
; RUN: llvm-mc --split-dwarf-file=main.dwo --triple=x86_64-unknown-linux-gnu \ ; RUN: llvm-mc --split-dwarf-file=main.dwo --triple=x86_64-unknown-linux-gnu \
; RUN: --filetype=obj %p/Inputs/dwarf4-ftypes-split-dwarf.s -o=main.o ; RUN: --filetype=obj %p/Inputs/dwarf4-ftypes-split-dwarf.s -o=main.o
; RUN: %clang %cflags -gdwarf-4 -gsplit-dwarf=split main.o -o main.exe ; RUN: %clang %cflags -gdwarf-4 -gsplit-dwarf=split main.o -o main.exe
; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.dwo | FileCheck -check-prefix=PRE-BOLT %s ; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.dwo | FileCheck -check-prefix=PRE-BOLT %s
; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections -write-dwp ; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections --write-dwp
; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.bolt.dwp | FileCheck -check-prefix=BOLT %s ; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.bolt.dwp | FileCheck -check-prefix=BOLT %s
; RUN: llvm-dwarfdump --show-form --verbose --debug-tu-index main.exe.bolt.dwp | FileCheck -check-prefix=BOLT-DWP-TU-INDEX %s ; RUN: llvm-dwarfdump --show-form --verbose --debug-tu-index main.exe.bolt.dwp | FileCheck -check-prefix=BOLT-DWP-TU-INDEX %s
; Test input into bolt a .dwo file with TU Index. ; Test input into bolt a .dwo file with TU Index.
; Make sure the output .dwp file has a type information. ; Make sure the output .dwp file has a type information.
; PRE-BOLT: DW_TAG_type_unit ; PRE-BOLT: DW_TAG_type_unit
; PRE-BOLT: DW_TAG_type_unit ; PRE-BOLT: DW_TAG_type_unit
Show All 13 Lines

bolt/test/X86/dwarf4-ftypes-dwp-input-dwp-output.test

# REQUIRES: system-linux # REQUIRES: system-linux
; RUN: rm -rf %t ; RUN: rm -rf %t
; RUN: mkdir %t ; RUN: mkdir %t
; RUN: cd %t ; RUN: cd %t
; RUN: llvm-mc --split-dwarf-file=main.dwo --triple=x86_64-unknown-linux-gnu \ ; RUN: llvm-mc --split-dwarf-file=main.dwo --triple=x86_64-unknown-linux-gnu \
; RUN: --filetype=obj %p/Inputs/dwarf4-ftypes-split-dwarf.s -o=main.o ; RUN: --filetype=obj %p/Inputs/dwarf4-ftypes-split-dwarf.s -o=main.o
; RUN: %clang %cflags -gdwarf-4 -gsplit-dwarf=split main.o -o main.exe ; RUN: %clang %cflags -gdwarf-4 -gsplit-dwarf=split main.o -o main.exe
; RUN: llvm-dwp -e main.exe -o main.exe.dwp ; RUN: llvm-dwp -e main.exe -o main.exe.dwp
; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.dwp | FileCheck -check-prefix=PRE-BOLT %s ; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.dwp | FileCheck -check-prefix=PRE-BOLT %s
; RUN: llvm-dwarfdump --show-form --verbose --debug-tu-index main.exe.dwp | FileCheck -check-prefix=PRE-BOLT-DWP-TU-INDEX %s ; RUN: llvm-dwarfdump --show-form --verbose --debug-tu-index main.exe.dwp | FileCheck -check-prefix=PRE-BOLT-DWP-TU-INDEX %s
; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections -write-dwp ; RUN: llvm-bolt main.exe -o main.exe.bolt --update-debug-sections --write-dwp
; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.bolt.dwp | FileCheck -check-prefix=BOLT %s ; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.bolt.dwp | FileCheck -check-prefix=BOLT %s
; RUN: llvm-dwarfdump --show-form --verbose --debug-tu-index main.exe.bolt.dwp | FileCheck -check-prefix=BOLT-DWP-TU-INDEX %s ; RUN: llvm-dwarfdump --show-form --verbose --debug-tu-index main.exe.bolt.dwp | FileCheck -check-prefix=BOLT-DWP-TU-INDEX %s
; Test input into bolt a DWP file with TU Index. ; Test input into bolt a DWP file with TU Index.
; Make sure the output .dwp file has a type information. ; Make sure the output .dwp file has a type information.
; PRE-BOLT: DW_TAG_type_unit ; PRE-BOLT: DW_TAG_type_unit
; PRE-BOLT: DW_TAG_type_unit ; PRE-BOLT: DW_TAG_type_unit
Show All 13 Lines

bolt/test/X86/dwarf5-debug-info-dwarf4-debug-line.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=4 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o # RUN: llvm-mc -dwarf-version=4 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o
# RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-line %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-line %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-line %t.bolt | FileCheck --check-prefix=POSTCHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-line %t.bolt | FileCheck --check-prefix=POSTCHECK %s
# This test checks that .debug_line gets generated correctly when .debug_info is DWARF5, and .debug_line is DWARF4. # This test checks that .debug_line gets generated correctly when .debug_info is DWARF5, and .debug_line is DWARF4.
# PRECHECK: version: 4 # PRECHECK: version: 4
# PRECHECK: file_names[ 1]: # PRECHECK: file_names[ 1]:
# PRECHECK-NEXT: name: "main.cpp" # PRECHECK-NEXT: name: "main.cpp"
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

bolt/test/X86/dwarf5-debug-line.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o
# RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-line %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-line %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-line %t.bolt | FileCheck --check-prefix=POSTCHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-line %t.bolt | FileCheck --check-prefix=POSTCHECK %s
# This test checks that DWARF5 .debug_line is handled correctly. # This test checks that DWARF5 .debug_line is handled correctly.
# PRECHECK: version: 5 # PRECHECK: version: 5
# PRECHECK: include_directories[ 0] = .debug_line_str # PRECHECK: include_directories[ 0] = .debug_line_str
# PRECHECK-SAME: ] = "." # PRECHECK-SAME: ] = "."
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

bolt/test/X86/dwarf5-debug-loclists.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o
# RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt
# RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s # RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s
# This tests checks that re-writing of .debug_loclists is handled correctly. # This tests checks that re-writing of .debug_loclists is handled correctly.
# PRECHECK: version = 0x0005 # PRECHECK: version = 0x0005
▲ Show 20 Lines • Show All 426 Lines • Show Last 20 Lines

bolt/test/X86/dwarf5-label-low-pc.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %tmain.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %tmain.o
# RUN: %clang %cflags -dwarf-5 %tmain.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %tmain.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt
# This test checks that we correctly handle DW_AT_low_pc [DW_FORM_addrx] that is part of DW_TAG_label. # This test checks that we correctly handle DW_AT_low_pc [DW_FORM_addrx] that is part of DW_TAG_label.
# PRECHECK: version = 0x0005 # PRECHECK: version = 0x0005
▲ Show 20 Lines • Show All 288 Lines • Show Last 20 Lines

bolt/test/X86/dwarf5-locexpr-addrx.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %tmain.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %tmain.o
# RUN: %clang %cflags -dwarf-5 %tmain.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %tmain.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt | FileCheck --check-prefix=POSTCHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt | FileCheck --check-prefix=POSTCHECK %s
# This test checks that we correctly encode new index into .debug_addr section # This test checks that we correctly encode new index into .debug_addr section
# from DW_AT_location [DW_FORM_exprloc] (DW_OP_addrx 0x#) # from DW_AT_location [DW_FORM_exprloc] (DW_OP_addrx 0x#)
# PRECHECK: version = 0x0005 # PRECHECK: version = 0x0005
# PRECHECK: DW_TAG_variable # PRECHECK: DW_TAG_variable
▲ Show 20 Lines • Show All 448 Lines • Show Last 20 Lines

bolt/test/X86/dwarf5-loclist-offset-form.test

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-loclist-offset-form-main.s -o %tmain.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-loclist-offset-form-main.s -o %tmain.o
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-loclist-offset-form-helper.s -o %thelper.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5-loclist-offset-form-helper.s -o %thelper.o
# RUN: %clang %cflags -dwarf-5 %tmain.o %thelper.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %tmain.o %thelper.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt
# RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s # RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s
# Checks we can handle DWARF5 CU with DWARF4 DW_AT_location access pattern. # Checks we can handle DWARF5 CU with DWARF4 DW_AT_location access pattern.
# PRECHECK: DW_TAG_compile_unit # PRECHECK: DW_TAG_compile_unit
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

bolt/test/X86/dwarf5-lowpc-highpc-convert.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o
# RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt
# RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s # RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s
# This tests checks that DW_AT_low_pc/DW_AT_high_pc is converted to DW_AT_low_pc/DW_AT_ranges. # This tests checks that DW_AT_low_pc/DW_AT_high_pc is converted to DW_AT_low_pc/DW_AT_ranges.
# Checks that DW_AT_rnglists_base is inserted, and that correct address is used. # Checks that DW_AT_rnglists_base is inserted, and that correct address is used.
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

bolt/test/X86/dwarf5-rangeoffset-to-rangeindex.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o
# RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt
# RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s # RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s
# This tests conversion for DWARF5 ranges DW_AT_ranges [DW_FORM_sec_offset] to DW_AT_ranges [DW_FORM_rnglistx] # This tests conversion for DWARF5 ranges DW_AT_ranges [DW_FORM_sec_offset] to DW_AT_ranges [DW_FORM_rnglistx]
# PRECHECK: version = 0x0005 # PRECHECK: version = 0x0005
▲ Show 20 Lines • Show All 243 Lines • Show Last 20 Lines

bolt/test/X86/dwarf5-two-loclists.test

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5_main.s -o %tmain.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5_main.s -o %tmain.o
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5_helper.s -o %thelper.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5_helper.s -o %thelper.o
# RUN: %clang %cflags -dwarf-5 %tmain.o %thelper.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %tmain.o %thelper.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt
# RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s # RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s
# This tests checks that re-writing of .debug_loclists is handled correctly for two CUs, # This tests checks that re-writing of .debug_loclists is handled correctly for two CUs,
# and two loclist entries. # and two loclist entries.
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

bolt/test/X86/dwarf5-two-rnglists.test

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5_main.s -o %tmain.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5_main.s -o %tmain.o
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5_helper.s -o %thelper.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %p/Inputs/dwarf5_helper.s -o %thelper.o
# RUN: %clang %cflags -dwarf-5 %tmain.o %thelper.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %tmain.o %thelper.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-addr %t.bolt > %t.txt
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt >> %t.txt
# RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s # RUN: cat %t.txt | FileCheck --check-prefix=POSTCHECK %s
# This tests checks that re-writing of .debug_rnglists is handled correctly for two CUs, # This tests checks that re-writing of .debug_rnglists is handled correctly for two CUs,
# and DW_AT_low_pc/DW_AT_high_pc conversion is handled correctly. # and DW_AT_low_pc/DW_AT_high_pc conversion is handled correctly.
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

bolt/test/X86/exceptions-args.test

# Check that we handle GNU_args_size correctly. # Check that we handle GNU_args_size correctly.
# It is generated for throwing functions with LP that have parameters on stack. # It is generated for throwing functions with LP that have parameters on stack.
RUN: %clang %cflags %p/../Inputs/stub.c -fPIC -pie -shared -o %t.so RUN: %clang %cflags %p/../Inputs/stub.c -fPIC -pie -shared -o %t.so
RUN: %clangxx %cxxflags -no-pie %p/Inputs/exc_args.s -o %t %t.so -Wl,-z,notext RUN: %clangxx %cxxflags -no-pie %p/Inputs/exc_args.s -o %t %t.so -Wl,-z,notext
RUN: llvm-bolt %t -o /dev/null -print-finalized -print-only=main | FileCheck %s RUN: llvm-bolt %t -o /dev/null --print-finalized --print-only=main | FileCheck %s
CHECK: Binary Function "main" after finalize-functions CHECK: Binary Function "main" after finalize-functions
CHECK: callq _Z3fooiiiiiiii {{.*}} GNU_args_size = 16 CHECK: callq _Z3fooiiiiiiii {{.*}} GNU_args_size = 16
CHECK: callq printf@PLT {{.*}} GNU_args_size = 0 CHECK: callq printf@PLT {{.*}} GNU_args_size = 0
CHECK: End of Function "main" CHECK: End of Function "main"

bolt/test/X86/fallthrough-to-noop.test

# Check that profile data for the fall-through jump is not ingored when there is # Check that profile data for the fall-through jump is not ingored when there is
# a conditional jump followed by a no-op. # a conditional jump followed by a no-op.
RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
RUN: %S/Inputs/ft_to_noop.s -o %t.o RUN: %S/Inputs/ft_to_noop.s -o %t.o
RUN: link_fdata %S/Inputs/ft_to_noop.s %t.o %t.fdata --nmtool llvm-nm RUN: link_fdata %S/Inputs/ft_to_noop.s %t.o %t.fdata --nmtool llvm-nm
RUN: llvm-strip --strip-unneeded %t.o RUN: llvm-strip --strip-unneeded %t.o
RUN: %clang %cflags %t.o -o %t.exe -Wl,-q RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
RUN: llvm-bolt %t.exe -o %t -data %t.fdata \ RUN: llvm-bolt %t.exe -o %t --data %t.fdata \
RUN: -print-cfg -sequential-disassembly 2>&1 | FileCheck %s RUN: --print-cfg --sequential-disassembly 2>&1 | FileCheck %s
CHECK: Binary Function "foo" after building cfg CHECK: Binary Function "foo" after building cfg
CHECK: Exec Count : 20 CHECK: Exec Count : 20
CHECK: Profile Acc : 100.0% CHECK: Profile Acc : 100.0%
# This block is terminated with a conditional jump to .Ltmp0 followed by a # This block is terminated with a conditional jump to .Ltmp0 followed by a
# no-op. The profile data contains a count for the fall-through (3) which # no-op. The profile data contains a count for the fall-through (3) which
# is different from what would be inferred (2). However the destination # is different from what would be inferred (2). However the destination
Show All 12 Lines

bolt/test/X86/false-jump-table.s

# Check that jump table detection does not fail on a false # Check that jump table detection does not fail on a false
# reference to a jump table. # reference to a jump table.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -print-cfg \ # RUN: llvm-bolt %t.exe --print-cfg \
# RUN: -print-only=inc_dup -o %t.out | FileCheck %s # RUN: --print-only=inc_dup -o %t.out | FileCheck %s
.file "jump_table.c" .file "jump_table.c"
.section .rodata .section .rodata
.LC0: .LC0:
.string "0" .string "0"
.LC1: .LC1:
.string "1" .string "1"
.LC2: .LC2:
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

bolt/test/X86/fptr-addend-pcrel.s

## Check that BOLT correctly recognizes pc-relative function pointer ## Check that BOLT correctly recognizes pc-relative function pointer
## reference with an addend. ## reference with an addend.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t.o
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: ld.lld %t.o -o %t.exe -q # RUN: ld.lld %t.o -o %t.exe -q
# RUN: llvm-bolt %t.exe -relocs -o /dev/null -print-only=foo -print-disasm \ # RUN: llvm-bolt %t.exe --relocs -o /dev/null --print-only=foo --print-disasm \
# RUN: | FileCheck %s # RUN: | FileCheck %s
.text .text
.globl _start .globl _start
.type _start,@function .type _start,@function
_start: _start:
.cfi_startproc .cfi_startproc
call foo call foo
Show All 18 Lines

bolt/test/X86/gdbindex.test

RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %p/Inputs/dwarfdump-gdbindex.s -o %t.o RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %p/Inputs/dwarfdump-gdbindex.s -o %t.o
RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %p/Inputs/dwarfdump-gdbindex2.s -o %t2.o RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %p/Inputs/dwarfdump-gdbindex2.s -o %t2.o
RUN: ld.lld --gdb-index %t.o %t2.o -o %tfile.exe RUN: ld.lld --gdb-index %t.o %t2.o -o %tfile.exe
RUN: llvm-bolt %tfile.exe -o %tfile.exe.bolt -update-debug-sections RUN: llvm-bolt %tfile.exe -o %tfile.exe.bolt --update-debug-sections
RUN: llvm-dwarfdump -gdb-index %tfile.exe.bolt | FileCheck %s RUN: llvm-dwarfdump -gdb-index %tfile.exe.bolt | FileCheck %s
; test.cpp: ; test.cpp:
; int main() { return 0; } ; int main() { return 0; }
; test2.cpp: ; test2.cpp:
; int main2() { return 0; } ; int main2() { return 0; }
; Compiled with: ; Compiled with:
; gcc -gsplit-dwarf -c test.cpp test2.cpp ; gcc -gsplit-dwarf -c test.cpp test2.cpp
Show All 20 Lines

bolt/test/X86/gotpcrelx.s

# REQUIRES: system-linux # REQUIRES: system-linux
## Check that BOLT correctly handles different types of instructions with ## Check that BOLT correctly handles different types of instructions with
## R_X86_64_GOTPCRELX or R_X86_64_REX_GOTPCRELX relocations and different ## R_X86_64_GOTPCRELX or R_X86_64_REX_GOTPCRELX relocations and different
## kinds of handling of the relocation by the linker (no relaxation, pic, and ## kinds of handling of the relocation by the linker (no relaxation, pic, and
## non-pic). ## non-pic).
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux \
# RUN: -relax-relocations %s -o %t.o # RUN: -relax-relocations %s -o %t.o
# RUN: ld.lld %t.o -o %t.exe -q # RUN: ld.lld %t.o -o %t.exe -q
# RUN: ld.lld %t.o -o %t.pie.exe -q -pie # RUN: ld.lld %t.o -o %t.pie.exe -q -pie
# RUN: ld.lld %t.o -o %t.no-relax.exe -q --no-relax # RUN: ld.lld %t.o -o %t.no-relax.exe -q --no-relax
# RUN: llvm-bolt %t.exe -relocs -o %t.out -print-cfg -print-only=_start \ # RUN: llvm-bolt %t.exe --relocs -o %t.out --print-cfg --print-only=_start \
# RUN: |& FileCheck --check-prefix=BOLT %s # RUN: |& FileCheck --check-prefix=BOLT %s
# RUN: llvm-bolt %t.pie.exe -o /dev/null -print-cfg -print-only=_start \ # RUN: llvm-bolt %t.pie.exe -o /dev/null --print-cfg --print-only=_start \
# RUN: |& FileCheck --check-prefix=PIE-BOLT %s # RUN: |& FileCheck --check-prefix=PIE-BOLT %s
# RUN: llvm-bolt %t.no-relax.exe -o /dev/null -print-cfg -print-only=_start \ # RUN: llvm-bolt %t.no-relax.exe -o /dev/null --print-cfg --print-only=_start \
# RUN: |& FileCheck --check-prefix=NO-RELAX-BOLT %s # RUN: |& FileCheck --check-prefix=NO-RELAX-BOLT %s
# RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex \ # RUN: llvm-objdump -d --no-show-raw-insn --print-imm-hex \
# RUN: %t.out | FileCheck --check-prefix=DISASM %s # RUN: %t.out | FileCheck --check-prefix=DISASM %s
.text .text
.globl _start .globl _start
.type _start, %function .type _start, %function
_start: _start:
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

bolt/test/X86/high_pc_udata.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o
# RUN: %clang %cflags %t1.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t1.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt | FileCheck --check-prefix=POSTCHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt | FileCheck --check-prefix=POSTCHECK %s
# PRECHECK: DW_AT_high_pc [DW_FORM_udata] (15) # PRECHECK: DW_AT_high_pc [DW_FORM_udata] (15)
# PRECHECK-NEXT: DW_AT_name [DW_FORM_strp] # PRECHECK-NEXT: DW_AT_name [DW_FORM_strp]
# PRECHECK-SAME: "main.cpp" # PRECHECK-SAME: "main.cpp"
# POSTCHECK: DW_AT_ranges [DW_FORM_sec_offset] # POSTCHECK: DW_AT_ranges [DW_FORM_sec_offset]
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

bolt/test/X86/icf-jump-tables.test

## Check that BOLT folds functions with jump tables and does not report ## Check that BOLT folds functions with jump tables and does not report
## undefined symbols. ## undefined symbols.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: %clang %cflags -O1 -g %p/../Inputs/icf-jump-tables.c -o %t.exe -Wl,-q # RUN: %clang %cflags -O1 -g %p/../Inputs/icf-jump-tables.c -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -icf -o %t.bolt |& FileCheck %s # RUN: llvm-bolt %t.exe --icf -o %t.bolt |& FileCheck %s
## Check that BOLT successfully folded a function with jump table: ## Check that BOLT successfully folded a function with jump table:
# CHECK: ICF folded {{.*}}. {{[^0]}} functions had jump tables. # CHECK: ICF folded {{.*}}. {{[^0]}} functions had jump tables.
## Check that no relocations against undefined symbols were emitted: ## Check that no relocations against undefined symbols were emitted:
# CHECK-NOT: Undefined temporary symbol # CHECK-NOT: Undefined temporary symbol

bolt/test/X86/indirect-goto.test

# Check llvm-bolt processes binaries compiled from sources that use indirect goto. # Check llvm-bolt processes binaries compiled from sources that use indirect goto.
RUN: %clang %cflags -no-pie %S/Inputs/indirect_goto.c -Wl,-q -o %t RUN: %clang %cflags -no-pie %S/Inputs/indirect_goto.c -Wl,-q -o %t
RUN: llvm-bolt %t -o /dev/null -relocs=1 -print-cfg -print-only=main -strict \ RUN: llvm-bolt %t -o /dev/null --relocs=1 --print-cfg --print-only=main \
RUN: --strict \
RUN: 2>&1 | FileCheck %s RUN: 2>&1 | FileCheck %s
# Check that all possible destinations are included as successors. # Check that all possible destinations are included as successors.
CHECK: jmpq *%rax # UNKNOWN CONTROL FLOW CHECK: jmpq *%rax # UNKNOWN CONTROL FLOW
CHECK: Successors: .Ltmp0, .Ltmp1, .Ltmp2 CHECK: Successors: .Ltmp0, .Ltmp1, .Ltmp2

bolt/test/X86/inline-debug-info.test

## Check that BOLT correctly prints and updates debug info for inlined ## Check that BOLT correctly prints and updates debug info for inlined
## functions. ## functions.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: %clang %cflags -O1 -g %p/Inputs/inline-main.c %p/Inputs/inline-foo.c \ # RUN: %clang %cflags -O1 -g %p/Inputs/inline-main.c %p/Inputs/inline-foo.c \
# RUN: -I%p/../Inputs -o %t.exe -Wl,-q # RUN: -I%p/../Inputs -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -update-debug-sections -print-debug-info \ # RUN: llvm-bolt %t.exe --update-debug-sections --print-debug-info \
# RUN: -print-only=main -print-after-lowering -force-inline=foo -o %t.bolt \ # RUN: --print-only=main --print-after-lowering --force-inline=foo \
# RUN: -o %t.bolt \
# RUN: | FileCheck %s # RUN: | FileCheck %s
## The call to puts() should come from inline-foo.c: ## The call to puts() should come from inline-foo.c:
# CHECK: callq {{.*}} # debug line {{.*}}inline-foo.c:4:3 # CHECK: callq {{.*}} # debug line {{.*}}inline-foo.c:4:3
# RUN: llvm-objdump --disassemble-symbols=main -d --line-numbers %t.bolt \ # RUN: llvm-objdump --disassemble-symbols=main -d --line-numbers %t.bolt \
# RUN: | FileCheck %s -check-prefix=CHECK-OBJDUMP # RUN: | FileCheck %s -check-prefix=CHECK-OBJDUMP
## Dump of main() should include debug info from inline-foo.c after inlining: ## Dump of main() should include debug info from inline-foo.c after inlining:
# CHECK-OBJDUMP: inline-foo.c:4 # CHECK-OBJDUMP: inline-foo.c:4

bolt/test/X86/inlined-function-mixed.test

# Make sure inlining from a unit with debug info into unit without # Make sure inlining from a unit with debug info into unit without
# debug info does not cause a crash. # debug info does not cause a crash.
RUN: %clangxx %cxxflags %S/Inputs/inlined.cpp -c -o %T/inlined.o RUN: %clangxx %cxxflags %S/Inputs/inlined.cpp -c -o %T/inlined.o
RUN: %clangxx %cxxflags %S/Inputs/inlinee.cpp -c -o %T/inlinee.o -g RUN: %clangxx %cxxflags %S/Inputs/inlinee.cpp -c -o %T/inlinee.o -g
RUN: %clangxx %cxxflags %T/inlined.o %T/inlinee.o -o %t RUN: %clangxx %cxxflags %T/inlined.o %T/inlinee.o -o %t
RUN: llvm-bolt %t -o %t.bolt -update-debug-sections -reorder-blocks=reverse \ RUN: llvm-bolt %t -o %t.bolt --update-debug-sections --reorder-blocks=reverse \
RUN: -inline-small-functions -force-inline=main | FileCheck %s RUN: --inline-small-functions --force-inline=main | FileCheck %s
CHECK-NOT: BOLT: 0 out of {{.*}} functions were overwritten CHECK-NOT: BOLT: 0 out of {{.*}} functions were overwritten

bolt/test/X86/insert-addr-rnglists_base.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o # RUN: llvm-mc -dwarf-version=5 -filetype=obj -triple x86_64-unknown-linux %s -o %t1.o
# RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q # RUN: %clang %cflags -dwarf-5 %t1.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -update-debug-sections # RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.exe | FileCheck --check-prefix=PRECHECK %s
# RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt | FileCheck --check-prefix=POSTCHECK %s # RUN: llvm-dwarfdump --show-form --verbose --debug-info %t.bolt | FileCheck --check-prefix=POSTCHECK %s
# This test checks we correctly insert DW_AT_addr_base, when converting DW_AT_low_pc into DW_AT_ranges. # This test checks we correctly insert DW_AT_addr_base, when converting DW_AT_low_pc into DW_AT_ranges.
# PRECHECK-NOT: DW_AT_addr_base # PRECHECK-NOT: DW_AT_addr_base
# POSTCHECK: DW_AT_ranges [DW_FORM_rnglistx] # POSTCHECK: DW_AT_ranges [DW_FORM_rnglistx]
# POSTCHECK: DW_AT_rnglists_base [DW_FORM_sec_offset] (0x0000000c) # POSTCHECK: DW_AT_rnglists_base [DW_FORM_sec_offset] (0x0000000c)
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

bolt/test/X86/internal-call-instrument-so.s

# This reproduces a bug with instrumentation crashes on internal call # This reproduces a bug with instrumentation crashes on internal call
# REQUIRES: system-linux,bolt-runtime # REQUIRES: system-linux,bolt-runtime
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# Delete our BB symbols so BOLT doesn't mark them as entry points # Delete our BB symbols so BOLT doesn't mark them as entry points
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: ld.lld %t.o -o %t.exe -q -shared -fini=_fini # RUN: ld.lld %t.o -o %t.exe -q -shared -fini=_fini
# RUN: llvm-bolt -instrument %t.exe -relocs -o %t.out # RUN: llvm-bolt --instrument %t.exe --relocs -o %t.out
.text .text
.globl _start .globl _start
.type _start, %function .type _start, %function
.p2align 4 .p2align 4
_start: _start:
push %rbp push %rbp
mov %rsp,%rbp mov %rsp,%rbp
Show All 38 Lines

bolt/test/X86/internal-call-instrument.s

# This reproduces a bug with instrumentation crashes on internal call # This reproduces a bug with instrumentation crashes on internal call
# REQUIRES: system-linux,bolt-runtime # REQUIRES: system-linux,bolt-runtime
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# Delete our BB symbols so BOLT doesn't mark them as entry points # Delete our BB symbols so BOLT doesn't mark them as entry points
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %t.o -o %t.exe -Wl,-q # RUN: %clang %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt -instrument %t.exe -relocs -o %t.out # RUN: llvm-bolt --instrument %t.exe --relocs -o %t.out
.text .text
.globl main .globl main
.type main, %function .type main, %function
.p2align 4 .p2align 4
main: main:
push %rbp push %rbp
mov %rsp,%rbp mov %rsp,%rbp
Show All 25 Lines

bolt/test/X86/interprocedural-ref-entry-point.s

Show All 13 Lines
# throw std::logic_error(""); # throw std::logic_error("");
# } catch (...) {} # } catch (...) {}
# } # }
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: %clangxx %cxxflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clangxx %cxxflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.out -dump-dot-all -funcs=main.* 2>&1 | FileCheck %s # RUN: llvm-bolt %t.exe -o %t.out --dump-dot-all --funcs=main.* \
# RUN: 2>&1 | FileCheck %s
# #
# CHECK-NOT: Assertion `isValid()' failed. # CHECK-NOT: Assertion `isValid()' failed.
.globl main .globl main
main: main:
jmp .L3 # jump to the secondary entry point in main.cold.0 jmp .L3 # jump to the secondary entry point in main.cold.0
.section a,"ax" .section a,"ax"
Show All 21 Lines

bolt/test/X86/issue20.s

# This reproduces issue 20 from our github repo # This reproduces issue 20 from our github repo
# "BOLT crashes when removing unreachable BBs that are a target # "BOLT crashes when removing unreachable BBs that are a target
# in a JT" # in a JT"
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe # RUN: %clang %cflags -no-pie %t.o -o %t.exe
# RUN: llvm-bolt %t.exe -relocs=0 -jump-tables=move -print-finalized \ # RUN: llvm-bolt %t.exe --relocs=0 --jump-tables=move --print-finalized \
# RUN: -o %t.out | FileCheck %s # RUN: -o %t.out | FileCheck %s
# CHECK: BOLT-INFO: UCE removed 0 blocks and 0 bytes of code. # CHECK: BOLT-INFO: UCE removed 0 blocks and 0 bytes of code.
# CHECK: Binary Function "main" # CHECK: Binary Function "main"
# CHECK: .LFT{{.*}} (2 instructions, align : 1) # CHECK: .LFT{{.*}} (2 instructions, align : 1)
# CHECK-NEXT: CFI State : 0 # CHECK-NEXT: CFI State : 0
# CHECK-NEXT: 00000004: andq # CHECK-NEXT: 00000004: andq
# CHECK-NEXT: 00000008: jmpq # CHECK-NEXT: 00000008: jmpq
Show All 35 Lines

bolt/test/X86/issue20.test

# This reproduces issue 20 from our github repo # This reproduces issue 20 from our github repo
# "BOLT crashes when removing unreachable BBs that are a target # "BOLT crashes when removing unreachable BBs that are a target
# in a JT" # in a JT"
# RUN: yaml2obj %p/Inputs/issue20.yaml &> %t.exe # RUN: yaml2obj %p/Inputs/issue20.yaml &> %t.exe
# RUN: llvm-bolt %t.exe -relocs=0 -jump-tables=move -print-finalized \ # RUN: llvm-bolt %t.exe --relocs=0 --jump-tables=move --print-finalized \
# RUN: -o %t.out | FileCheck %s # RUN: -o %t.out | FileCheck %s
CHECK: BOLT-INFO: UCE removed 0 blocks and 0 bytes of code. CHECK: BOLT-INFO: UCE removed 0 blocks and 0 bytes of code.
CHECK: Binary Function "main" CHECK: Binary Function "main"
CHECK: .LFT0 (2 instructions, align : 1) CHECK: .LFT0 (2 instructions, align : 1)
CHECK-NEXT: CFI State : 0 CHECK-NEXT: CFI State : 0
CHECK-NEXT: 00000004: andq CHECK-NEXT: 00000004: andq
CHECK-NEXT: 00000008: jmpq CHECK-NEXT: 00000008: jmpq
CHECK-NEXT: Successors: .Ltmp1, .Ltmp2, .Ltmp3, .Ltmp4 CHECK-NEXT: Successors: .Ltmp1, .Ltmp2, .Ltmp3, .Ltmp4

bolt/test/X86/issue26.s

# This reproduces issue 26 from our github repo # This reproduces issue 26 from our github repo
# BOLT fails with the following assertion: # BOLT fails with the following assertion:
# llvm/tools/llvm-bolt/src/BinaryFunction.cpp:2950: void llvm::bolt::BinaryFunction::postProcessBranches(): Assertion `validateCFG() && "invalid CFG"' failed. # llvm/tools/llvm-bolt/src/BinaryFunction.cpp:2950: void llvm::bolt::BinaryFunction::postProcessBranches(): Assertion `validateCFG() && "invalid CFG"' failed.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -relocs -print-cfg -o %t.out \ # RUN: llvm-bolt %t.exe --relocs --print-cfg -o %t.out \
# RUN: | FileCheck %s # RUN: | FileCheck %s
# CHECK-NOT: BOLT-WARNING: CFG invalid in XYZ @ .LBB0 # CHECK-NOT: BOLT-WARNING: CFG invalid in XYZ @ .LBB0
# CHECK: Binary Function "XYZ" # CHECK: Binary Function "XYZ"
# CHECK: .Ltmp{{.*}} (1 instructions, align : 1) # CHECK: .Ltmp{{.*}} (1 instructions, align : 1)
# CHECK-NEXT: Secondary Entry Point: FUNCat{{.*}} # CHECK-NEXT: Secondary Entry Point: FUNCat{{.*}}
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

bolt/test/X86/issue26.test

# This reproduces issue 26 from our github repo # This reproduces issue 26 from our github repo
# RUN: yaml2obj %p/Inputs/issue26.yaml &> %t.exe # RUN: yaml2obj %p/Inputs/issue26.yaml &> %t.exe
# RUN: llvm-bolt %t.exe -relocs -print-cfg -o %t.out \ # RUN: llvm-bolt %t.exe --relocs --print-cfg -o %t.out \
# RUN: | FileCheck %s # RUN: | FileCheck %s
CHECK-NOT: BOLT-WARNING: CFG invalid in XYZ @ .LBB0 CHECK-NOT: BOLT-WARNING: CFG invalid in XYZ @ .LBB0
CHECK: Binary Function "XYZ" CHECK: Binary Function "XYZ"
CHECK: .Ltmp0 (1 instructions, align : 1) CHECK: .Ltmp0 (1 instructions, align : 1)
CHECK-NEXT: Secondary Entry Point: FUNCat0x4004e9 CHECK-NEXT: Secondary Entry Point: FUNCat0x4004e9

bolt/test/X86/jmpjmp.test

# Verifies that llvm-bolt allocates two consecutive jumps in two separate basic # Verifies that llvm-bolt allocates two consecutive jumps in two separate basic
# blocks. # blocks.
RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %S/Inputs/jmpjmp.s -o %t.o RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %S/Inputs/jmpjmp.s -o %t.o
RUN: %clang %cflags %t.o -o %t.exe RUN: %clang %cflags %t.o -o %t.exe
RUN: llvm-bolt %t.exe -o /dev/null -print-cfg 2>&1 | FileCheck %s RUN: llvm-bolt %t.exe -o /dev/null --print-cfg 2>&1 | FileCheck %s
CHECK: Binary Function "testfunc" CHECK: Binary Function "testfunc"
CHECK: State : CFG constructed CHECK: State : CFG constructed
CHECK: Section : .text CHECK: Section : .text
CHECK: IsSimple : 1 CHECK: IsSimple : 1
CHECK: BB Count : 4 CHECK: BB Count : 4
CHECK: } CHECK: }
CHECK: .LBB{{.*}} CHECK: .LBB{{.*}}
Show All 12 Lines

bolt/test/X86/jump-table-footprint-reduction.test

# Checks that jump table footprint reduction optimization is reducing entry # Checks that jump table footprint reduction optimization is reducing entry
# sizes. # sizes.
RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
RUN: %S/Inputs/jump_table_footprint_reduction.s -o %t.o RUN: %S/Inputs/jump_table_footprint_reduction.s -o %t.o
RUN: link_fdata %S/Inputs/jump_table_footprint_reduction.s %t.o %t.fdata --nmtool llvm-nm RUN: link_fdata %S/Inputs/jump_table_footprint_reduction.s %t.o %t.fdata --nmtool llvm-nm
RUN: llvm-strip --strip-unneeded %t.o RUN: llvm-strip --strip-unneeded %t.o
RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
RUN: llvm-bolt %t.exe -data %t.fdata -o /dev/null \ RUN: llvm-bolt %t.exe --data %t.fdata -o /dev/null \
RUN: -jump-tables=move -jt-footprint-reduction -assume-abi -relocs \ RUN: --jump-tables=move --jt-footprint-reduction --assume-abi --relocs \
RUN: | FileCheck %s RUN: | FileCheck %s
CHECK: 100.00% of dynamic JT entries were reduced. CHECK: 100.00% of dynamic JT entries were reduced.
CHECK: 1 of 1 jump tables affected. CHECK: 1 of 1 jump tables affected.
CHECK: 1 of 1 indirect jumps to JTs affected. CHECK: 1 of 1 indirect jumps to JTs affected.
CHECK: 36 bytes saved. CHECK: 36 bytes saved.

bolt/test/X86/jump-table-icp.test

RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
RUN: %p/Inputs/jump_table_icp.s -o %t.o RUN: %p/Inputs/jump_table_icp.s -o %t.o
RUN: link_fdata %p/Inputs/jump_table_icp.s %t.o %t.fdata --nmtool llvm-nm RUN: link_fdata %p/Inputs/jump_table_icp.s %t.o %t.fdata --nmtool llvm-nm
RUN: llvm-strip --strip-unneeded %t.o RUN: llvm-strip --strip-unneeded %t.o
RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
RUN: (llvm-bolt %t.exe -data %t.fdata -o %t -relocs \ RUN: (llvm-bolt %t.exe --data %t.fdata -o %t --relocs \
RUN: -reorder-blocks=cache -split-functions=3 -split-all-cold \ RUN: --reorder-blocks=cache --split-functions=3 --split-all-cold \
RUN: -use-gnu-stack -dyno-stats -indirect-call-promotion=jump-tables \ RUN: --use-gnu-stack --dyno-stats --indirect-call-promotion=jump-tables \
RUN: -print-icp -v=0 \ RUN: --print-icp -v=0 \
RUN: -icp-jt-remaining-percent-threshold=10 \ RUN: --icp-jt-remaining-percent-threshold=10 \
RUN: -icp-jt-total-percent-threshold=2 \ RUN: --icp-jt-total-percent-threshold=2 \
RUN: -indirect-call-promotion-topn=1 \ RUN: --indirect-call-promotion-topn=1 \
RUN: -icp-jump-tables-targets -align-functions-max-bytes=7 2>&1 && \ RUN: --icp-jump-tables-targets --align-functions-max-bytes=7 2>&1 && \
RUN: llvm-objdump -d %t --print-imm-hex) | FileCheck %s RUN: llvm-objdump -d %t --print-imm-hex) | FileCheck %s
BOLT-INFO: ICP total indirect callsites = 0 BOLT-INFO: ICP total indirect callsites = 0
BOLT-INFO: ICP total jump table callsites = 2 BOLT-INFO: ICP total jump table callsites = 2
BOLT-INFO: ICP total number of calls = 2137 BOLT-INFO: ICP total number of calls = 2137
BOLT-INFO: ICP percentage of calls that are indirect = 0.0% BOLT-INFO: ICP percentage of calls that are indirect = 0.0%
BOLT-INFO: ICP percentage of indirect calls that can be optimized = 0.0% BOLT-INFO: ICP percentage of indirect calls that can be optimized = 0.0%
BOLT-INFO: ICP percentage of indirect calls that are optimized = 0.0% BOLT-INFO: ICP percentage of indirect calls that are optimized = 0.0%
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

bolt/test/X86/jump-table-pic-order.test

# Check that successors of a basic block with jump table are generated # Check that successors of a basic block with jump table are generated
# in the same order as they appear in the input code. # in the same order as they appear in the input code.
RUN: %clang %cflags %S/Inputs/jump-table-pic.s -o %t.exe -Wl,-q RUN: %clang %cflags %S/Inputs/jump-table-pic.s -o %t.exe -Wl,-q
RUN: llvm-bolt %t.exe -strict -print-cfg -print-only=main -o /dev/null \ RUN: llvm-bolt %t.exe --strict --print-cfg --print-only=main -o /dev/null \
RUN: | FileCheck %s RUN: | FileCheck %s
CHECK: BB Layout : {{.*, .*, .*,}} [[BB4to6:.*, .*, .*]] CHECK: BB Layout : {{.*, .*, .*,}} [[BB4to6:.*, .*, .*]]
# Check that successors appear in the order matching the input layout. # Check that successors appear in the order matching the input layout.
CHECK: jmpq *%rax # JUMPTABLE CHECK: jmpq *%rax # JUMPTABLE
CHECK-NEXT: Successors: [[BB4to6]] CHECK-NEXT: Successors: [[BB4to6]]

bolt/test/X86/jump-table-reference.test

# Verifies that BOLT detects fixed destination of indirect jump # Verifies that BOLT detects fixed destination of indirect jump
RUN: %clang %cflags -no-pie %S/Inputs/jump_table_reference.s -Wl,-q -o %t RUN: %clang %cflags -no-pie %S/Inputs/jump_table_reference.s -Wl,-q -o %t
RUN: llvm-bolt %t -relocs -o /dev/null 2>&1 | FileCheck %s RUN: llvm-bolt %t --relocs -o /dev/null 2>&1 | FileCheck %s
CHECK: BOLT-INFO: fixed indirect branch detected in main CHECK: BOLT-INFO: fixed indirect branch detected in main

bolt/test/X86/layout-heuristic.test

# Checks that llvm-bolt is able to read data generated by perf2bolt, update the # Checks that llvm-bolt is able to read data generated by perf2bolt, update the
# CFG edges accordingly with absolute number of branches and mispredictions, # CFG edges accordingly with absolute number of branches and mispredictions,
# infer fallthrough branch info and reorder basic blocks using a greedy # infer fallthrough branch info and reorder basic blocks using a greedy
# heuristic, or find the optimal solution if the function is small enough. # heuristic, or find the optimal solution if the function is small enough.
# Also checks that llvm-bolt disassembler and CFG builder is working properly. # Also checks that llvm-bolt disassembler and CFG builder is working properly.
RUN: yaml2obj %p/Inputs/blarge.yaml &> %t.exe RUN: yaml2obj %p/Inputs/blarge.yaml &> %t.exe
RUN: llvm-bolt %t.exe -o /dev/null -data %p/Inputs/blarge.fdata \ RUN: llvm-bolt %t.exe -o /dev/null --data %p/Inputs/blarge.fdata \
RUN: -reorder-blocks=normal -print-cfg -print-reordered \ RUN: --reorder-blocks=normal --print-cfg --print-reordered \
RUN: -funcs=main,SolveCubic,usqrt -sequential-disassembly 2>&1 | FileCheck %s RUN: --funcs=main,SolveCubic,usqrt --sequential-disassembly \
RUN: 2>&1 | FileCheck %s
# Original order # Original order
CHECK: Binary Function "main" CHECK: Binary Function "main"
CHECK: BB Layout : .LBB00, .Ltmp1, .Ltmp0, .Ltmp3, .Ltmp2, .Ltmp5, .Ltmp4, .Ltmp7, .Ltmp6, .Ltmp9, .Ltmp8, .Ltmp11, .Ltmp10, .Ltmp13, .Ltmp12, .Ltmp15, .Ltmp14, .Ltmp21, .Ltmp20, .Ltmp19, .Ltmp18, .Ltmp17, .Ltmp16, .LFT0, .LFT1, .LFT2, .LFT3, .Ltmp22, .LFT4, .Ltmp23, .LFT5, .Ltmp24, .LFT6, .Ltmp25, .LFT7 CHECK: BB Layout : .LBB00, .Ltmp1, .Ltmp0, .Ltmp3, .Ltmp2, .Ltmp5, .Ltmp4, .Ltmp7, .Ltmp6, .Ltmp9, .Ltmp8, .Ltmp11, .Ltmp10, .Ltmp13, .Ltmp12, .Ltmp15, .Ltmp14, .Ltmp21, .Ltmp20, .Ltmp19, .Ltmp18, .Ltmp17, .Ltmp16, .LFT0, .LFT1, .LFT2, .LFT3, .Ltmp22, .LFT4, .Ltmp23, .LFT5, .Ltmp24, .LFT6, .Ltmp25, .LFT7
CHECK: Binary Function "SolveCubic" CHECK: Binary Function "SolveCubic"
CHECK: BB Layout : .LBB01, .LFT8, .LFT9, .Ltmp33, .LFT10, .Ltmp28, .LFT11, .Ltmp26, .LFT12, .Ltmp37, .Ltmp36, .Ltmp35, .Ltmp34, .Ltmp27, .Ltmp32, .Ltmp31, .Ltmp30, .Ltmp29 CHECK: BB Layout : .LBB01, .LFT8, .LFT9, .Ltmp33, .LFT10, .Ltmp28, .LFT11, .Ltmp26, .LFT12, .Ltmp37, .Ltmp36, .Ltmp35, .Ltmp34, .Ltmp27, .Ltmp32, .Ltmp31, .Ltmp30, .Ltmp29
CHECK: Binary Function "usqrt" CHECK: Binary Function "usqrt"
CHECK: BB Layout : .LBB02, .Ltmp39, .LFT13, .Ltmp38, .LFT14 CHECK: BB Layout : .LBB02, .Ltmp39, .LFT13, .Ltmp38, .LFT14
# New order # New order
CHECK: Binary Function "main" CHECK: Binary Function "main"
CHECK: BB Layout : .LBB00, .Ltmp1, .Ltmp0, .Ltmp3, .Ltmp2, .Ltmp5, .Ltmp4, .Ltmp7, .Ltmp6, .Ltmp9, .Ltmp8, .Ltmp11, .Ltmp10, .Ltmp13, .Ltmp12, .Ltmp15, .Ltmp14, .Ltmp21, .Ltmp16, .Ltmp18, .Ltmp17, .LFT0, .Ltmp19, .LFT1, .Ltmp20, .LFT2, .LFT3, .Ltmp22, .LFT4, .Ltmp23, .LFT5, .Ltmp24, .LFT6, .Ltmp25, .LFT7 CHECK: BB Layout : .LBB00, .Ltmp1, .Ltmp0, .Ltmp3, .Ltmp2, .Ltmp5, .Ltmp4, .Ltmp7, .Ltmp6, .Ltmp9, .Ltmp8, .Ltmp11, .Ltmp10, .Ltmp13, .Ltmp12, .Ltmp15, .Ltmp14, .Ltmp21, .Ltmp16, .Ltmp18, .Ltmp17, .LFT0, .Ltmp19, .LFT1, .Ltmp20, .LFT2, .LFT3, .Ltmp22, .LFT4, .Ltmp23, .LFT5, .Ltmp24, .LFT6, .Ltmp25, .LFT7
CHECK: Binary Function "SolveCubic" CHECK: Binary Function "SolveCubic"
CHECK: BB Layout : .LBB01, .Ltmp26, .LFT12, .Ltmp37, .Ltmp36, .Ltmp35, .Ltmp34, .LFT8, .LFT9, .Ltmp33, .Ltmp28, .LFT10, .Ltmp27, .Ltmp32, .Ltmp31, .Ltmp30, .Ltmp29 CHECK: BB Layout : .LBB01, .Ltmp26, .LFT12, .Ltmp37, .Ltmp36, .Ltmp35, .Ltmp34, .LFT8, .LFT9, .Ltmp33, .Ltmp28, .LFT10, .Ltmp27, .Ltmp32, .Ltmp31, .Ltmp30, .Ltmp29
CHECK: Binary Function "usqrt" CHECK: Binary Function "usqrt"
CHECK: BB Layout : .LBB02, .Ltmp38, .Ltmp39, .LFT13, .LFT14 CHECK: BB Layout : .LBB02, .Ltmp38, .Ltmp39, .LFT13, .LFT14

bolt/test/X86/line-number.test

# Verifies that the extraction of DWARF line number information is correct. # Verifies that the extraction of DWARF line number information is correct.
RUN: %clangxx %cxxflags %S/Inputs/linenumber.cpp -g -o %t RUN: %clangxx %cxxflags %S/Inputs/linenumber.cpp -g -o %t
RUN: llvm-bolt %t -o /dev/null -print-reordered -update-debug-sections \ RUN: llvm-bolt %t -o /dev/null --print-reordered --update-debug-sections \
RUN: -print-debug-info -reorder-blocks=reverse -sequential-disassembly 2>&1 \ RUN: --print-debug-info --reorder-blocks=reverse --sequential-disassembly \
RUN: | FileCheck %s RUN: 2>&1 | FileCheck %s
# Local variable in f() # Local variable in f()
CHECK: movl $0xbeef, -0x4(%rbp) # debug line {{.*}}linenumber.cpp:9 CHECK: movl $0xbeef, -0x4(%rbp) # debug line {{.*}}linenumber.cpp:9
# Checks that a branch instruction that is inserted by BOLT does not have # Checks that a branch instruction that is inserted by BOLT does not have
# debug line info associated with it. # debug line info associated with it.
CHECK-NOT: jmp .LFT0 # debug line {{.*}}linenumber.cpp:1 CHECK-NOT: jmp .LFT0 # debug line {{.*}}linenumber.cpp:1
# Call to f() in g() # Call to f() in g()
CHECK: callq _Z1fv{{.*}} # debug line {{.*}}linenumber.cpp:19 CHECK: callq _Z1fv{{.*}} # debug line {{.*}}linenumber.cpp:19
# Calls to g() and f() in main # Calls to g() and f() in main
CHECK: callq _Z1gv{{.*}} # debug line {{.*}}linenumber.cpp:23 CHECK: callq _Z1gv{{.*}} # debug line {{.*}}linenumber.cpp:23
CHECK: callq _Z1fv{{.*}} # debug line {{.*}}linenumber.cpp:23 CHECK: callq _Z1fv{{.*}} # debug line {{.*}}linenumber.cpp:23

bolt/test/X86/loop-inversion-pass.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: link_fdata %s %t.o %t.fdata2 "FDATA2" # RUN: link_fdata %s %t.o %t.fdata2 "FDATA2"
# RUN: link_fdata %s %t.o %t.fdata3 "FDATA3" # RUN: link_fdata %s %t.o %t.fdata3 "FDATA3"
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -data %t.fdata -reorder-blocks=ext-tsp -print-finalized \ # RUN: llvm-bolt %t.exe --data %t.fdata --reorder-blocks=ext-tsp \
# RUN: -loop-inversion-opt -o %t.out | FileCheck %s # RUN: --print-finalized --loop-inversion-opt -o %t.out \
# RUN: llvm-bolt %t.exe -data %t.fdata2 -reorder-blocks=ext-tsp -print-finalized \ # RUN: | FileCheck %s
# RUN: -loop-inversion-opt -o %t.out2 | FileCheck --check-prefix="CHECK2" %s # RUN: llvm-bolt %t.exe --data %t.fdata2 --reorder-blocks=ext-tsp \
# RUN: llvm-bolt %t.exe -data %t.fdata3 -reorder-blocks=none -print-finalized \ # RUN: --print-finalized --loop-inversion-opt -o %t.out2 \
# RUN: -loop-inversion-opt -o %t.out3 | FileCheck --check-prefix="CHECK3" %s # RUN: | FileCheck --check-prefix="CHECK2" %s
# RUN: llvm-bolt %t.exe --data %t.fdata3 --reorder-blocks=none \
# RUN: --print-finalized --loop-inversion-opt -o %t.out3 \
# RUN: | FileCheck --check-prefix="CHECK3" %s
# The case where the loop is used: # The case where the loop is used:
# FDATA: 1 main 2 1 main #.J1# 0 420 # FDATA: 1 main 2 1 main #.J1# 0 420
# FDATA: 1 main b 1 main #.Jloop# 0 420 # FDATA: 1 main b 1 main #.Jloop# 0 420
# FDATA: 1 main b 1 main d 0 1 # FDATA: 1 main b 1 main d 0 1
# CHECK: BB Layout : .LBB00, .Ltmp0, .Ltmp1, .LFT0 # CHECK: BB Layout : .LBB00, .Ltmp0, .Ltmp1, .LFT0
# The case where the loop is unused: # The case where the loop is unused:
Show All 28 Lines

bolt/test/X86/loop-nest.test

# Verifies that llvm-bolt prints correct loop information. # Verifies that llvm-bolt prints correct loop information.
RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
RUN: %p/Inputs/loop_nest.s -o %t.o RUN: %p/Inputs/loop_nest.s -o %t.o
RUN: link_fdata %p/Inputs/loop_nest.s %t.o %t.fdata --nmtool llvm-nm RUN: link_fdata %p/Inputs/loop_nest.s %t.o %t.fdata --nmtool llvm-nm
RUN: llvm-strip --strip-unneeded %t.o RUN: llvm-strip --strip-unneeded %t.o
RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
RUN: llvm-bolt %t.exe -o %t -data=%t.fdata \ RUN: llvm-bolt %t.exe -o %t --data=%t.fdata \
RUN: -print-cfg -print-loops -sequential-disassembly -lite=0 2>&1 | FileCheck %s RUN: --print-cfg --print-loops --sequential-disassembly --lite=0 \
RUN: 2>&1 | FileCheck %s
CHECK: Binary Function "main{{.*}}" after building cfg CHECK: Binary Function "main{{.*}}" after building cfg
CHECK: Loop Info for Function "main{{.*}}" CHECK: Loop Info for Function "main{{.*}}"
CHECK: Outer loop header: .Ltmp[[#MAIN_OUTER_HDR:]] CHECK: Outer loop header: .Ltmp[[#MAIN_OUTER_HDR:]]
CHECK-NEXT: Loop basic blocks: .Ltmp[[#MAIN_OUTER_HDR]], .Ltmp[[#]] CHECK-NEXT: Loop basic blocks: .Ltmp[[#MAIN_OUTER_HDR]], .Ltmp[[#]]
CHECK: Binary Function "foo" after building cfg CHECK: Binary Function "foo" after building cfg
CHECK: Loop Info for Function "foo" CHECK: Loop Info for Function "foo"
CHECK: Outer loop header: .Ltmp[[#FOO_OUTER_HDR:]] CHECK: Outer loop header: .Ltmp[[#FOO_OUTER_HDR:]]
CHECK-NEXT: Loop basic blocks: .Ltmp[[#FOO_OUTER_HDR]], .Ltmp[[#]], .LFT[[#]], .Ltmp[[#]], .Ltmp[[#FOO_INNER_HDR:]], .Ltmp[[#]], .Ltmp[[#FOO_INNER_BB:]] CHECK-NEXT: Loop basic blocks: .Ltmp[[#FOO_OUTER_HDR]], .Ltmp[[#]], .LFT[[#]], .Ltmp[[#]], .Ltmp[[#FOO_INNER_HDR:]], .Ltmp[[#]], .Ltmp[[#FOO_INNER_BB:]]
CHECK: Nested loop header: .Ltmp[[#FOO_INNER_HDR]] CHECK: Nested loop header: .Ltmp[[#FOO_INNER_HDR]]
CHECK-NEXT: Loop basic blocks: .Ltmp[[#FOO_INNER_HDR]], .Ltmp[[#FOO_INNER_BB]] CHECK-NEXT: Loop basic blocks: .Ltmp[[#FOO_INNER_HDR]], .Ltmp[[#FOO_INNER_BB]]

bolt/test/X86/lto-name-match.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe # RUN: %clang %cflags %t.o -o %t.exe
# RUN: llvm-bolt %t.exe -data %t.fdata -o /dev/null | FileCheck %s # RUN: llvm-bolt %t.exe --data %t.fdata -o /dev/null | FileCheck %s
## Check that profile is correctly matched by functions with variable suffixes. ## Check that profile is correctly matched by functions with variable suffixes.
## E.g., LTO-generated name foo.llvm.123 should match foo.llvm.*. ## E.g., LTO-generated name foo.llvm.123 should match foo.llvm.*.
# CHECK: 4 out of {{.*}} functions in the binary {{.*}} have non-empty execution profile # CHECK: 4 out of {{.*}} functions in the binary {{.*}} have non-empty execution profile
# CHECK-NOT: profile for {{.*}} objects was ignored # CHECK-NOT: profile for {{.*}} objects was ignored
.globl _start .globl _start
Show All 34 Lines

bolt/test/X86/no-entry-reordering.test

# Verifies that llvm-bolt reordering heuristic does not allocate a BB before the # Verifies that llvm-bolt reordering heuristic does not allocate a BB before the
# entry point even if there is a hot edge from a block to entry point # entry point even if there is a hot edge from a block to entry point
RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %S/Inputs/entry.s -o %t.o RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %S/Inputs/entry.s -o %t.o
RUN: link_fdata %S/Inputs/entry.s %t.o %t.fdata --nmtool llvm-nm RUN: link_fdata %S/Inputs/entry.s %t.o %t.fdata --nmtool llvm-nm
RUN: llvm-strip --strip-unneeded %t.o RUN: llvm-strip --strip-unneeded %t.o
RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib
RUN: llvm-bolt %t.exe -data %t.fdata -o /dev/null -reorder-blocks=normal \ RUN: llvm-bolt %t.exe --data %t.fdata -o /dev/null --reorder-blocks=normal \
RUN: -funcs=_start -print-reordered -sequential-disassembly | FileCheck %s RUN: --funcs=_start --print-reordered --sequential-disassembly | FileCheck %s
CHECK: BB Layout : .LBB00, {{.*}} CHECK: BB Layout : .LBB00, {{.*}}

bolt/test/X86/no-output.test

# This script checks that BOLT is able to work in dry run mode (no output) # This script checks that BOLT is able to work in dry run mode (no output)
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -print-profile-stats -o /dev/null \ # RUN: llvm-bolt %t.exe --print-profile-stats -o /dev/null \
# RUN: -data %t.fdata | FileCheck %s # RUN: --data %t.fdata | FileCheck %s
.text .text
.globl main .globl main
.type main, %function .type main, %function
.p2align 4 .p2align 4
main: main:
# FDATA: 0 [unknown] 0 1 main 0 0 510 # FDATA: 0 [unknown] 0 1 main 0 0 510
pushq %rbp pushq %rbp
Show All 10 Lines

bolt/test/X86/plt-sec-8-byte.test

## Check correctness of processing .plt.sec with 8-byte entries. ## Check correctness of processing .plt.sec with 8-byte entries.
# RUN: yaml2obj %p/Inputs/plt-sec-8-byte.yaml &> %t.exe # RUN: yaml2obj %p/Inputs/plt-sec-8-byte.yaml &> %t.exe
# RUN: llvm-bolt %t.exe -print-cfg -print-only=main -o %t.out | FileCheck %s # RUN: llvm-bolt %t.exe --print-cfg --print-only=main -o %t.out | FileCheck %s
CHECK: callq printf@PLT CHECK: callq printf@PLT
CHECK: callq exit@PLT CHECK: callq exit@PLT

bolt/test/X86/plt-sec.test

## Check that llvm-bolt correctly identifies functions in .plt.sec ## Check that llvm-bolt correctly identifies functions in .plt.sec
# RUN: yaml2obj %p/Inputs/plt-sec.yaml &> %t.exe # RUN: yaml2obj %p/Inputs/plt-sec.yaml &> %t.exe
# RUN: llvm-bolt %t.exe -print-cfg -print-only=foo -o %t.out | FileCheck %s # RUN: llvm-bolt %t.exe --print-cfg --print-only=foo -o %t.out | FileCheck %s
## Check that llvm-bolt correctly identifies functions in .plt.got that has ## Check that llvm-bolt correctly identifies functions in .plt.got that has
## endbr instruction at the start of its entries. ## endbr instruction at the start of its entries.
# RUN: yaml2obj %p/Inputs/plt-got-sec.yaml &> %t.exe # RUN: yaml2obj %p/Inputs/plt-got-sec.yaml &> %t.exe
# RUN: llvm-bolt %t.exe -print-cfg -print-only=foo -o %t.out | FileCheck %s # RUN: llvm-bolt %t.exe --print-cfg --print-only=foo -o %t.out | FileCheck %s
## The only call instruction in function foo() should be a call to PLT. ## The only call instruction in function foo() should be a call to PLT.
CHECK: callq puts@PLT CHECK: callq puts@PLT

bolt/test/X86/reader.test

# This script checks that DataReader in llvm-bolt is reading data correctly # This script checks that DataReader in llvm-bolt is reading data correctly
RUN: yaml2obj %p/Inputs/blarge.yaml &> %t.exe RUN: yaml2obj %p/Inputs/blarge.yaml &> %t.exe
RUN: llvm-bolt %t.exe -o /dev/null -data %p/Inputs/blarge.fdata --dump-data \ RUN: llvm-bolt %t.exe -o /dev/null --data %p/Inputs/blarge.fdata --dump-data \
RUN: 2>&1 | sort | FileCheck %s -check-prefix=CHECK RUN: 2>&1 | sort | FileCheck %s -check-prefix=CHECK
CHECK: main 1105 SolveCubic 0 0 151 CHECK: main 1105 SolveCubic 0 0 151
CHECK: main 1161 main 1130 0 27 CHECK: main 1161 main 1130 0 27
CHECK: main 1313 usqrt 0 0 168 CHECK: main 1313 usqrt 0 0 168
CHECK: main 1494 main 1423 0 1001 CHECK: main 1494 main 1423 0 1001

bolt/test/X86/relaxed-tailcall.test

# Check that tail calls can be 2 bytes in the output binary. # Check that tail calls can be 2 bytes in the output binary.
RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-unknown -o %t.o \ RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-unknown -o %t.o \
RUN: %S/Inputs/relaxed_tc.s RUN: %S/Inputs/relaxed_tc.s
RUN: ld.lld %t.o -o %t.exe -q RUN: ld.lld %t.o -o %t.exe -q
RUN: llvm-bolt %t.exe -relocs -o %t RUN: llvm-bolt %t.exe --relocs -o %t
RUN: llvm-objdump -d --disassemble-symbols=foo %t | FileCheck %s RUN: llvm-objdump -d --disassemble-symbols=foo %t | FileCheck %s
CHECK: eb 00 jmp {{.*}} <bar> CHECK: eb 00 jmp {{.*}} <bar>

bolt/test/X86/remove-unused.test

# Verifies that llvm-bolt is able to remove dead basic blocks. Also check that # Verifies that llvm-bolt is able to remove dead basic blocks. Also check that
# the BB reordering ignores dead BBs. # the BB reordering ignores dead BBs.
RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %S/Inputs/entry.s -o %t.o RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %S/Inputs/entry.s -o %t.o
RUN: link_fdata %S/Inputs/entry.s %t.o %t.fdata --nmtool llvm-nm RUN: link_fdata %S/Inputs/entry.s %t.o %t.fdata --nmtool llvm-nm
RUN: llvm-strip --strip-unneeded %t.o RUN: llvm-strip --strip-unneeded %t.o
RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib
RUN: llvm-bolt %t.exe -data %t.fdata -o %t -funcs=_start \ RUN: llvm-bolt %t.exe --data %t.fdata -o %t --funcs=_start \
RUN: -eliminate-unreachable -reorder-blocks=none \ RUN: --eliminate-unreachable --reorder-blocks=none \
RUN: -print-finalized -sequential-disassembly 2>&1 | FileCheck %s RUN: --print-finalized --sequential-disassembly 2>&1 | FileCheck %s
# Optimized # Optimized
CHECK: BB Layout : .LBB00, .Ltmp0, .Ltmp2, .Ltmp3, .Ltmp4, .Ltmp5, .Ltmp6, .Ltmp7, .Ltmp8, .Ltmp9, .Ltmp10, .Ltmp11 CHECK: BB Layout : .LBB00, .Ltmp0, .Ltmp2, .Ltmp3, .Ltmp4, .Ltmp5, .Ltmp6, .Ltmp7, .Ltmp8, .Ltmp9, .Ltmp10, .Ltmp11

bolt/test/X86/rodata-simpl-loads.test

# Check for the simplification of .rodata loads. # Check for the simplification of .rodata loads.
RUN: %clang %cflags %p/Inputs/rodata_simpl_loads.s -o %t.exe RUN: %clang %cflags %p/Inputs/rodata_simpl_loads.s -o %t.exe
RUN: llvm-bolt %t.exe -o %t -simplify-rodata-loads RUN: llvm-bolt %t.exe -o %t --simplify-rodata-loads
RUN: FileCheck %s --check-prefix=ORIGINAL --input-file %p/Inputs/rodata_simpl_loads.s RUN: FileCheck %s --check-prefix=ORIGINAL --input-file %p/Inputs/rodata_simpl_loads.s
RUN: llvm-objdump -d %t --print-imm-hex --disassemble-symbols=main | FileCheck %s RUN: llvm-objdump -d %t --print-imm-hex --disassemble-symbols=main | FileCheck %s
CHECK: Disassembly of section .text: CHECK: Disassembly of section .text:
CHECK: <main>: CHECK: <main>:
# check that the following rip-relative operands have been # check that the following rip-relative operands have been
# replaced with immediates # replaced with immediates
Show All 32 Lines

bolt/test/X86/sctc-bug.test

# Check that we don't accidentally optimize out a tail call. # Check that we don't accidentally optimize out a tail call.
RUN: %clang %cflags %S/Inputs/sctc_bug.s -o %t RUN: %clang %cflags %S/Inputs/sctc_bug.s -o %t
RUN: llvm-bolt %t -o /dev/null -funcs=main -print-after-lowering 2>&1 | FileCheck %s RUN: llvm-bolt %t -o /dev/null --funcs=main --print-after-lowering \
RUN: 2>&1 | FileCheck %s
CHECK: jp .L{{.*}} CHECK: jp .L{{.*}}
CHECK: je foo # TAILCALL CHECK: je foo # TAILCALL
CHECK: xorl %eax, %eax CHECK: xorl %eax, %eax
CHECK: retq CHECK: retq

bolt/test/X86/sctc-bug2.test

# Check that conditional tail call is not treated as a regular tail call by SCTC. # Check that conditional tail call is not treated as a regular tail call by SCTC.
RUN: %clang %cflags %S/Inputs/sctc_bug2.s -o %t RUN: %clang %cflags %S/Inputs/sctc_bug2.s -o %t
RUN: llvm-bolt %t -o /dev/null -funcs=main -print-after-lowering \ RUN: llvm-bolt %t -o /dev/null --funcs=main --print-after-lowering \
RUN: -sequential-disassembly 2>&1 | FileCheck %s RUN: --sequential-disassembly 2>&1 | FileCheck %s
CHECK: .LFT1 CHECK: .LFT1
CHECK: ja .Ltmp0 CHECK: ja .Ltmp0

bolt/test/X86/sctc-bug3.test

# Check that we don't accidentally optimize out a tail call. # Check that we don't accidentally optimize out a tail call.
RUN: %clang %cflags %S/Inputs/sctc_bug3.s -o %t RUN: %clang %cflags %S/Inputs/sctc_bug3.s -o %t
RUN: llvm-bolt %t -o /dev/null -funcs=main -print-after-lowering \ RUN: llvm-bolt %t -o /dev/null --funcs=main --print-after-lowering \
RUN: -sequential-disassembly 2>&1 | FileCheck %s RUN: --sequential-disassembly 2>&1 | FileCheck %s
CHECK: .LBB00 (1 instructions, align : 1) CHECK: .LBB00 (1 instructions, align : 1)
CHECK: cmpq %rdi, 0x0 CHECK: cmpq %rdi, 0x0
# Check that .Ltmp0 does not have a deleted predecessor. # Check that .Ltmp0 does not have a deleted predecessor.
CHECK: .Ltmp0 (1 instructions, align : 1) CHECK: .Ltmp0 (1 instructions, align : 1)
CHECK: Predecessors: .LBB00 CHECK: Predecessors: .LBB00
# Tail call. # Tail call.
CHECK: jmp foo CHECK: jmp foo

bolt/test/X86/shared-abbrev.s

# RUN: rm -rf %t # RUN: rm -rf %t
# RUN: mkdir %t # RUN: mkdir %t
# RUN: llvm-mc -filetype=obj -triple=x86_64 -dwarf-version=4 %s -o %t/shared-abbrev.o # RUN: llvm-mc -filetype=obj -triple=x86_64 -dwarf-version=4 %s -o %t/shared-abbrev.o
# RUN: %clang %cflags %t/shared-abbrev.o -o %t/shared-abbrev.exe # RUN: %clang %cflags %t/shared-abbrev.o -o %t/shared-abbrev.exe
# RUN: llvm-bolt %t/shared-abbrev.exe -o %t/shared-abbrev.exe.bolt -update-debug-sections # RUN: llvm-bolt %t/shared-abbrev.exe -o %t/shared-abbrev.exe.bolt --update-debug-sections
# RUN: llvm-dwarfdump --debug-info %t/shared-abbrev.exe.bolt | FileCheck %s # RUN: llvm-dwarfdump --debug-info %t/shared-abbrev.exe.bolt | FileCheck %s
# CHECK: 0x00000000: # CHECK: 0x00000000:
# CHECK-SAME: abbr_offset = 0x0000 # CHECK-SAME: abbr_offset = 0x0000
# CHECK-EMPTY: # CHECK-EMPTY:
# CHECK-NEXT: DW_TAG_compile_unit # CHECK-NEXT: DW_TAG_compile_unit
# CHECK-NEXT: DW_AT_stmt_list # CHECK-NEXT: DW_AT_stmt_list
# CHECK-NEXT: DW_AT_low_pc # CHECK-NEXT: DW_AT_low_pc
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

bolt/test/X86/shrinkwrapping-and-rsp.s

# This checks that shrink wrapping does attempt at accessing stack elements # This checks that shrink wrapping does attempt at accessing stack elements
# using RSP when the function is aligning RSP and changing offsets. # using RSP when the function is aligning RSP and changing offsets.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib
# RUN: llvm-bolt %t.exe -o %t.out -data %t.fdata \ # RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata \
# RUN: -frame-opt=all -simplify-conditional-tail-calls=false \ # RUN: --frame-opt=all --simplify-conditional-tail-calls=false \
# RUN: -eliminate-unreachable=false | FileCheck %s # RUN: --eliminate-unreachable=false | FileCheck %s
# Here we have a function that aligns the stack at prologue. Stack pointer # Here we have a function that aligns the stack at prologue. Stack pointer
# analysis can't try to infer offset positions after AND because that depends # analysis can't try to infer offset positions after AND because that depends
# on the runtime value of the stack pointer of callee (whether it is misaligned # on the runtime value of the stack pointer of callee (whether it is misaligned
# or not). # or not).
.globl _start .globl _start
.type _start, %function .type _start, %function
_start: _start:
Show All 34 Lines

bolt/test/X86/shrinkwrapping-critedge.s

# This reproduces a bug with shrink wrapping when trying to split critical # This reproduces a bug with shrink wrapping when trying to split critical
# edges originating at the same basic block. # edges originating at the same basic block.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q -nostdlib # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q -nostdlib
# RUN: llvm-bolt %t.exe -relocs -o %t.out -data %t.fdata \ # RUN: llvm-bolt %t.exe --relocs -o %t.out --data %t.fdata \
# RUN: -frame-opt=all -simplify-conditional-tail-calls=false \ # RUN: --frame-opt=all --simplify-conditional-tail-calls=false \
# RUN: -eliminate-unreachable=false # RUN: --eliminate-unreachable=false
.globl _start .globl _start
_start: _start:
# FDATA: 0 [unknown] 0 1 _start 0 0 1 # FDATA: 0 [unknown] 0 1 _start 0 0 1
push %rbx push %rbx
je b je b
c: c:
pop %rbx pop %rbx
Show All 14 Lines

bolt/test/X86/shrinkwrapping-insertcfi.s

# This test reproduces the issue with inserting updated CFI in shrink wrapping # This test reproduces the issue with inserting updated CFI in shrink wrapping
# into the first basic block. # into the first basic block.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib
# RUN: llvm-bolt %t.exe -o %t.out -data %t.fdata -frame-opt=all -lite=0 \ # RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata --frame-opt=all --lite=0 \
# RUN: -print-fop 2>&1 | FileCheck %s # RUN: --print-fop 2>&1 | FileCheck %s
# Check shrink wrapping results: # Check shrink wrapping results:
# CHECK: BOLT-INFO: Shrink wrapping moved 0 spills inserting load/stores and 1 spills inserting push/pops # CHECK: BOLT-INFO: Shrink wrapping moved 0 spills inserting load/stores and 1 spills inserting push/pops
# Check that CFI is successfully inserted into the first basic block: # Check that CFI is successfully inserted into the first basic block:
# CHECK: Binary Function "_start" after frame-optimizer # CHECK: Binary Function "_start" after frame-optimizer
# CHECK: .LBB00 (2 instructions, align : 1) # CHECK: .LBB00 (2 instructions, align : 1)
# CHECK-NEXT: Entry Point # CHECK-NEXT: Entry Point
Show All 22 Lines

bolt/test/X86/shrinkwrapping-pop-order.s

# This test reproduces a POP reordering issue in shrink wrapping where we would # This test reproduces a POP reordering issue in shrink wrapping where we would
# incorrectly put a store after a load (instead of before) when having multiple # incorrectly put a store after a load (instead of before) when having multiple
# insertions at the same point. Check that the order is correct in this test. # insertions at the same point. Check that the order is correct in this test.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib
# RUN: llvm-bolt %t.exe -o %t.out -data %t.fdata -frame-opt=all -lite=0 \ # RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata --frame-opt=all --lite=0 \
# RUN: -print-fop 2>&1 | FileCheck %s # RUN: --print-fop 2>&1 | FileCheck %s
.globl _start .globl _start
_start: _start:
.cfi_startproc .cfi_startproc
# FDATA: 0 [unknown] 0 1 _start 0 0 6 # FDATA: 0 [unknown] 0 1 _start 0 0 6
je a je a
b: jne _start b: jne _start
# FDATA: 1 _start #b# 1 _start #c# 0 3 # FDATA: 1 _start #b# 1 _start #c# 0 3
Show All 25 Lines

bolt/test/X86/shrinkwrapping-popf.s

# This test checks that POPF will not crash our frame analysis pass # This test checks that POPF will not crash our frame analysis pass
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q -nostdlib
# RUN: llvm-bolt %t.exe -o %t.out -data %t.fdata -frame-opt=all -lite=0 # RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata --frame-opt=all --lite=0
.globl _start .globl _start
_start: _start:
.cfi_startproc .cfi_startproc
# FDATA: 0 [unknown] 0 1 _start 0 0 6 # FDATA: 0 [unknown] 0 1 _start 0 0 6
je a je a
b: jne _start b: jne _start
Show All 14 Lines

bolt/test/X86/shrinkwrapping.test

# Verifies that llvm-bolt updates CFI correctly after # Verifies that llvm-bolt updates CFI correctly after
# shrink-wrapping when optimizing a function without # shrink-wrapping when optimizing a function without
# frame pointers. # frame pointers.
RUN: %clangxx %cxxflags -no-pie %S/Inputs/exc4sw.S -o %t.exe -Wl,-q RUN: %clangxx %cxxflags -no-pie %S/Inputs/exc4sw.S -o %t.exe -Wl,-q
RUN: llvm-bolt %t.exe -o %t -relocs -frame-opt=all \ RUN: llvm-bolt %t.exe -o %t --relocs --frame-opt=all \
RUN: -data=%p/Inputs/exc4sw.fdata -reorder-blocks=cache 2>&1 | \ RUN: --data=%p/Inputs/exc4sw.fdata --reorder-blocks=cache 2>&1 | \
RUN: FileCheck %s --check-prefix=CHECK-BOLT RUN: FileCheck %s --check-prefix=CHECK-BOLT
RUN: llvm-objdump --dwarf=frames %t.exe | grep -A20 -e \ RUN: llvm-objdump --dwarf=frames %t.exe | grep -A20 -e \
RUN: `llvm-nm --numeric-sort %t.exe | grep main | tail -n 1 | \ RUN: `llvm-nm --numeric-sort %t.exe | grep main | tail -n 1 | \
RUN: cut -f1 -d' ' | tail -c9` 2>&1 | FileCheck %s --check-prefix=CHECK-INPUT RUN: cut -f1 -d' ' | tail -c9` 2>&1 | FileCheck %s --check-prefix=CHECK-INPUT
RUN: llvm-objdump --dwarf=frames %t | grep -A20 -e \ RUN: llvm-objdump --dwarf=frames %t | grep -A20 -e \
RUN: `llvm-nm --numeric-sort %t | grep main | tail -n 1 | cut -f1 -d' ' | \ RUN: `llvm-nm --numeric-sort %t | grep main | tail -n 1 | cut -f1 -d' ' | \
Show All 30 Lines

bolt/test/X86/split-func-icf.s

# This reproduces an issue where two cold fragments are folded into one, so the # This reproduces an issue where two cold fragments are folded into one, so the
# fragment has two parents. # fragment has two parents.
# The fragment is only reachable through a jump table, so all functions must be # The fragment is only reachable through a jump table, so all functions must be
# ignored. # ignored.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.out -lite=0 -v=1 2>&1 | FileCheck %s # RUN: llvm-bolt %t.exe -o %t.out --lite=0 -v=1 2>&1 | FileCheck %s
# CHECK-NOT: unclaimed PC-relative relocations left in data # CHECK-NOT: unclaimed PC-relative relocations left in data
# CHECK-DAG: BOLT-INFO: marking main2.cold.1(*2) as a fragment of main # CHECK-DAG: BOLT-INFO: marking main2.cold.1(*2) as a fragment of main
# CHECK-DAG: BOLT-INFO: marking main2.cold.1(*2) as a fragment of main2 # CHECK-DAG: BOLT-INFO: marking main2.cold.1(*2) as a fragment of main2
# CHECK-DAG: BOLT-WARNING: Ignoring main2 # CHECK-DAG: BOLT-WARNING: Ignoring main2
# CHECK-DAG: BOLT-WARNING: Ignoring main # CHECK-DAG: BOLT-WARNING: Ignoring main
# CHECK-DAG: BOLT-WARNING: Ignoring main2.cold.1(*2) # CHECK-DAG: BOLT-WARNING: Ignoring main2.cold.1(*2)
# CHECK: BOLT-WARNING: ignored 3 functions due to cold fragments # CHECK: BOLT-WARNING: ignored 3 functions due to cold fragments
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

bolt/test/X86/split-func-jump-table-fragment-noparent.s

# This reproduces a bug with jump table identification where jump table has # This reproduces a bug with jump table identification where jump table has
# entries pointing to code in function and its cold fragment. # entries pointing to code in function and its cold fragment.
# The fragment is only reachable through jump table. # The fragment is only reachable through jump table.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.out -lite=0 -v=1 2>&1 | FileCheck %s # RUN: llvm-bolt %t.exe -o %t.out --lite=0 -v=1 2>&1 | FileCheck %s
# CHECK-NOT: unclaimed PC-relative relocations left in data # CHECK-NOT: unclaimed PC-relative relocations left in data
# CHECK: BOLT-INFO: marking main.cold.1 as a fragment of main # CHECK: BOLT-INFO: marking main.cold.1 as a fragment of main
.text .text
.globl main .globl main
.type main, %function .type main, %function
.p2align 2 .p2align 2
main: main:
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

bolt/test/X86/split-func-jump-table-fragment-reverse.s

# This reproduces a bug with jump table identification where jump table has # This reproduces a bug with jump table identification where jump table has
# entries pointing to code in function and its cold fragment. # entries pointing to code in function and its cold fragment.
# The fragment is only reachable through jump table. # The fragment is only reachable through jump table.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.out -lite=0 -v=1 2>&1 | FileCheck %s # RUN: llvm-bolt %t.exe -o %t.out --lite=0 -v=1 2>&1 | FileCheck %s
# CHECK-NOT: unclaimed PC-relative relocations left in data # CHECK-NOT: unclaimed PC-relative relocations left in data
# CHECK: BOLT-INFO: marking main.cold as a fragment of main # CHECK: BOLT-INFO: marking main.cold as a fragment of main
.text .text
.globl _start .globl _start
.type _start, %function .type _start, %function
_start: _start:
callq main.cold callq main.cold
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

bolt/test/X86/split-func-jump-table-fragment.s

# This reproduces a bug with jump table identification where jump table has # This reproduces a bug with jump table identification where jump table has
# entries pointing to code in function and its cold fragment. # entries pointing to code in function and its cold fragment.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.out -lite=0 -v=1 2>&1 | FileCheck %s # RUN: llvm-bolt %t.exe -o %t.out --lite=0 -v=1 2>&1 | FileCheck %s
# CHECK-NOT: unclaimed PC-relative relocations left in data # CHECK-NOT: unclaimed PC-relative relocations left in data
# CHECK: BOLT-INFO: marking main.cold.1 as a fragment of main # CHECK: BOLT-INFO: marking main.cold.1 as a fragment of main
.text .text
.globl main .globl main
.type main, %function .type main, %function
.p2align 2 .p2align 2
main: main:
Show All 40 Lines

bolt/test/X86/srol-bug.test

# RUN: yaml2obj %p/Inputs/srol-bug-input.yaml &> %t.exe # RUN: yaml2obj %p/Inputs/srol-bug-input.yaml &> %t.exe
# RUN: llvm-bolt %t.exe -simplify-rodata-loads -print-finalized -relocs=0 \ # RUN: llvm-bolt %t.exe --simplify-rodata-loads --print-finalized --relocs=0 \
# RUN: -print-disasm -o %t.out | FileCheck %s # RUN: --print-disasm -o %t.out | FileCheck %s
CHECK: Binary Function "myfunc" after disassembly { CHECK: Binary Function "myfunc" after disassembly {
CHECK: 00000000: addl mydata(%rip), %edx CHECK: 00000000: addl mydata(%rip), %edx
CHECK: 00000006: subl mydata(%rip), %edx CHECK: 00000006: subl mydata(%rip), %edx
CHECK: 0000000c: andl mydata(%rip), %edx CHECK: 0000000c: andl mydata(%rip), %edx
CHECK: 00000012: orl mydata(%rip), %edx CHECK: 00000012: orl mydata(%rip), %edx
CHECK: 00000018: xorl mydata(%rip), %edx CHECK: 00000018: xorl mydata(%rip), %edx
CHECK: 0000001f: movzwl mydata(%rip), %edx CHECK: 0000001f: movzwl mydata(%rip), %edx
Show All 32 Lines

bolt/test/X86/symtab-secondary-entries.test

# Check that secondary entry points are updated correctly in the ELF symtab # Check that secondary entry points are updated correctly in the ELF symtab
RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
RUN: %p/Inputs/user-order.S -o %t.o RUN: %p/Inputs/user-order.S -o %t.o
RUN: ld.lld %t.o --emit-relocs --nostdlib -o %t.exe RUN: ld.lld %t.o --emit-relocs --nostdlib -o %t.exe
RUN: llvm-bolt %t.exe -o %t -reorder-functions=user \ RUN: llvm-bolt %t.exe -o %t --reorder-functions=user \
RUN: -function-order=%p/Inputs/order.txt RUN: --function-order=%p/Inputs/order.txt
RUN: llvm-readelf -Ws %t | cut -d':' -f2- | sort -u | FileCheck %s RUN: llvm-readelf -Ws %t | cut -d':' -f2- | sort -u | FileCheck %s
CHECK: [[#]] FUNC GLOBAL DEFAULT [[#NDX:]] _start CHECK: [[#]] FUNC GLOBAL DEFAULT [[#NDX:]] _start
CHECK: [[#]] FUNC GLOBAL DEFAULT [[#NDX]] main CHECK: [[#]] FUNC GLOBAL DEFAULT [[#NDX]] main
CHECK: [[#]] FUNC LOCAL DEFAULT [[#NDX]] _a CHECK: [[#]] FUNC LOCAL DEFAULT [[#NDX]] _a
CHECK: [[#]] FUNC GLOBAL DEFAULT [[#NDX]] _b CHECK: [[#]] FUNC GLOBAL DEFAULT [[#NDX]] _b
CHECK: [[#]] FUNC GLOBAL DEFAULT [[#NDX]] _f CHECK: [[#]] FUNC GLOBAL DEFAULT [[#NDX]] _f
# The following are all secondary entries of _f # The following are all secondary entries of _f
CHECK: 0 FUNC GLOBAL DEFAULT [[#NDX]] _c CHECK: 0 FUNC GLOBAL DEFAULT [[#NDX]] _c
CHECK: 0 FUNC GLOBAL DEFAULT [[#NDX]] _d CHECK: 0 FUNC GLOBAL DEFAULT [[#NDX]] _d
CHECK: 0 FUNC GLOBAL DEFAULT [[#NDX]] _e CHECK: 0 FUNC GLOBAL DEFAULT [[#NDX]] _e

bolt/test/X86/tail-duplication-cache.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: link_fdata %s %t.o %t.fdata2 "FDATA2" # RUN: link_fdata %s %t.o %t.fdata2 "FDATA2"
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -data %t.fdata -reorder-blocks=none -print-finalized \ # RUN: llvm-bolt %t.exe --data %t.fdata --reorder-blocks=none \
# RUN: -tail-duplication=cache -o %t.out | FileCheck %s # RUN: --print-finalized --tail-duplication=cache -o %t.out | FileCheck %s
# RUN: llvm-bolt %t.exe -data %t.fdata2 -reorder-blocks=none -print-finalized \ # RUN: llvm-bolt %t.exe --data %t.fdata2 --reorder-blocks=none \
# RUN: -tail-duplication=cache -o %t.out2 | FileCheck --check-prefix="CHECK2" %s # RUN: --print-finalized --tail-duplication=cache -o %t.out2 \
# RUN: | FileCheck --check-prefix="CHECK2" %s
# A test where the tail is duplicated to eliminate an uncoditional jump # A test where the tail is duplicated to eliminate an uncoditional jump
# FDATA: 1 main #.BB0_br# 1 main #.BB4# 0 100 # FDATA: 1 main #.BB0_br# 1 main #.BB4# 0 100
# FDATA: 1 main #.BB0_br# 1 main #.BB1# 0 100 # FDATA: 1 main #.BB0_br# 1 main #.BB1# 0 100
# FDATA: 1 main #.BB1_br# 1 main #.BB3# 0 50 # FDATA: 1 main #.BB1_br# 1 main #.BB3# 0 50
# FDATA: 1 main #.BB1_br# 1 main #.BB2# 0 50 # FDATA: 1 main #.BB1_br# 1 main #.BB2# 0 50
# FDATA: 1 main #.BB3_br# 1 main #.BB2# 0 50 # FDATA: 1 main #.BB3_br# 1 main #.BB2# 0 50
# CHECK: BOLT-INFO: tail duplication modified 1 ({{.*}}%) functions; duplicated 1 blocks (13 bytes) responsible for 50 dynamic executions ({{.*}}% of all block executions) # CHECK: BOLT-INFO: tail duplication modified 1 ({{.*}}%) functions; duplicated 1 blocks (13 bytes) responsible for 50 dynamic executions ({{.*}}% of all block executions)
Show All 40 Lines

bolt/test/X86/tail-duplication-cacheline.s

# This reproduces a bug in TailDuplication::isInCacheLine # This reproduces a bug in TailDuplication::isInCacheLine
# with accessing BlockLayout past bounds (unreachable blocks). # with accessing BlockLayout past bounds (unreachable blocks).
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q -nostdlib # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q -nostdlib
# RUN: llvm-bolt %t.exe -o %t.out -data %t.fdata -relocs \ # RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata --relocs \
# RUN: -tail-duplication=aggressive # RUN: --tail-duplication=aggressive
.globl _start .globl _start
_start: _start:
jmp d jmp d
je _start je _start
movl %esi, %edi movl %esi, %edi
d: d:
jmpq *JT0(,%rcx,8) jmpq *JT0(,%rcx,8)
# FDATA: 1 _start #d# 1 _start #e# 1 3 # FDATA: 1 _start #d# 1 _start #e# 1 3
Show All 11 Lines

bolt/test/X86/tail-duplication-complex.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -data %t.fdata -print-finalized \ # RUN: llvm-bolt %t.exe --data %t.fdata --print-finalized \
# RUN: -tail-duplication=moderate -tail-duplication-minimum-offset 1 -o %t.out | FileCheck %s # RUN: --tail-duplication=moderate --tail-duplication-minimum-offset=1 \
# RUN: -o %t.out | FileCheck %s
# FDATA: 1 main f 1 main 19 0 10 # FDATA: 1 main f 1 main 19 0 10
# FDATA: 1 main f 1 main 11 0 13 # FDATA: 1 main f 1 main 11 0 13
# FDATA: 1 main 17 1 main 3c 0 10 # FDATA: 1 main 17 1 main 3c 0 10
# FDATA: 1 main 39 1 main 3c 0 10 # FDATA: 1 main 39 1 main 3c 0 10
# CHECK: tail duplication modified 1 ({{.*}}%) functions; duplicated 1 blocks ({{.*}} bytes) responsible for {{.*}} dynamic executions ({{.*}} of all block executions) # CHECK: tail duplication modified 1 ({{.*}}%) functions; duplicated 1 blocks ({{.*}} bytes) responsible for {{.*}} dynamic executions ({{.*}} of all block executions)
# CHECK: BB Layout : .LBB00, .Ltmp0, .Ltail-dup0, .Ltmp1, .Ltmp2 # CHECK: BB Layout : .LBB00, .Ltmp0, .Ltail-dup0, .Ltmp1, .Ltmp2
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

bolt/test/X86/tail-duplication-jt.s

# This reproduces a bug in tail duplication when aggressiveCodeToDuplicate # This reproduces a bug in tail duplication when aggressiveCodeToDuplicate
# fails to handle a block with a jump table. # fails to handle a block with a jump table.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clangxx %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clangxx %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.out -data %t.fdata -relocs \ # RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata --relocs \
# RUN: -tail-duplication=aggressive \ # RUN: --tail-duplication=aggressive \
# RUN: -print-cfg | FileCheck %s # RUN: --print-cfg | FileCheck %s
# CHECK: Jump table {{.*}} for function a at {{.*}} with a total count of 3 # CHECK: Jump table {{.*}} for function a at {{.*}} with a total count of 3
.globl main .globl main
main: main:
.globl a .globl a
.type a, %function .type a, %function
a: a:
.cfi_startproc .cfi_startproc
b: b:
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

bolt/test/X86/tail-duplication-pass.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -data %t.fdata -reorder-blocks=ext-tsp -print-finalized \ # RUN: llvm-bolt %t.exe --data %t.fdata --reorder-blocks=ext-tsp \
# RUN: -tail-duplication=moderate -tail-duplication-minimum-offset=1 -o %t.out | FileCheck %s # RUN: --print-finalized --tail-duplication=moderate \
# RUN: --tail-duplication-minimum-offset=1 -o %t.out | FileCheck %s
# FDATA: 1 main 2 1 main #.BB2# 0 10 # FDATA: 1 main 2 1 main #.BB2# 0 10
# FDATA: 1 main 4 1 main #.BB2# 0 20 # FDATA: 1 main 4 1 main #.BB2# 0 20
# CHECK: BOLT-INFO: tail duplication modified 1 ({{.*}}%) functions; duplicated 1 blocks (1 bytes) responsible for {{.*}} dynamic executions ({{.*}}% of all block executions) # CHECK: BOLT-INFO: tail duplication modified 1 ({{.*}}%) functions; duplicated 1 blocks (1 bytes) responsible for {{.*}} dynamic executions ({{.*}}% of all block executions)
# CHECK: BB Layout : .LBB00, .Ltail-dup0, .Ltmp0, .Ltmp1 # CHECK: BB Layout : .LBB00, .Ltail-dup0, .Ltmp0, .Ltmp1
.text .text
.globl main .globl main
Show All 12 Lines

bolt/test/X86/tail-duplication-prop-bug.s

# This reproduces a bug in aggressive tail duplication/copy propagation. # This reproduces a bug in aggressive tail duplication/copy propagation.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: ld.lld %t.o -o %t.exe -q -nostdlib # RUN: ld.lld %t.o -o %t.exe -q -nostdlib
# RUN: llvm-bolt %t.exe -o %t.out -data %t.fdata -relocs \ # RUN: llvm-bolt %t.exe -o %t.out --data %t.fdata --relocs \
# RUN: -tail-duplication=aggressive \ # RUN: --tail-duplication=aggressive \
# RUN: -tail-duplication-const-copy-propagation=1 # RUN: --tail-duplication-const-copy-propagation=1
.text .text
.type a, %function .type a, %function
.globl a .globl a
a: a:
.cfi_startproc .cfi_startproc
jmpq *JT(,%rcx,8) jmpq *JT(,%rcx,8)
b: b:
Show All 26 Lines

bolt/test/X86/tailcall-traps.test

# Tests the peephole that adds trap instructions following indirect tail calls. # Tests the peephole that adds trap instructions following indirect tail calls.
RUN: %clang %cflags %p/Inputs/tailcall_traps.s -o %t.exe RUN: %clang %cflags %p/Inputs/tailcall_traps.s -o %t.exe
RUN: llvm-bolt %t.exe -o %t -peepholes=tailcall-traps \ RUN: llvm-bolt %t.exe -o %t --peepholes=tailcall-traps \
RUN: -print-peepholes -funcs=foo,bar 2>&1 | FileCheck %s RUN: --print-peepholes --funcs=foo,bar 2>&1 | FileCheck %s
CHECK: Binary Function "foo" CHECK: Binary Function "foo"
CHECK: jmpl *%rax # TAILCALL CHECK: jmpl *%rax # TAILCALL
CHECK: ud2 CHECK: ud2
CHECK: End of Function "foo" CHECK: End of Function "foo"
CHECK: Binary Function "bar" CHECK: Binary Function "bar"
CHECK: jmp moo # TAILCALL CHECK: jmp moo # TAILCALL
CHECK: End of Function "bar" CHECK: End of Function "bar"

bolt/test/X86/tailcall.test

# Verifies that llvm-bolt recognizes tailcalls and mark them # Verifies that llvm-bolt recognizes tailcalls and mark them
# in control flow graph. # in control flow graph.
RUN: %clang %cflags %S/Inputs/tailcall.s -o %t.exe RUN: %clang %cflags %S/Inputs/tailcall.s -o %t.exe
RUN: llvm-bolt %t.exe -o /dev/null -print-cfg 2>&1 | FileCheck %s RUN: llvm-bolt %t.exe -o /dev/null --print-cfg 2>&1 | FileCheck %s
CHECK: Binary Function "foo" CHECK: Binary Function "foo"
CHECK: jmp bar # TAILCALL CHECK: jmp bar # TAILCALL
CHECK: End of Function "foo" CHECK: End of Function "foo"
CHECK: Binary Function "bar" CHECK: Binary Function "bar"
CHECK: jmp baz # TAILCALL CHECK: jmp baz # TAILCALL
CHECK: End of Function "bar" CHECK: End of Function "bar"

bolt/test/X86/vararg.test

# Check that a function that references a label inside itself, # Check that a function that references a label inside itself,
# as in the case of vararg handling code generated by GCC 4.5 # as in the case of vararg handling code generated by GCC 4.5
# and earlier, is recognized as multi-entry. # and earlier, is recognized as multi-entry.
REQUIRES: x86_64-linux REQUIRES: x86_64-linux
RUN: %clangxx %cxxflags -no-pie %p/../Inputs/vararg.s -o %t -Wl,-q RUN: %clangxx %cxxflags -no-pie %p/../Inputs/vararg.s -o %t -Wl,-q
RUN: llvm-bolt %t -o /dev/null -print-cfg -print-only=.*printf.* |& FileCheck %s RUN: llvm-bolt %t -o /dev/null --print-cfg --print-only=.*printf.* |& FileCheck %s
CHECK: IsSimple : 0 CHECK: IsSimple : 0
CHECK: Entry Point CHECK: Entry Point
CHECK: Entry Point CHECK: Entry Point

bolt/test/X86/zero-sized-object.s

# Check that references to local (unnamed) objects below are not # Check that references to local (unnamed) objects below are not
# treated as references relative to zero-sized A object. # treated as references relative to zero-sized A object.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -print-cfg \ # RUN: llvm-bolt %t.exe --print-cfg \
# RUN: -print-only=main -o %t.out | FileCheck %s # RUN: --print-only=main -o %t.out | FileCheck %s
.file "rust_bug.c" .file "rust_bug.c"
.section .rodata .section .rodata
.LC0: .LC0:
.string "0" .string "0"
.LC1: .LC1:
.string "1" .string "1"
.LC2: .LC2:
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

bolt/test/bolt-icf.test

# Check for the replacement of calls to identical functions. # Check for the replacement of calls to identical functions.
REQUIRES: system-linux REQUIRES: system-linux
RUN: %clangxx %p/Inputs/bolt_icf.cpp -g -Wl,-q -o %t.exe RUN: %clangxx %p/Inputs/bolt_icf.cpp -g -Wl,-q -o %t.exe
RUN: llvm-bolt %t.exe -relocs -o %t -icf 2>&1 | FileCheck %s RUN: llvm-bolt %t.exe --relocs -o %t --icf 2>&1 | FileCheck %s
RUN: llvm-nm -n %t | FileCheck %s -check-prefix=CHECK-SYM RUN: llvm-nm -n %t | FileCheck %s -check-prefix=CHECK-SYM
CHECK: BOLT-INFO: ICF folded [[#]] out of [[#]] functions in [[#]] passes. CHECK: BOLT-INFO: ICF folded [[#]] out of [[#]] functions in [[#]] passes.
# Check that symbols are updated correctly in the symbol table # Check that symbols are updated correctly in the symbol table
CHECK-SYM-DAG: [[#%x,FIZ:]] T _Z3fizv CHECK-SYM-DAG: [[#%x,FIZ:]] T _Z3fizv
CHECK-SYM-DAG: [[#FIZ]] T _Z3fazv CHECK-SYM-DAG: [[#FIZ]] T _Z3fazv
CHECK-SYM-DAG: [[#%x,ZIP:]] T _Z3zipv CHECK-SYM-DAG: [[#%x,ZIP:]] T _Z3zipv
CHECK-SYM-DAG: [[#ZIP]] T _Z3zapv CHECK-SYM-DAG: [[#ZIP]] T _Z3zapv
CHECK-SYM-DAG: [[#%x,FOO:]] T _Z3foov CHECK-SYM-DAG: [[#%x,FOO:]] T _Z3foov
CHECK-SYM-DAG: [[#FOO]] T _Z3barv CHECK-SYM-DAG: [[#FOO]] T _Z3barv

bolt/test/cache+-deprecated.test

REQUIRES: system-linux REQUIRES: system-linux
RUN: %clangxx %p/Inputs/bolt_icf.cpp -g -Wl,-q -o %t.exe RUN: %clangxx %p/Inputs/bolt_icf.cpp -g -Wl,-q -o %t.exe
RUN: llvm-bolt %t.exe -reorder-blocks=cache+ -relocs -o %t 2>&1 | FileCheck %s RUN: llvm-bolt %t.exe --reorder-blocks=cache+ --relocs -o %t 2>&1 | FileCheck %s
CHECK: '-reorder-blocks=cache+' is deprecated, please use '-reorder-blocks=ext-tsp' instead CHECK: '-reorder-blocks=cache+' is deprecated, please use '-reorder-blocks=ext-tsp' instead

bolt/test/invalid-profile.test

# Check that llvm-bolt detects bad profile data and aborts # Check that llvm-bolt detects bad profile data and aborts
RUN: %clang %S/Inputs/icf-jump-tables.c -o %t RUN: %clang %S/Inputs/icf-jump-tables.c -o %t
RUN: not llvm-bolt %t -o %t.bolt -data %t 2>&1 | FileCheck %s RUN: not llvm-bolt %t -o %t.bolt --data %t 2>&1 | FileCheck %s
CHECK: no valid profile data found CHECK: no valid profile data found

bolt/test/keep-aranges.test

# Check that BOLT generates .debug_aranges section for an input # Check that BOLT generates .debug_aranges section for an input
# where it was removed when .gdb_index was generated. # where it was removed when .gdb_index was generated.
REQUIRES: system-linux REQUIRES: system-linux
RUN: %clang %cflags %S/Inputs/icf_baz.c %S/Inputs/icf_main.c -Wl,--icf=all,--gdb-index \ RUN: %clang %cflags %S/Inputs/icf_baz.c %S/Inputs/icf_main.c -Wl,--icf=all,--gdb-index \
RUN: -g -o %t.exe -fuse-ld=lld RUN: -g -o %t.exe -fuse-ld=lld
RUN: llvm-bolt %t.exe -o %t -update-debug-sections -keep-aranges RUN: llvm-bolt %t.exe -o %t --update-debug-sections --keep-aranges
RUN: llvm-dwarfdump -debug-aranges %t | FileCheck %s RUN: llvm-dwarfdump -debug-aranges %t | FileCheck %s
CHECK: Address Range Header: length = {{.*}}, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00 CHECK: Address Range Header: length = {{.*}}, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00

bolt/test/no-relocs.test

# Verifies that input without relocations is rejected in relocs mode. # Verifies that input without relocations is rejected in relocs mode.
RUN: %clang %cflags %S/Inputs/icf-jump-tables.c -o %t RUN: %clang %cflags %S/Inputs/icf-jump-tables.c -o %t
RUN: not llvm-bolt %t -o /dev/null -relocs 2>&1 | FileCheck %s RUN: not llvm-bolt %t -o /dev/null --relocs 2>&1 | FileCheck %s
CHECK: BOLT-ERROR: relocations against code are missing from the input file. CHECK: BOLT-ERROR: relocations against code are missing from the input file.

bolt/test/non-empty-debug-line.test

# Verifies that BOLT emits DWARF line table with the same size if # Verifies that BOLT emits DWARF line table with the same size if
# no functions with debug info were modified. # no functions with debug info were modified.
REQUIRES: system-linux REQUIRES: system-linux
RUN: %clang %cflags %S/Inputs/hello.c -g -o %t RUN: %clang %cflags %S/Inputs/hello.c -g -o %t
RUN: llvm-bolt %t -o %t1 -update-debug-sections -funcs=_start RUN: llvm-bolt %t -o %t1 --update-debug-sections --funcs=_start
RUN: llvm-readobj -S %t > %t2 RUN: llvm-readobj -S %t > %t2
RUN: llvm-readobj -S %t1 >> %t2 RUN: llvm-readobj -S %t1 >> %t2
RUN: FileCheck %s --input-file %t2 RUN: FileCheck %s --input-file %t2
# Check the input and grab .debug_line size. # Check the input and grab .debug_line size.
CHECK: File: CHECK: File:
CHECK: Name: .debug_line CHECK: Name: .debug_line
CHECK: Size: [[SIZE:[0-9]+]] CHECK: Size: [[SIZE:[0-9]+]]
# Verify .debug_line size is the same after BOLT. # Verify .debug_line size is the same after BOLT.
CHECK: File: CHECK: File:
CHECK: Name: .debug_line CHECK: Name: .debug_line
CHECK: Size: CHECK: Size:
CHECK-SAME: [[SIZE]] CHECK-SAME: [[SIZE]]

bolt/test/runtime/AArch64/adrrelaxationpass.s

# The second and third ADR instructions are non-local to functions # The second and third ADR instructions are non-local to functions
# and must be replaced with ADRP + ADD by BOLT # and must be replaced with ADRP + ADD by BOLT
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -adr-relaxation=true # RUN: llvm-bolt %t.exe -o %t.bolt --adr-relaxation=true
# RUN: llvm-objdump -d --disassemble-symbols=main %t.bolt | FileCheck %s # RUN: llvm-objdump -d --disassemble-symbols=main %t.bolt | FileCheck %s
# RUN: %t.bolt # RUN: %t.bolt
.data .data
.align 8 .align 8
.global Gvar .global Gvar
Gvar: .xword 0x0 Gvar: .xword 0x0
.global Gvar2 .global Gvar2
Show All 32 Lines

bolt/test/runtime/AArch64/constant-island-relocations.s

# This test checks that the address stored in constant island # This test checks that the address stored in constant island
# is updated after llvm-bolt # is updated after llvm-bolt
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -use-old-text=0 -lite=0 -trap-old-code # RUN: llvm-bolt %t.exe -o %t.bolt --use-old-text=0 --lite=0 --trap-old-code
# RUN: %t.bolt # RUN: %t.bolt
.text .text
.align 4 .align 4
.global test .global test
.type test, %function .type test, %function
test: test:
mov x0, #0 mov x0, #0
Show All 12 Lines

bolt/test/runtime/AArch64/controlflow.s

# This test checks relocations for control-flow instructions # This test checks relocations for control-flow instructions
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple aarch64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -use-old-text=0 -lite=0 -trap-old-code # RUN: llvm-bolt %t.exe -o %t.bolt --use-old-text=0 --lite=0 --trap-old-code
# RUN: %t.bolt # RUN: %t.bolt
.macro panic .macro panic
.panic\@: .panic\@:
mov x0, #0 mov x0, #0
br x0 br x0
.endm .endm
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

bolt/test/runtime/AArch64/issue177.s

# This reproduces issue 177 from our github repo # This reproduces issue 177 from our github repo
# AARCH64_MOVW_UABS_G* relocations handling # AARCH64_MOVW_UABS_G* relocations handling
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: %clang %cflags -no-pie %s -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %s -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -o %t.bolt -use-old-text=0 -lite=0 -trap-old-code # RUN: llvm-bolt %t.exe -o %t.bolt --use-old-text=0 --lite=0 --trap-old-code
# RUN: %t.bolt # RUN: %t.bolt
.text .text
.align 4 .align 4
.global test .global test
.type test, %function .type test, %function
test: test:
mov x0, xzr mov x0, xzr
Show All 13 Lines

bolt/test/runtime/X86/basic-instrumentation.test

# Try to instrument a very fast test. Input bin will not execute any code during # Try to instrument a very fast test. Input bin will not execute any code during
# runtime besides returning zero in main, so it is a good trivial case. # runtime besides returning zero in main, so it is a good trivial case.
REQUIRES: system-linux REQUIRES: system-linux
RUN: %clang %p/Inputs/basic-instrumentation.s -Wl,-q -o %t.exe RUN: %clang %p/Inputs/basic-instrumentation.s -Wl,-q -o %t.exe
RUN: llvm-bolt %t.exe -o %t -instrument \ RUN: llvm-bolt %t.exe -o %t --instrument \
RUN: -instrumentation-file=%t \ RUN: --instrumentation-file=%t \
RUN: -instrumentation-file-append-pid RUN: --instrumentation-file-append-pid
# Execute program to collect profile # Execute program to collect profile
RUN: rm %t.*.fdata || echo Nothing to remove RUN: rm %t.*.fdata || echo Nothing to remove
RUN: %t RUN: %t
# Profile should be written to %t.PID.fdata, check it # Profile should be written to %t.PID.fdata, check it
RUN: mv %t.*.fdata %t.fdata RUN: mv %t.*.fdata %t.fdata
RUN: cat %t.fdata | FileCheck -check-prefix=CHECK %s RUN: cat %t.fdata | FileCheck -check-prefix=CHECK %s
# Check BOLT works with this profile # Check BOLT works with this profile
RUN: llvm-bolt %t.exe -data %t.fdata -o %t.2 -reorder-blocks=cache RUN: llvm-bolt %t.exe --data %t.fdata -o %t.2 --reorder-blocks=cache
# The instrumented profile should at least say main was called once # The instrumented profile should at least say main was called once
CHECK: main 0 0 1{{$}} CHECK: main 0 0 1{{$}}

bolt/test/runtime/X86/exceptions-instrumentation.test

# Check instrumentation of C++ code with exceptions # Check instrumentation of C++ code with exceptions
REQUIRES: system-linux REQUIRES: system-linux
RUN: %clangxx %cxxflags -no-pie %p/Inputs/exceptions_split.cpp -Wl,-q -g -o %t_exc_split RUN: %clangxx %cxxflags -no-pie %p/Inputs/exceptions_split.cpp -Wl,-q -g -o %t_exc_split
RUN: llvm-bolt %t_exc_split -o %t.exc -instrument -instrumentation-file=%t.fdata RUN: llvm-bolt %t_exc_split -o %t.exc --instrument --instrumentation-file=%t.fdata
RUN: %t.exc arg1 arg2 arg3 RUN: %t.exc arg1 arg2 arg3
RUN: llvm-bolt %t_exc_split -o %t.exc.bolted -data %t.fdata \ RUN: llvm-bolt %t_exc_split -o %t.exc.bolted --data %t.fdata \
RUN: -reorder-blocks=ext-tsp -reorder-functions=hfsort+ -split-functions=3 \ RUN: --reorder-blocks=ext-tsp --reorder-functions=hfsort+ \
RUN: -split-eh=1 | FileCheck --check-prefix=EXCEPTIONS %s RUN: --split-functions=3 --split-eh=1 \
RUN: | FileCheck --check-prefix=EXCEPTIONS %s
EXCEPTIONS-NOT: invalid (possibly stale) profile EXCEPTIONS-NOT: invalid (possibly stale) profile
# Check that cold symbols are emitted with local binding. # Check that cold symbols are emitted with local binding.
RUN: llvm-readelf -Ws %t.exc.bolted | FileCheck %s --check-prefix=CHECK-READELF RUN: llvm-readelf -Ws %t.exc.bolted | FileCheck %s --check-prefix=CHECK-READELF
CHECK-READELF: FUNC LOCAL DEFAULT {{.*}} main.cold.{{.*}} CHECK-READELF: FUNC LOCAL DEFAULT {{.*}} main.cold.{{.*}}
RUN: cat %t.fdata | FileCheck --check-prefix=EXCEPTIONS-FDATA %s RUN: cat %t.fdata | FileCheck --check-prefix=EXCEPTIONS-FDATA %s
# Check that the printf "catch" ran exactly 10 times # Check that the printf "catch" ran exactly 10 times
EXCEPTIONS-FDATA: 1 main {{.*}} 1 _Znwm@PLT 0 0 10 EXCEPTIONS-FDATA: 1 main {{.*}} 1 _Znwm@PLT 0 0 10

bolt/test/runtime/X86/exceptions-pic.test

# Verify that C++ exceptions work after binary re-writing # Verify that C++ exceptions work after binary re-writing
REQUIRES: x86_64-linux REQUIRES: x86_64-linux
RUN: %clangxx -fpic -Wl,-q %S/Inputs/exception4.cpp -o %t.pic RUN: %clangxx -fpic -Wl,-q %S/Inputs/exception4.cpp -o %t.pic
RUN: llvm-bolt %t.pic -o %t && %t 2>&1 | FileCheck %s RUN: llvm-bolt %t.pic -o %t && %t 2>&1 | FileCheck %s
RUN: llvm-bolt -relocs -use-old-text %t.pic -o %t && %t 2>&1 | FileCheck %s RUN: llvm-bolt --relocs --use-old-text %t.pic -o %t && %t 2>&1 | FileCheck %s
CHECK: catch 2 CHECK: catch 2
CHECK-NEXT: catch 1 CHECK-NEXT: catch 1
CHECK-NEXT: caught ExcC CHECK-NEXT: caught ExcC

bolt/test/runtime/X86/exceptions-run.test

# Verify the exceptions handling work after moving code. # Verify the exceptions handling work after moving code.
# The input has dummy nops that are removed by bolt. # The input has dummy nops that are removed by bolt.
REQUIRES: x86_64-linux REQUIRES: x86_64-linux
RUN: %clangxx -g %S/Inputs/exception3.cpp -o %t.exe RUN: %clangxx -g %S/Inputs/exception3.cpp -o %t.exe
RUN: llvm-bolt -align-blocks=0 %t.exe -o %t && %t 2>&1 | FileCheck %s RUN: llvm-bolt --align-blocks=0 %t.exe -o %t && %t 2>&1 | FileCheck %s
RUN: llvm-bolt -reorder-blocks=reverse -align-blocks=0 %t.exe -o %t && %t 2>&1 \ RUN: llvm-bolt --reorder-blocks=reverse --align-blocks=0 %t.exe -o %t && %t 2>&1 \
RUN: | FileCheck %s RUN: | FileCheck %s
CHECK: catch 2 CHECK: catch 2
CHECK-NEXT: catch 1 CHECK-NEXT: catch 1
CHECK-NEXT: caught ExcC CHECK-NEXT: caught ExcC

bolt/test/runtime/X86/fdata-escape-chars.ll

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
} }
; REQUIRES: system-linux,bolt-runtime ; REQUIRES: system-linux,bolt-runtime
; RUN: llc %s -o %t.s ; RUN: llc %s -o %t.s
; RUN: %clang %cflags -O0 %t.s -o %t.exe -Wl,-q ; RUN: %clang %cflags -O0 %t.s -o %t.exe -Wl,-q
; RUN: llvm-objcopy --redefine-syms=%p/Inputs/fdata-escape-chars-syms.txt %t.exe ; RUN: llvm-objcopy --redefine-syms=%p/Inputs/fdata-escape-chars-syms.txt %t.exe
; ;
; RUN: llvm-bolt %t.exe -o %t.exe.instrumented -instrument \ ; RUN: llvm-bolt %t.exe -o %t.exe.instrumented --instrument \
; RUN: -instrumentation-file=%t.fdata ; RUN: --instrumentation-file=%t.fdata
; RUN: %t.exe.instrumented ; RUN: %t.exe.instrumented
; RUN: cat %t.fdata | \ ; RUN: cat %t.fdata | \
; RUN: FileCheck --check-prefix="FDATA_CHECK" %s ; RUN: FileCheck --check-prefix="FDATA_CHECK" %s
; RUN: llvm-bolt %t.exe -o %t.fdata.exe -data %t.fdata -print-finalized | \ ; RUN: llvm-bolt %t.exe -o %t.fdata.exe --data %t.fdata --print-finalized | \
; RUN: FileCheck --check-prefix="INSTR_CHECK" %s ; RUN: FileCheck --check-prefix="INSTR_CHECK" %s
; ;
; RUN: link_fdata %p/Inputs/fdata-escape-chars.txt %t.exe %t.pre "PREAGR" ; RUN: link_fdata %p/Inputs/fdata-escape-chars.txt %t.exe %t.pre "PREAGR"
; RUN: perf2bolt %t.exe -o %t.pre.fdata -pa -p %t.pre ; RUN: perf2bolt %t.exe -o %t.pre.fdata -pa -p %t.pre
; RUN: cat %t.pre.fdata | FileCheck --check-prefix="PREAGR_FDATA_CHECK" %s ; RUN: cat %t.pre.fdata | FileCheck --check-prefix="PREAGR_FDATA_CHECK" %s
; RUN: llvm-bolt %t.exe -o %t.pre.fdata.exe -data %t.pre.fdata -print-finalized | \ ; RUN: llvm-bolt %t.exe -o %t.pre.fdata.exe --data %t.pre.fdata --print-finalized | \
; RUN: FileCheck --check-prefix="PREAGR_CHECK" %s ; RUN: FileCheck --check-prefix="PREAGR_CHECK" %s
; FDATA_CHECK: 1 symb\ backslash\\ {{([[:xdigit:]]+)}} 1 symb\ whitespace 0 0 2 ; FDATA_CHECK: 1 symb\ backslash\\ {{([[:xdigit:]]+)}} 1 symb\ whitespace 0 0 2
; FDATA_CHECK: 1 main {{([[:xdigit:]]+)}} 1 symb\ whitespace 0 0 1 ; FDATA_CHECK: 1 main {{([[:xdigit:]]+)}} 1 symb\ whitespace 0 0 1
; FDATA_CHECK: 1 main {{([[:xdigit:]]+)}} 1 symb\ backslash\\ 0 0 2 ; FDATA_CHECK: 1 main {{([[:xdigit:]]+)}} 1 symb\ backslash\\ 0 0 2
; INSTR_CHECK: Binary Function "symb whitespace" ; INSTR_CHECK: Binary Function "symb whitespace"
; INSTR_CHECK: Exec Count : 4 ; INSTR_CHECK: Exec Count : 4
Show All 23 Lines

bolt/test/runtime/X86/fix-branches-jrcxz.s

# Test BOLT does not crash by trying to change the direction of a JRCXZ # Test BOLT does not crash by trying to change the direction of a JRCXZ
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -relocs=1 -reorder-blocks=ext-tsp -print-finalized \ # RUN: llvm-bolt %t.exe --relocs=1 --reorder-blocks=ext-tsp --print-finalized \
# RUN: -o %t.out -data %t.fdata | FileCheck %s # RUN: -o %t.out --data %t.fdata | FileCheck %s
# RUN: %t.out 1 2 3 # RUN: %t.out 1 2 3
# CHECK: BOLT-INFO # CHECK: BOLT-INFO
.text .text
.section .text.startup,"ax",@progbits .section .text.startup,"ax",@progbits
.p2align 5,,31 .p2align 5,,31
.globl main .globl main
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

bolt/test/runtime/X86/hot-end-symbol.s

# This reproduces a bug where BOLT would read __hot_end as # This reproduces a bug where BOLT would read __hot_end as
# the name of a function even when -hot-text is used, which # the name of a function even when -hot-text is used, which
# means BOLT will emit another __hot_end label, eventually # means BOLT will emit another __hot_end label, eventually
# asserting due to a symbol redefinition in MCStreamer. # asserting due to a symbol redefinition in MCStreamer.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -relocs=1 -hot-text -reorder-functions=hfsort \ # RUN: llvm-bolt %t.exe --relocs=1 --hot-text --reorder-functions=hfsort \
# RUN: -data %t.fdata -o %t.out | FileCheck %s # RUN: --data %t.fdata -o %t.out | FileCheck %s
# RUN: %t.out 1 # RUN: %t.out 1
# CHECK: BOLT-INFO: setting __hot_end to # CHECK: BOLT-INFO: setting __hot_end to
# RUN: llvm-nm -n %t.exe | FileCheck %s --check-prefix=CHECK-INPUT # RUN: llvm-nm -n %t.exe | FileCheck %s --check-prefix=CHECK-INPUT
# RUN: llvm-nm -n %t.out | FileCheck %s --check-prefix=CHECK-OUTPUT # RUN: llvm-nm -n %t.out | FileCheck %s --check-prefix=CHECK-OUTPUT
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

bolt/test/runtime/X86/indirect-goto-pie.test

# Check llvm-bolt processes binaries compiled from sources that use indirect goto. # Check llvm-bolt processes binaries compiled from sources that use indirect goto.
REQUIRES: x86_64-linux REQUIRES: x86_64-linux
RUN: %clang %S/Inputs/indirect_goto.c -o %t -fpic -pie -Wl,-q RUN: %clang %S/Inputs/indirect_goto.c -o %t -fpic -pie -Wl,-q
RUN: llvm-bolt %t -o %t.bolt -relocs=1 -print-cfg -print-only=main \ RUN: llvm-bolt %t -o %t.bolt --relocs=1 --print-cfg --print-only=main \
RUN: |& FileCheck %s RUN: |& FileCheck %s
# The test fails as we don't update corresponding dynamic relocations. # The test fails as we don't update corresponding dynamic relocations.
RUN: not %t.bolt RUN: not %t.bolt
CHECK: jmpq *%rax # UNKNOWN CONTROL FLOW CHECK: jmpq *%rax # UNKNOWN CONTROL FLOW

bolt/test/runtime/X86/instrumentation-dup-jts.s

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
# REQUIRES: system-linux,bolt-runtime # REQUIRES: system-linux,bolt-runtime
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -instrument -instrumentation-file=%t.fdata \ # RUN: llvm-bolt %t.exe --instrument --instrumentation-file=%t.fdata \
# RUN: -o %t.instrumented # RUN: -o %t.instrumented
# Instrumented program needs to finish returning zero # Instrumented program needs to finish returning zero
# RUN: %t.instrumented 120 # RUN: %t.instrumented 120
# Test that the instrumented data makes sense # Test that the instrumented data makes sense
# RUN: llvm-bolt %t.exe -o %t.bolted -data %t.fdata \ # RUN: llvm-bolt %t.exe -o %t.bolted --data %t.fdata \
# RUN: -reorder-blocks=ext-tsp -reorder-functions=hfsort+ \ # RUN: --reorder-blocks=ext-tsp --reorder-functions=hfsort+ \
# RUN: -print-only=interp -print-finalized | FileCheck %s # RUN: --print-only=interp --print-finalized | FileCheck %s
# RUN: %t.bolted 120 # RUN: %t.bolted 120
# Check that our two indirect jumps are recorded in the fdata file and that # Check that our two indirect jumps are recorded in the fdata file and that
# each has its own independent profile # each has its own independent profile
# CHECK: Successors: .Ltmp1 (mispreds: 0, count: 1), .Ltmp0 (mispreds: 0, count: 0), .Ltmp2 (mispreds: 0, count: 0) # CHECK: Successors: .Ltmp1 (mispreds: 0, count: 1), .Ltmp0 (mispreds: 0, count: 0), .Ltmp2 (mispreds: 0, count: 0)
# CHECK: Successors: .Ltmp0 (mispreds: 0, count: 1), .Ltmp2 (mispreds: 0, count: 1), .Ltmp1 (mispreds: 0, count: 0) # CHECK: Successors: .Ltmp0 (mispreds: 0, count: 1), .Ltmp2 (mispreds: 0, count: 1), .Ltmp1 (mispreds: 0, count: 0)
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

bolt/test/runtime/X86/instrumentation-ind-calls.s

# This reproduces a bug with instrumentation when trying to count calls # This reproduces a bug with instrumentation when trying to count calls
# when the target address is computed with a referece to the stack pointer. # when the target address is computed with a referece to the stack pointer.
# Our instrumentation code uses the stack to save registers to be # Our instrumentation code uses the stack to save registers to be
# transparent with the instrumented code, but we end up updating the stack # transparent with the instrumented code, but we end up updating the stack
# pointer while doing so, which affects this target address calculation. # pointer while doing so, which affects this target address calculation.
# The solution is to temporarily fix RSP. Check that we correctly instrument # The solution is to temporarily fix RSP. Check that we correctly instrument
# these cases. # these cases.
# REQUIRES: system-linux,bolt-runtime # REQUIRES: system-linux,bolt-runtime
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -instrument -instrumentation-file=%t.fdata \ # RUN: llvm-bolt %t.exe --instrument --instrumentation-file=%t.fdata \
# RUN: -o %t.instrumented # RUN: -o %t.instrumented
# Instrumented program needs to finish returning zero # Instrumented program needs to finish returning zero
# RUN: %t.instrumented arg1 arg2 # RUN: %t.instrumented arg1 arg2
# Test that the instrumented data makes sense # Test that the instrumented data makes sense
# RUN: llvm-bolt %t.exe -o %t.bolted -data %t.fdata \ # RUN: llvm-bolt %t.exe -o %t.bolted --data %t.fdata \
# RUN: -reorder-blocks=ext-tsp -reorder-functions=hfsort+ \ # RUN: --reorder-blocks=ext-tsp --reorder-functions=hfsort+ \
# RUN: -print-only=main -print-finalized | FileCheck %s # RUN: --print-only=main --print-finalized | FileCheck %s
# RUN: %t.bolted arg1 arg2 # RUN: %t.bolted arg1 arg2
# Check that our indirect call has 1 hit recorded in the fdata file and that # Check that our indirect call has 1 hit recorded in the fdata file and that
# this was processed correctly by BOLT # this was processed correctly by BOLT
# CHECK: callq *0x18(%rsp) # CallProfile: 1 (0 misses) : # CHECK: callq *0x18(%rsp) # CallProfile: 1 (0 misses) :
# CHECK-NEXT: { targetFunc: 1 (0 misses) } # CHECK-NEXT: { targetFunc: 1 (0 misses) }
Show All 34 Lines

bolt/test/runtime/X86/instrumentation-indirect.c

Show All 34 Linesint main(int argc, char **argv) {
return 0; return 0;
} }
/* /*
REQUIRES: system-linux && lit-max-individual-test-time REQUIRES: system-linux && lit-max-individual-test-time
RUN: %clang %cflags %s -o %t.exe -Wl,-q -pie -fpie RUN: %clang %cflags %s -o %t.exe -Wl,-q -pie -fpie
RUN: llvm-bolt %t.exe -instrument -instrumentation-file=%t.fdata \ RUN: llvm-bolt %t.exe --instrument --instrumentation-file=%t.fdata \
RUN: -instrumentation-wait-forks=1 -conservative-instrumentation \ RUN: --instrumentation-wait-forks=1 --conservative-instrumentation \
RUN: -o %t.instrumented_conservative RUN: -o %t.instrumented_conservative
# Instrumented program needs to finish returning zero # Instrumented program needs to finish returning zero
RUN: %t.instrumented_conservative | FileCheck %s -check-prefix=CHECK-OUTPUT RUN: %t.instrumented_conservative | FileCheck %s -check-prefix=CHECK-OUTPUT
RUN: llvm-bolt %t.exe -instrument -instrumentation-file=%t.fdata \ RUN: llvm-bolt %t.exe --instrument --instrumentation-file=%t.fdata \
RUN: -instrumentation-wait-forks=1 \ RUN: --instrumentation-wait-forks=1 \
RUN: -o %t.instrumented RUN: -o %t.instrumented
# Instrumented program needs to finish returning zero # Instrumented program needs to finish returning zero
RUN: %t.instrumented | FileCheck %s -check-prefix=CHECK-OUTPUT RUN: %t.instrumented | FileCheck %s -check-prefix=CHECK-OUTPUT
# Test that the instrumented data makes sense # Test that the instrumented data makes sense
RUN: llvm-bolt %t.exe -o %t.bolted -data %t.fdata \ RUN: llvm-bolt %t.exe -o %t.bolted --data %t.fdata \
RUN: -reorder-blocks=ext-tsp -reorder-functions=hfsort+ \ RUN: --reorder-blocks=ext-tsp --reorder-functions=hfsort+ \
RUN: -print-only=interp -print-finalized RUN: --print-only=interp --print-finalized
RUN: %t.bolted | FileCheck %s -check-prefix=CHECK-OUTPUT RUN: %t.bolted | FileCheck %s -check-prefix=CHECK-OUTPUT
CHECK-OUTPUT: [child] CHECK-OUTPUT: [child]
CHECK-OUTPUT: [parent] CHECK-OUTPUT: [parent]
*/ */

bolt/test/runtime/X86/instrumentation-pie.c

Show All 17 Linesint main(int argc, char **argv) {
return 0; return 0;
} }
/* /*
REQUIRES: system-linux,bolt-runtime REQUIRES: system-linux,bolt-runtime
RUN: %clang %cflags %s -o %t.exe -Wl,-q -pie -fpie RUN: %clang %cflags %s -o %t.exe -Wl,-q -pie -fpie
RUN: llvm-bolt %t.exe -instrument -instrumentation-file=%t.fdata \ RUN: llvm-bolt %t.exe --instrument --instrumentation-file=%t.fdata \
RUN: -o %t.instrumented RUN: -o %t.instrumented
# Instrumented program needs to finish returning zero # Instrumented program needs to finish returning zero
RUN: %t.instrumented 1 2 3 | FileCheck %s -check-prefix=CHECK-OUTPUT RUN: %t.instrumented 1 2 3 | FileCheck %s -check-prefix=CHECK-OUTPUT
# Test that the instrumented data makes sense # Test that the instrumented data makes sense
RUN: llvm-bolt %t.exe -o %t.bolted -data %t.fdata \ RUN: llvm-bolt %t.exe -o %t.bolted --data %t.fdata \
RUN: -reorder-blocks=ext-tsp -reorder-functions=hfsort+ RUN: --reorder-blocks=ext-tsp --reorder-functions=hfsort+
RUN: %t.bolted 1 2 3 | FileCheck %s -check-prefix=CHECK-OUTPUT RUN: %t.bolted 1 2 3 | FileCheck %s -check-prefix=CHECK-OUTPUT
CHECK-OUTPUT: fib(4) = 3 CHECK-OUTPUT: fib(4) = 3
*/ */

bolt/test/runtime/X86/instrumentation-shlib.c

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
#endif #endif
/* /*
REQUIRES: system-linux,bolt-runtime REQUIRES: system-linux,bolt-runtime
RUN: %clang %cflags %s -o %t.so -Wl,-q -fpie -fPIC -shared -DLIB RUN: %clang %cflags %s -o %t.so -Wl,-q -fpie -fPIC -shared -DLIB
RUN: %clang %cflags %s -o %t.exe -Wl,-q -ldl RUN: %clang %cflags %s -o %t.exe -Wl,-q -ldl
RUN: llvm-bolt %t.so -instrument -instrumentation-file=%t.so.fdata \ RUN: llvm-bolt %t.so --instrument --instrumentation-file=%t.so.fdata \
RUN: -o %t.so.instrumented RUN: -o %t.so.instrumented
# Program with instrumented shared library needs to finish returning zero # Program with instrumented shared library needs to finish returning zero
RUN: %t.exe %t.so.instrumented 1 2 | FileCheck %s -check-prefix=CHECK-OUTPUT RUN: %t.exe %t.so.instrumented 1 2 | FileCheck %s -check-prefix=CHECK-OUTPUT
RUN: test -f %t.so.fdata RUN: test -f %t.so.fdata
# Test that the instrumented data makes sense # Test that the instrumented data makes sense
RUN: llvm-bolt %t.so -o %t.so.bolted -data %t.so.fdata \ RUN: llvm-bolt %t.so -o %t.so.bolted --data %t.so.fdata \
RUN: -reorder-blocks=ext-tsp -reorder-functions=hfsort+ RUN: --reorder-blocks=ext-tsp --reorder-functions=hfsort+
RUN: %t.exe %t.so.bolted 1 2 | FileCheck %s -check-prefix=CHECK-OUTPUT RUN: %t.exe %t.so.bolted 1 2 | FileCheck %s -check-prefix=CHECK-OUTPUT
CHECK-OUTPUT: fib(4) = 3 CHECK-OUTPUT: fib(4) = 3
*/ */

bolt/test/runtime/X86/internal-call-instrument.test

# Verify that instrumentation pass handles internal calls # Verify that instrumentation pass handles internal calls
REQUIRES: x86_64-linux,bolt-runtime REQUIRES: x86_64-linux,bolt-runtime
RUN: %clang -O3 %S/Inputs/internalcall-main.c %S/Inputs/internalcall.S -Wl,-q \ RUN: %clang -O3 %S/Inputs/internalcall-main.c %S/Inputs/internalcall.S -Wl,-q \
RUN: -o %t.exe RUN: -o %t.exe
RUN: llvm-bolt -instrument %t.exe -instrumentation-file=%t.fdata \ RUN: llvm-bolt --instrument %t.exe --instrumentation-file=%t.fdata \
RUN: -o %t -relocs -lite=0 RUN: -o %t -relocs -lite=0
RUN: %t | FileCheck %s RUN: %t | FileCheck %s
CHECK: Case 1: Result is: DEADBEEF CHECK: Case 1: Result is: DEADBEEF
CHECK: Case 2: Result is: DEADBEEF CHECK: Case 2: Result is: DEADBEEF
CHECK: Case 3: Result is: DEADBEEF CHECK: Case 3: Result is: DEADBEEF

bolt/test/runtime/X86/internal-call.test

# Verify that we support x86 old pic style internal calls accordingly in # Verify that we support x86 old pic style internal calls accordingly in
# relocation mode # relocation mode
# #
REQUIRES: x86_64-linux REQUIRES: x86_64-linux
RUN: %clang -O3 %S/Inputs/internalcall-main.c %S/Inputs/internalcall.S -Wl,-q \ RUN: %clang -O3 %S/Inputs/internalcall-main.c %S/Inputs/internalcall.S -Wl,-q \
RUN: -o %t.exe RUN: -o %t.exe
RUN: llvm-bolt %t.exe -o %t -relocs -lite=0 RUN: llvm-bolt %t.exe -o %t --relocs --lite=0
RUN: %t | FileCheck %s RUN: %t | FileCheck %s
CHECK: Case 1: Result is: DEADBEEF CHECK: Case 1: Result is: DEADBEEF
CHECK: Case 2: Result is: DEADBEEF CHECK: Case 2: Result is: DEADBEEF
CHECK: Case 3: Result is: DEADBEEF CHECK: Case 3: Result is: DEADBEEF

bolt/test/runtime/X86/interp-overwrite-bug.s

# This reproduces a bug with BOLT non-reloc mode, during emission, if the user # This reproduces a bug with BOLT non-reloc mode, during emission, if the user
# does not use -update-debug-sections. In this bug, if a function gets too large # does not use -update-debug-sections. In this bug, if a function gets too large
# to occupy its original location, but it has a jump table, BOLT would skip # to occupy its original location, but it has a jump table, BOLT would skip
# rewriting the function but it would still overwrite the jump table in a bogus # rewriting the function but it would still overwrite the jump table in a bogus
# file offset (offset zero). This will typically corrupt the .interp section, # file offset (offset zero). This will typically corrupt the .interp section,
# which is the first section in the binary, depending on the size of the jump # which is the first section in the binary, depending on the size of the jump
# table that was written. If .interp is corrupted, the binary won't run. # table that was written. If .interp is corrupted, the binary won't run.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags -no-pie -nostartfiles -nostdlib -lc %t.o -o %t.exe # RUN: %clang %cflags -no-pie -nostartfiles -nostdlib -lc %t.o -o %t.exe
# RUN: llvm-bolt %t.exe -o %t.exe.bolt -relocs=0 -lite=0 -reorder-blocks=reverse # RUN: llvm-bolt %t.exe -o %t.exe.bolt --relocs=0 --lite=0 \
# RUN: --reorder-blocks=reverse
# RUN: %t.exe.bolt 1 2 3 # RUN: %t.exe.bolt 1 2 3
.file "test.S" .file "test.S"
.text .text
.globl _start .globl _start
.type _start, @function .type _start, @function
_start: _start:
Show All 36 Lines

bolt/test/runtime/X86/retpoline-synthetic.test

# Check that llvm-bolt retpoline all indirect branches and the resulting binary # Check that llvm-bolt retpoline all indirect branches and the resulting binary
# correctly runs. # correctly runs.
REQUIRES: x86_64-linux REQUIRES: x86_64-linux
RUN: %clangxx %S/Inputs/retpoline_synthetic.cpp -fno-jump-tables -Wl,-q,-znow \ RUN: %clangxx %S/Inputs/retpoline_synthetic.cpp -fno-jump-tables -Wl,-q,-znow \
RUN: -O2 -o %t.exe RUN: -O2 -o %t.exe
RUN: llvm-bolt %t.exe -o %t -insert-retpolines -trap-old-code RUN: llvm-bolt %t.exe -o %t --insert-retpolines --trap-old-code
# Check indirect calls in the original binary # Check indirect calls in the original binary
RUN: llvm-objdump -d %t.exe | FileCheck %s -check-prefix=CHECK-CALL-ORIG RUN: llvm-objdump -d %t.exe | FileCheck %s -check-prefix=CHECK-CALL-ORIG
CHECK-CALL-ORIG: callq * CHECK-CALL-ORIG: callq *
# No indirect jumps # No indirect jumps
RUN: llvm-objdump -d -j ".text" %t | FileCheck %s -check-prefix=CHECK-JUMP-ORIG RUN: llvm-objdump -d -j ".text" %t | FileCheck %s -check-prefix=CHECK-JUMP-ORIG
CHECK-JUMP-ORIG-NOT: jmpq * CHECK-JUMP-ORIG-NOT: jmpq *
# Check that there are no indirect calls or jumps in the resulting binary # Check that there are no indirect calls or jumps in the resulting binary
RUN: llvm-objdump -d %t | FileCheck %s -check-prefix=CHECK-CALL RUN: llvm-objdump -d %t | FileCheck %s -check-prefix=CHECK-CALL
CHECK-CALL-NOT: callq * CHECK-CALL-NOT: callq *
RUN: llvm-objdump -d -j ".text" %t | FileCheck %s -check-prefix=CHECK-JUMP RUN: llvm-objdump -d -j ".text" %t | FileCheck %s -check-prefix=CHECK-JUMP
CHECK-JUMP-NOT: jmpq * CHECK-JUMP-NOT: jmpq *
RUN: %t 1000 3 | FileCheck %s RUN: %t 1000 3 | FileCheck %s
CHECK: 30000000 CHECK: 30000000

bolt/test/runtime/X86/section-reloc-with-addend.s

# This reproduces a bug triggered by a relocation referencing a section symbol # This reproduces a bug triggered by a relocation referencing a section symbol
# plus a negative reloc. BOLT handles such cases specially, but while doing so, # plus a negative reloc. BOLT handles such cases specially, but while doing so,
# it was failing to sign extend a negative result for the relocation (encoded # it was failing to sign extend a negative result for the relocation (encoded
# in the immediate operand of an LEA instruction). # in the immediate operand of an LEA instruction).
# Originally triggered by https://fossies.org/linux/glib/glib/guniprop.c # Originally triggered by https://fossies.org/linux/glib/glib/guniprop.c
# Line 550: const gchar *p = special_case_table + val - 0x1000000; # Line 550: const gchar *p = special_case_table + val - 0x1000000;
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# Delete our BB symbols so BOLT doesn't mark them as entry points # Delete our BB symbols so BOLT doesn't mark them as entry points
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -relocs=1 -print-finalized -print-only=main -o %t.out # RUN: llvm-bolt %t.exe --relocs=1 --print-finalized --print-only=main -o %t.out
# RUN: %t.out 1 2 # RUN: %t.out 1 2
.text .text
.globl main .globl main
.type main, %function .type main, %function
.p2align 4 .p2align 4
main: main:
Show All 26 Lines

bolt/test/runtime/X86/shrinkwrapping-alignment.s

# This reproduces a bug with shrink wrapping when trying to move # This reproduces a bug with shrink wrapping when trying to move
# push-pops in a function where we are not allowed to modify the # push-pops in a function where we are not allowed to modify the
# stack layout for alignment reasons. In this bug, we failed to # stack layout for alignment reasons. In this bug, we failed to
# propagate alignment requirement upwards in the call graph for # propagate alignment requirement upwards in the call graph for
# some functions when there is a cycle in the call graph. # some functions when there is a cycle in the call graph.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# Delete our BB symbols so BOLT doesn't mark them as entry points # Delete our BB symbols so BOLT doesn't mark them as entry points
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -relocs=1 -frame-opt=all -print-finalized \ # RUN: llvm-bolt %t.exe --relocs=1 --frame-opt=all --print-finalized \
# RUN: -lite=0 -print-only=main -data %t.fdata -o %t.out | FileCheck %s # RUN: --lite=0 --print-only=main --data %t.fdata -o %t.out | FileCheck %s
# RUN: %t.out # RUN: %t.out
# CHECK: BOLT-INFO: Shrink wrapping moved 1 spills inserting load/stores and 0 spills inserting push/pops # CHECK: BOLT-INFO: Shrink wrapping moved 1 spills inserting load/stores and 0 spills inserting push/pops
.text .text
.globl bar .globl bar
.type bar, %function .type bar, %function
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

bolt/test/runtime/X86/shrinkwrapping-lock.s

# This reproduces a bug with shrink wrapping when moving # This reproduces a bug with shrink wrapping when moving
# load instructions in-between the lock prefix and another # load instructions in-between the lock prefix and another
# instruction (where the lock prefix applies). # instruction (where the lock prefix applies).
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# Delete our BB symbols so BOLT doesn't mark them as entry points # Delete our BB symbols so BOLT doesn't mark them as entry points
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -relocs=1 -frame-opt=all -print-fop \ # RUN: llvm-bolt %t.exe --relocs=1 --frame-opt=all --print-fop \
# RUN: -print-only=main -data %t.fdata -o %t.out | FileCheck %s # RUN: --print-only=main --data %t.fdata -o %t.out | FileCheck %s
# RUN: %t.out 1 # RUN: %t.out 1
# CHECK: BOLT-INFO: Shrink wrapping moved 1 spills inserting load/stores and 0 spills inserting push/pops # CHECK: BOLT-INFO: Shrink wrapping moved 1 spills inserting load/stores and 0 spills inserting push/pops
.text .text
.globl main .globl main
.type main, %function .type main, %function
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

bolt/test/runtime/X86/shrinkwrapping-pushpop.s

# This reproduces a bug with shrink wrapping when trying to move # This reproduces a bug with shrink wrapping when trying to move
# push-pops where restores were not validated to be POPs (and could be # push-pops where restores were not validated to be POPs (and could be
# a regular load, which violated our assumptions). Check that we # a regular load, which violated our assumptions). Check that we
# identify those cases. # identify those cases.
# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# Delete our BB symbols so BOLT doesn't mark them as entry points # Delete our BB symbols so BOLT doesn't mark them as entry points
# RUN: llvm-strip --strip-unneeded %t.o # RUN: llvm-strip --strip-unneeded %t.o
# RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags -no-pie %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -relocs=1 -frame-opt=all -print-finalized \ # RUN: llvm-bolt %t.exe --relocs=1 --frame-opt=all --print-finalized \
# RUN: -print-only=main -data %t.fdata -o %t.out | FileCheck %s # RUN: --print-only=main --data %t.fdata -o %t.out | FileCheck %s
# RUN: %t.out # RUN: %t.out
# CHECK: BOLT-INFO: Shrink wrapping moved 1 spills inserting load/stores and 0 spills inserting push/pops # CHECK: BOLT-INFO: Shrink wrapping moved 1 spills inserting load/stores and 0 spills inserting push/pops
.text .text
.globl main .globl main
.type main, %function .type main, %function
Show All 36 Lines

bolt/test/runtime/X86/tail-duplication-constant-prop.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -data %t.fdata -reorder-blocks=ext-tsp -print-finalized \ # RUN: llvm-bolt %t.exe --data %t.fdata --reorder-blocks=ext-tsp \
# RUN: -tail-duplication=moderate -tail-duplication-minimum-offset=1 -tail-duplication-const-copy-propagation=1 -o %t.out | FileCheck %s # RUN: --print-finalized \
# RUN: --tail-duplication=moderate --tail-duplication-minimum-offset=1 \
# RUN: --tail-duplication-const-copy-propagation=1 -o %t.out | FileCheck %s
# RUN: %t.exe; echo $? # RUN: %t.exe; echo $?
# RUN: %t.out; echo $? # RUN: %t.out; echo $?
# FDATA: 1 main 14 1 main #.BB2# 0 10 # FDATA: 1 main 14 1 main #.BB2# 0 10
# FDATA: 1 main 16 1 main #.BB2# 0 20 # FDATA: 1 main 16 1 main #.BB2# 0 20
# CHECK: BOLT-INFO: tail duplication modified 1 ({{.*}}%) functions; duplicated 1 blocks ({{.*}} bytes) responsible for {{.*}} dynamic executions ({{.*}}% of all block executions) # CHECK: BOLT-INFO: tail duplication modified 1 ({{.*}}%) functions; duplicated 1 blocks ({{.*}} bytes) responsible for {{.*}} dynamic executions ({{.*}}% of all block executions)
# CHECK: BB Layout : .LBB00, .Ltail-dup0, .Ltmp0, .Ltmp1 # CHECK: BB Layout : .LBB00, .Ltail-dup0, .Ltmp0, .Ltmp1
# CHECK-NOT: mov $0x2, %rbx # CHECK-NOT: mov $0x2, %rbx
Show All 27 Lines

bolt/test/runtime/X86/three-way-branch-pass.s

# REQUIRES: system-linux # REQUIRES: system-linux
# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \ # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
# RUN: %s -o %t.o # RUN: %s -o %t.o
# RUN: link_fdata %s %t.o %t.fdata # RUN: link_fdata %s %t.o %t.fdata
# RUN: %clang %cflags %t.o -o %t.exe -Wl,-q # RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
# RUN: llvm-bolt %t.exe -data %t.fdata -print-finalized \ # RUN: llvm-bolt %t.exe --data %t.fdata --print-finalized \
# RUN: -o %t.out -three-way-branch | FileCheck %s # RUN: -o %t.out --three-way-branch | FileCheck %s
# RUN: %t.exe # RUN: %t.exe
# RUN: %t.out # RUN: %t.out
# FDATA: 1 main 8 1 main a 0 22 # FDATA: 1 main 8 1 main a 0 22
# FDATA: 1 main 8 1 main #.BB1# 0 50 # FDATA: 1 main 8 1 main #.BB1# 0 50
# FDATA: 1 main 12 1 main 14 0 30 # FDATA: 1 main 12 1 main 14 0 30
# FDATA: 1 main 12 1 main #.BB2# 0 40 # FDATA: 1 main 12 1 main #.BB2# 0 40
# CHECK: Successors: .Ltmp1 (mispreds: 0, count: 40), .Ltmp0 (mispreds: 0, count: 52) # CHECK: Successors: .Ltmp1 (mispreds: 0, count: 40), .Ltmp0 (mispreds: 0, count: 52)
Show All 20 Lines

bolt/test/runtime/X86/user-func-reorder.c

Show All 23 Linesint main(int argc, char **argv) {
return 0; return 0;
} }
/* /*
REQUIRES: system-linux,bolt-runtime REQUIRES: system-linux,bolt-runtime
RUN: %clang %cflags -no-pie %s -o %t.exe -Wl,-q RUN: %clang %cflags -no-pie %s -o %t.exe -Wl,-q
RUN: llvm-bolt %t.exe -relocs=1 -lite -reorder-functions=user \ RUN: llvm-bolt %t.exe --relocs=1 --lite --reorder-functions=user \
RUN: -hugify -function-order=%p/Inputs/user_func_order.txt -o %t RUN: --hugify --function-order=%p/Inputs/user_func_order.txt -o %t
RUN: llvm-nm --numeric-sort --print-armap %t | \ RUN: llvm-nm --numeric-sort --print-armap %t | \
RUN: FileCheck %s -check-prefix=CHECK-NM RUN: FileCheck %s -check-prefix=CHECK-NM
RUN: %t 1 2 3 | FileCheck %s -check-prefix=CHECK-OUTPUT RUN: %t 1 2 3 | FileCheck %s -check-prefix=CHECK-OUTPUT
CHECK-NM: W __hot_start CHECK-NM: W __hot_start
CHECK-NM: T main CHECK-NM: T main
CHECK-NM-NEXT: T fib CHECK-NM-NEXT: T fib
CHECK-NM-NEXT: W __hot_end CHECK-NM-NEXT: W __hot_end
CHECK-OUTPUT: fib(4) = 3 CHECK-OUTPUT: fib(4) = 3
*/ */

bolt/test/runtime/fptr.test

# Make sure BOLT correctly updates values based on function pointer. # Make sure BOLT correctly updates values based on function pointer.
RUN: %clang %cflags -no-pie %p/Inputs/fptr.c -Wl,-q -o %t.exe RUN: %clang %cflags -no-pie %p/Inputs/fptr.c -Wl,-q -o %t.exe
RUN: llvm-bolt %t.exe -o %t -lite=0 RUN: llvm-bolt %t.exe -o %t --lite=0
RUN: %t | FileCheck %s RUN: %t | FileCheck %s
CHECK: Global = 0x[[#%x,ADDR:]] CHECK: Global = 0x[[#%x,ADDR:]]
CHECK-NEXT: Local = 0x[[#ADDR]] CHECK-NEXT: Local = 0x[[#ADDR]]
CHECK-NEXT: Local2 = 0x[[#ADDR]] CHECK-NEXT: Local2 = 0x[[#ADDR]]

bolt/test/runtime/iplt.c

// This test checks that the ifuncs works after bolt. // This test checks that the ifuncs works after bolt.
// RUN: %clang %cflags -no-pie %s -fuse-ld=lld \ // RUN: %clang %cflags -no-pie %s -fuse-ld=lld \
// RUN: -o %t.exe -Wl,-q // RUN: -o %t.exe -Wl,-q
// RUN: llvm-bolt %t.exe -o %t.bolt.exe -use-old-text=0 -lite=0 // RUN: llvm-bolt %t.exe -o %t.bolt.exe --use-old-text=0 --lite=0
// RUN: %t.bolt.exe | FileCheck %s // RUN: %t.bolt.exe | FileCheck %s
// CHECK: foo // CHECK: foo
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
static void foo() { printf("foo\n"); } static void foo() { printf("foo\n"); }
Show All 18 Lines

bolt/test/runtime/meta-merge-fdata.test

# Meta test using merge-fdata binary # Meta test using merge-fdata binary
UNSUPPORTED: asan UNSUPPORTED: asan
# Instrumentation currently only works on X86 # Instrumentation currently only works on X86
REQUIRES: x86_64-linux REQUIRES: x86_64-linux
# Instrumentation, should test: # Instrumentation, should test:
# - Direct branches # - Direct branches
# - Unmapped calls coming from uninstrumented code (libc) # - Unmapped calls coming from uninstrumented code (libc)
# - Direct calls # - Direct calls
RUN: llvm-bolt merge-fdata -o %t.inst -instrument -instrumentation-file=%t.fdata RUN: llvm-bolt merge-fdata -o %t.inst --instrument \
RUN: --instrumentation-file=%t.fdata
# Execute with no input # Execute with no input
RUN: %t.inst --version RUN: %t.inst --version
RUN: mv %t.fdata %t.fdata1 RUN: mv %t.fdata %t.fdata1
# Check unmapped calls coverage - libc should be calling _start via # Check unmapped calls coverage - libc should be calling _start via
# uninstrumented code # uninstrumented code
RUN: cat %t.fdata1 | FileCheck %s --check-prefix=CHECK-FDATA RUN: cat %t.fdata1 | FileCheck %s --check-prefix=CHECK-FDATA
CHECK-FDATA: 0 [unknown] 0 1 _start 0 0 1 CHECK-FDATA: 0 [unknown] 0 1 _start 0 0 1
# Check that BOLT works with this profile # Check that BOLT works with this profile
RUN: llvm-bolt merge-fdata -o %t.bolt -data %t.fdata1 \ RUN: llvm-bolt merge-fdata -o %t.bolt --data %t.fdata1 \
RUN: -reorder-blocks=ext-tsp -reorder-functions=hfsort+ -split-functions=3 | \ RUN: --reorder-blocks=ext-tsp --reorder-functions=hfsort+ \
RUN: FileCheck %s --check-prefix=CHECK-BOLT1 RUN: --split-functions=3 \
RUN: | FileCheck %s --check-prefix=CHECK-BOLT1
CHECK-BOLT1-NOT: invalid (possibly stale) profile CHECK-BOLT1-NOT: invalid (possibly stale) profile
# Execute again # Execute again
RUN: %t.inst --help RUN: %t.inst --help
RUN: mv %t.fdata %t.fdata2 RUN: mv %t.fdata %t.fdata2
# Check profile coverage # Check profile coverage
RUN: llvm-boltdiff merge-fdata merge-fdata \ RUN: llvm-boltdiff merge-fdata merge-fdata \
RUN: -data %t.fdata1 -data2 %t.fdata2 -display-count=20 | \ RUN: --data %t.fdata1 --data2 %t.fdata2 --display-count=20 | \
RUN: FileCheck %s --check-prefix=CHECK-BOLTDIFF RUN: FileCheck %s --check-prefix=CHECK-BOLTDIFF
CHECK-BOLTDIFF: Inputs share [[#]] functions CHECK-BOLTDIFF: Inputs share [[#]] functions
# Check that instrumented binary produces the same result # Check that instrumented binary produces the same result
RUN: merge-fdata %t.fdata1 %t.fdata2 > %t.fdata.base RUN: merge-fdata %t.fdata1 %t.fdata2 > %t.fdata.base
RUN: %t.inst %t.fdata1 %t.fdata2 > %t.fdata.inst RUN: %t.inst %t.fdata1 %t.fdata2 > %t.fdata.inst
RUN: cmp %t.fdata.base %t.fdata.inst RUN: cmp %t.fdata.base %t.fdata.inst
# Optimize using merged fdata # Optimize using merged fdata
RUN: llvm-bolt merge-fdata -o %t.opt -data %t.fdata.base \ RUN: llvm-bolt merge-fdata -o %t.opt --data %t.fdata.base \
RUN: -reorder-blocks=ext-tsp -reorder-functions=hfsort+ -split-functions=3 | \ RUN: --reorder-blocks=ext-tsp --reorder-functions=hfsort+ \
RUN: FileCheck %s --check-prefix=CHECK-BOLT2 RUN: --split-functions=3 \
RUN: | FileCheck %s --check-prefix=CHECK-BOLT2
CHECK-BOLT2-NOT: invalid (possibly stale) profile CHECK-BOLT2-NOT: invalid (possibly stale) profile
# Check that optimized binary produces the same result # Check that optimized binary produces the same result
RUN: %t.opt %t.fdata1 %t.fdata2 > %t.fdata.opt RUN: %t.opt %t.fdata1 %t.fdata2 > %t.fdata.opt
RUN: cmp %t.fdata.base %t.fdata.opt RUN: cmp %t.fdata.base %t.fdata.opt

bolt/test/runtime/plt-gnu-ld.test

// This test checks that the pointers to PLT are properly updated. // This test checks that the pointers to PLT are properly updated.
// The test is using bfd linker, since it may add versioning string // The test is using bfd linker, since it may add versioning string
// to the symbol name e.g. memcpy@@GLIBC_2.17 // to the symbol name e.g. memcpy@@GLIBC_2.17
// REQUIRES: gnu_ld // REQUIRES: gnu_ld
// RUN: %clang %cflags %p/../Inputs/plt.c -fuse-ld=bfd \ // RUN: %clang %cflags %p/../Inputs/plt.c -fuse-ld=bfd \
// RUN: -o %t.bfd.exe -Wl,-q // RUN: -o %t.bfd.exe -Wl,-q
// RUN: llvm-bolt %t.bfd.exe -o %t.bfd.bolt.exe -use-old-text=0 -lite=0 // RUN: llvm-bolt %t.bfd.exe -o %t.bfd.bolt.exe --use-old-text=0 --lite=0
// RUN: %t.bfd.bolt.exe | FileCheck %s // RUN: %t.bfd.bolt.exe | FileCheck %s
// CHECK: Test completed // CHECK: Test completed

bolt/test/runtime/plt-lld.test

// This test checks that the pointers to PLT are properly updated. // This test checks that the pointers to PLT are properly updated.
// The test is using lld linker. // The test is using lld linker.
// Non-PIE: // Non-PIE:
RUN: %clang %cflags -no-pie %p/../Inputs/plt.c -fuse-ld=lld \ RUN: %clang %cflags -no-pie %p/../Inputs/plt.c -fuse-ld=lld \
RUN: -o %t.lld.exe -Wl,-q RUN: -o %t.lld.exe -Wl,-q
RUN: llvm-bolt %t.lld.exe -o %t.lld.bolt.exe -use-old-text=0 -lite=0 RUN: llvm-bolt %t.lld.exe -o %t.lld.bolt.exe --use-old-text=0 --lite=0
RUN: %t.lld.bolt.exe | FileCheck %s RUN: %t.lld.bolt.exe | FileCheck %s
// PIE: // PIE:
RUN: %clang %cflags -fPIC -pie %p/../Inputs/plt.c -fuse-ld=lld \ RUN: %clang %cflags -fPIC -pie %p/../Inputs/plt.c -fuse-ld=lld \
RUN: -o %t.lld.pie.exe -Wl,-q RUN: -o %t.lld.pie.exe -Wl,-q
RUN: llvm-bolt %t.lld.pie.exe -o %t.lld.bolt.pie.exe -use-old-text=0 -lite=0 RUN: llvm-bolt %t.lld.pie.exe -o %t.lld.bolt.pie.exe --use-old-text=0 --lite=0
RUN: %t.lld.bolt.pie.exe | FileCheck %s RUN: %t.lld.bolt.pie.exe | FileCheck %s
CHECK: Test completed CHECK: Test completed