[BOLT][test] Fix X86 tests

[yota9]

Summary

Be aware that the unreachable.test is marked as XFAIL due to passed cxxflags

[maksfb]

Thanks! Could you please check that premerge check failures are unrelated?

[yota9]

Remove unreachable test changes

[yota9]

Update stubs

[yota9]

@maksfb Yes, you're right. The problem is coming from cxxflags passed to the test now, I'm marking it as XFAIL: * now (see my comments in discord)

[Amir]

Can you please add the following to unreachable.s? This would fix the test and make XFAIL: * unneeded:

diff --git a/bolt/test/X86/Inputs/unreachable.s b/bolt/test/X86/Inputs/unreachable.s
index b8dcf4c05557..39f4be971c87 100644
--- a/bolt/test/X86/Inputs/unreachable.s
+++ b/bolt/test/X86/Inputs/unreachable.s
@@ -82,4 +82,5 @@ foo:
        .globl  main, function
 main:
        .cfi_startproc
+  ud2
        .cfi_endproc

[yota9]

Fix unreachable.s

[yota9]

clang-format

[yota9]

@Amir Thank you very much, it works now, submitting the patch now :)

bolt/test/AArch64/lit.local.cfg

 if 'AArch64' not in config.root.targets:
     config.unsupported = True
 
 config.substitutions.insert(
     0, ('%cflags',
         '%cflags --target=aarch64-pc-linux -nostartfiles -nostdlib -fuse-ld=lld'
         ' -ffreestanding -Wl,--unresolved-symbols=ignore-all'))
+
+config.substitutions.insert(
+    0, ('%cxxflags',
+        '%cxxflags --target=aarch64-pc-linux -nostartfiles -nostdlib -fuse-ld=lld'
+        ' -ffreestanding -Wl,--unresolved-symbols=ignore-all'))

bolt/test/Inputs/stub.c

 // The stub symbols library used for testing purposes
 
 void *memcpy(void *dest, const void *src, unsigned long n) { return 0; }
 void *memset(void *dest, int c, unsigned long n) { return 0; }
 int printf(const char *format, ...) { return 0; }
 void exit(int status) {}
+
+void *__gxx_personality_v0;

bolt/test/X86/asm-dump.c

 /**
  * Test for asm-dump functionality.
  *
- * REQUIRES: system-linux
+ * REQUIRES: system-linux,bolt-runtime
  *
  * Compile the source
  * RUN: %clang -fPIC %s -o %t.exe -Wl,-q
  *
  * Profile collection: instrument the binary
  * RUN: llvm-bolt %t.exe -instrument -instrumentation-file=%t.fdata -o %t.instr
  *
  * Profile collection: run instrumented binary (and capture output)

bolt/test/X86/avx512-trap.test

 # 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.
 
-RUN: %clang %S/Inputs/avx512.c -o %t -Wl,-q,-znow
+RUN: %clang %cflags %S/Inputs/avx512.c -o %t -Wl,-q,-znow
 RUN: llvm-bolt %t -trap-avx512=1 -o %t.bolt 2>&1 | FileCheck %s && \
 RUN:    llvm-objdump -d --disassemble-symbols=use_avx512 %t.bolt | FileCheck %s --check-prefix=CHECK-DIS
 RUN: llvm-bolt %t -trap-avx512=0 -o %t.bolt && \
 RUN:    llvm-objdump -d --disassemble-symbols=use_avx512 %t.bolt | FileCheck %s --check-prefix=CHECK-DIS-NO-TRAP
 
 CHECK: BOLT-WARNING: 1 function will trap on entry
 
 # Check that we have two ud2 instructions - one per entry.
 CHECK-DIS:      use_avx512
 CHECK-DIS-NEXT:    ud2
 CHECK-DIS-NEXT:    ud2
 
 # Check that we generate correct AVX-512
 CHECK-DIS-NO-TRAP:      use_avx512
 CHECK-DIS-NO-TRAP:          62 e2 f5 70 2c da     vscalefpd 

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

 # Test performs a BB reordering with unsupported
 # instruction jrcxz. Reordering works correctly with the
 # follow options: None, Normal or Reverse. Other strategies
 # are completed with Assertion `isIntN(Size * 8 + 1, Value).
 # The cause is the distance between BB where one contains
 # jrcxz instruction.
 # Example: OpenSSL
 # https://github.com/openssl/openssl/blob/master/crypto/bn/asm/x86_64-mont5.pl#L3319
 
 # REQUIRES: system-linux
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 # RUN:   %s -o %t.o
 # RUN: link_fdata %s %t.o %t.fdata
-# RUN: %clang %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:    -reorder-blocks=cache+ -reorder-functions=hfsort \
 # RUN:    -split-functions=2 -split-all-cold -split-eh -dyno-stats \
 # RUN:    -print-finalized 2>&1 | FileCheck %s
 
 # CHECK-NOT: value of -2105 is too large for field of 1 byte.
 

bolt/test/X86/exceptions-args.test

 # Check that we handle GNU_args_size correctly.
 # It is generated for throwing functions with LP that have parameters on stack.
 
-RUN: %clangxx %cxxflags %p/Inputs/exc_args.s -o %t
+RUN: %clang %cflags %p/../Inputs/stub.c -fPIC -pie -shared -o %t.so
+RUN: %clangxx %cxxflags %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
 
 CHECK: Binary Function "main" after finalize-functions
 CHECK:      callq _Z3fooiiiiiiii {{.*}} GNU_args_size = 16
 CHECK:      callq printf@PLT {{.*}} GNU_args_size = 0
 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
 # a conditional jump followed by a no-op.
 
 RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 RUN:   %S/Inputs/ft_to_noop.s -o %t.o
 RUN: link_fdata %S/Inputs/ft_to_noop.s %t.o %t.fdata
 RUN: llvm-strip --strip-unneeded %t.o
-RUN: %clang %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:   -print-cfg -sequential-disassembly 2>&1 | FileCheck %s
 
 CHECK:      Binary Function "foo" after building cfg
 CHECK:        Exec Count  : 20
 CHECK:        Profile Acc : 100.0%
 
 # This block is terminated with a conditional jump to .Ltmp0 followed by a

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

 # Make sure inlining from a unit with debug info into unit without
 # debug info does not cause a crash.
 
-RUN: %clangxx %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 %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:   -inline-small-functions -force-inline=main | FileCheck %s
 
 CHECK-NOT: BOLT: 0 out of {{.*}} functions were overwritten

bolt/test/X86/jmp-optimization.test

 # Tests the optimization of functions that just do a tail call in the beginning.
 
-RUN: %clang -O2 %S/Inputs/jmp_opt{,2,3}.cpp -o %t
+RUN: %clang %cflags -O2 %S/Inputs/jmp_opt{,2,3}.cpp -o %t
 RUN: llvm-bolt -inline-small-functions %t -o %t.bolt
 RUN: llvm-objdump -d %t.bolt --print-imm-hex | FileCheck %s
 
 CHECK:     <main>:
 CHECK-NOT: call
 CHECK:     xorl    %eax, %eax
 CHECK:     retq

bolt/test/X86/line-number.test

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

bolt/test/X86/lit.local.cfg

 if not 'X86' in config.root.targets:
     config.unsupported = True
 
 config.substitutions.insert(
     0, ('%cflags',
-        '%cflags --target=x86_64--pc-linux -nostartfiles -nostdlib -fuse-ld=lld'
+        '%cflags --target=x86_64--pc-linux -nostdlib -fuse-ld=lld'
+        ' -Wl,--unresolved-symbols=ignore-all'))
+
+config.substitutions.insert(
+    0, ('%cxxflags',
+        '%cxxflags --target=x86_64--pc-linux -nostdlib -fuse-ld=lld'
         ' -Wl,--unresolved-symbols=ignore-all'))

bolt/test/X86/no-output.test

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

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

 # Check for the simplification of .rodata loads.
 
-RUN: %clang %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: 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
 
 CHECK:   Disassembly of section .text:
 CHECK:   <main>:
 # check that the following rip-relative operands have been
 # replaced with immediates

bolt/test/X86/shorten-mov.test

 # Test that 64 bit movq instructions with immediate operands
 # that fit in 32 bits are shortened.
 
-RUN: %clang %p/Inputs/asm_main.c %p/Inputs/shorten_mov.s -o %t.exe
+RUN: %clang %cflags %p/Inputs/asm_main.c %p/Inputs/shorten_mov.s -o %t.exe
 RUN: llvm-bolt %t.exe -o %t
 RUN: llvm-objdump -d %t --print-imm-hex | FileCheck %s
 
 CHECK: <foo>:
 CHECK-NEXT:  48 c7 c0 11 11 00 00   movq    $0x1111, %rax
 CHECK-NEXT:  48 c7 c0 11 11 00 00   movq    $0x1111, %rax
 CHECK-NEXT:  48 c7 c0 22 22 11 11   movq    $0x11112222, %rax
 CHECK-NEXT:  48 b8 22 22 11 11 01 00 00 00  movabsq $0x111112222, %rax
 CHECK-NEXT:  48 c7 c0 ff ff ff ff   movq    $-0x1, %rax
 CHECK-NEXT:  48 b8 ff ff ff ff ff ff ff 7f  movabsq $0x7fffffffffffffff, %rax

bolt/test/X86/static-exe.test

 # Check that llvm-bolt can rewrite static executable
 
-RUN: %clang %S/Inputs/static_exe.s -static -o %t.exe -nostdlib
+RUN: %clang %cflags %S/Inputs/static_exe.s -static -o %t.exe -nostdlib
 RUN: llvm-bolt %t.exe -o %t |& FileCheck %s
 
 CHECK: 1 out of 1 functions were overwritten

bolt/test/X86/tailcall.test

 # Verifies that llvm-bolt recognizes tailcalls and mark them
 # in control flow graph.
 
-RUN: %clang %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
 
 CHECK:  Binary Function "foo"
 CHECK:    jmp     bar # TAILCALL
 CHECK:  End of Function "foo"
 
 CHECK:  Binary Function "bar"
 CHECK:    jmp     baz # TAILCALL
 CHECK:  End of Function "bar"

bolt/test/X86/unreachable.test

 # Check unreachable code elimination
 
-RUN: %clangxx %cxxflags %p/Inputs/unreachable.s -o %t.exe
+XFAIL: aarch64
+
+RUN: %clang %cflags %p/../Inputs/stub.c -fPIC -pie -shared -o %t.so
+RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
+RUN:   %p/Inputs/unreachable.s -o %t.o
+RUN: %clangxx %cxxflags %t.o -o %t.exe %t.so
 RUN: llvm-bolt %t.exe -o %t \
 RUN:   -reorder-blocks=none -split-functions=1 -eliminate-unreachable \
 RUN:   -funcs=foo -use-gnu-stack -print-cfg -print-finalized \
 RUN:   | FileCheck %s --check-prefix=BOLT
 RUN: llvm-objdump -d %t --print-imm-hex --disassemble-symbols=foo \
 RUN:   --no-show-raw-insn | FileCheck %s
 
 BOLT: BB Layout   : .LBB{{.*}}, .LFT{{.*}}, .Ltmp{{.*}}, .LFT{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .LLP{{.*}}, .LFT{{.*}}, .Ltmp{{.*}}, .LFT{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}, .Ltmp{{.*}}