[BOLT][TEST] Remove -no-pie from cflags/cxxflags

[Amir]

Summary

Align with an upstream change D120305 to make PIE the default on linux-gnu.

Add -no-pie to tests that require it.

[Amir]

Update tests

[yota9]

@Amir I think you need to rebase the patch, I will check it on aarch64 then :) Thank you!

[Amir]

Rebase

[Amir]

In D123329#3438746, @yota9 wrote:

@Amir I think you need to rebase the patch, I will check it on aarch64 then :) Thank you!

Done

[maksfb]

LGTM

[Amir]

Rebase

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

 # Verify that we update DW_TAG_compile_unit' ranges and .debug_aranges
 # for assembly function that doesn't have corresponding DIE.
 #
 # The input test case foo() contains nops that we remove.
 
-RUN: %clang %cflags -g %p/../Inputs/asm_foo.s %p/../Inputs/asm_main.c -o %t.exe
+RUN: %clang %cflags -no-pie -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-dwarfdump -all %t | FileCheck %s
 
 # Check ranges were created/updated for asm compile unit
 CHECK:       0x0000000b: DW_TAG_compile_unit
 CHECK-NEXT:       DW_AT_stmt_list (0x00000000)
 CHECK-NEXT:       DW_AT_low_pc (0x0000000000000000)
 CHECK-NEXT:       DW_AT_ranges

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

 # Verify that we update DW_TAG_compile_unit' ranges and .debug_aranges
 # for assembly function that doesn't have corresponding DIE.
 #
 # The input test case foo() contains nops that we remove.
 
-RUN: %clang -g %cflags %p/../Inputs/asm_foo.s %p/../Inputs/asm_main.c -o %t.exe
+RUN: %clang -g %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-dwarfdump -all %t | FileCheck %s
 
 # Check ranges were created/updated for asm compile unit
 CHECK:       0x0000000b: DW_TAG_compile_unit
 CHECK-NEXT:       DW_AT_stmt_list (0x00000000)
 CHECK-NEXT:       DW_AT_low_pc (0x0000000000000000)
 CHECK-NEXT:       DW_AT_ranges

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

 # Checks debug fission support in BOLT
 
 # REQUIRES: system-linux
 
 # RUN: llvm-mc -g \
 # RUN:   --filetype=obj \
 # RUN:   --triple x86_64-unknown-unknown \
 # RUN:   --split-dwarf-file=debug-fission-simple.dwo \
 # RUN:   %p/Inputs/debug-fission-simple.s \
 # RUN:   -o %t.o
-# RUN: %clangxx %cxxflags -g \
+# RUN: %clangxx %cxxflags -no-pie -g \
 # RUN:   -Wl,--gc-sections,-q,-nostdlib \
 # RUN:   -Wl,--undefined=_Z6_startv \
 # RUN:   -nostartfiles \
 # RUN:   -Wl,--script=%p/Inputs/debug-fission-script.txt \
 # RUN:   %t.o -o %t.exe
 # RUN: llvm-bolt %t.exe \
 # RUN:   --reorder-blocks=reverse \
 # RUN:   --update-debug-sections \

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: %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: %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
 
 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/indirect-goto.test

 # Check llvm-bolt processes binaries compiled from sources that use indirect goto.
-RUN: %clang %cflags %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:   |& FileCheck %s
 
 # Check that all possible destinations are included as successors.
 CHECK:  jmpq    *%rax # UNKNOWN CONTROL FLOW
 CHECK:  Successors: .Ltmp0, .Ltmp1, .Ltmp2

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

 #  try {
 #    throw std::logic_error("");
 #  } catch (...) {}
 # }
 
 # REQUIRES: system-linux
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
-# RUN: %clangxx %cxxflags %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
 #
 # CHECK-NOT: Assertion `isValid()' failed.
 
   .globl main
 main:
   jmp .L3 # jump to the secondary entry point in main.cold.0
 

bolt/test/X86/issue20.s

 # This reproduces issue 20 from our github repo
 #  "BOLT crashes when removing unreachable BBs that are a target
 #   in a JT"
 
 # REQUIRES: system-linux
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 # RUN:   %s -o %t.o
-# RUN: %clang %cflags %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:    -o %t.out | FileCheck %s
 
 # CHECK: BOLT-INFO: UCE removed 0 blocks and 0 bytes of code.
 # CHECK: Binary Function "main"
 # CHECK:      .LFT{{.*}} (2 instructions, align : 1)
 # CHECK-NEXT:   CFI State : 0
 # CHECK-NEXT:     00000004:   andq

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

 # Checks that jump table footprint reduction optimization is reducing entry
 # sizes.
 
 RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 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
 RUN: llvm-strip --strip-unneeded %t.o
-RUN: %clang %cflags %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:   -jump-tables=move -jt-footprint-reduction -assume-abi -relocs \
 RUN:   | FileCheck %s
 
 CHECK: 100.00% of dynamic JT entries were reduced.
 CHECK: 1 of 1 jump tables affected.
 CHECK: 1 of 1 indirect jumps to JTs affected.
 CHECK: 36 bytes saved.

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

 RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 RUN:   %p/Inputs/jump_table_icp.s -o %t.o
 RUN: link_fdata %p/Inputs/jump_table_icp.s %t.o %t.fdata 
 RUN: llvm-strip --strip-unneeded %t.o
-RUN: %clang %cflags %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:   -reorder-blocks=cache -split-functions=3 -split-all-cold \
 RUN:   -use-gnu-stack -dyno-stats -indirect-call-promotion=jump-tables \
 RUN:   -print-icp -v=0 \
 RUN:   -icp-jt-remaining-percent-threshold=10 \
 RUN:   -icp-jt-total-percent-threshold=2 \
 RUN:   -indirect-call-promotion-topn=1 \

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

 # Verifies that BOLT detects fixed destination of indirect jump
 
-RUN: %clang %cflags %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
 
 CHECK: BOLT-INFO: fixed indirect branch detected in main

bolt/test/X86/loop-nest.test

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

bolt/test/X86/shrinkwrapping-critedge.s

 # This reproduces a bug with shrink wrapping when trying to split critical
 # edges originating at the same basic block.
 
 # 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 %cflags %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:     -frame-opt=all -simplify-conditional-tail-calls=false \
 # RUN:     -eliminate-unreachable=false
 
   .globl _start
 _start:
 # FDATA: 0 [unknown] 0 1 _start 0 0 1
     push  %rbx

bolt/test/X86/shrinkwrapping.test

 # Verifies that llvm-bolt updates CFI correctly after
 # shrink-wrapping when optimizing a function without
 # frame pointers.
 
-RUN: %clangxx %cxxflags %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:   -data=%p/Inputs/exc4sw.fdata -reorder-blocks=cache 2>&1 | \
 RUN:   FileCheck %s --check-prefix=CHECK-BOLT
 
 RUN: llvm-objdump --dwarf=frames %t.exe | grep -A20 -e \
 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
 

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

 # This reproduces a bug in TailDuplication::isInCacheLine
 # with accessing BlockLayout past bounds (unreachable blocks).
 
 # 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 %cflags %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:   -tail-duplication=1 -tail-duplication-aggressive=1
   .globl _start
 _start:
   jmp d
   je  _start
   movl  %esi, %edi
 d:

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

 # This reproduces a bug in tail duplication when aggressiveCodeToDuplicate
 # fails to handle a block with a jump table.
 
 # 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: %clangxx %cflags %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:   -tail-duplication=1 -tail-duplication-aggressive=1 \
 # RUN:   -print-cfg | FileCheck %s
 # CHECK: Jump table {{.*}} for function a at {{.*}} with a total count of 3
   .globl main
 main:
   .globl a
   .type a, %function

bolt/test/X86/unreachable.test

 # Check unreachable code elimination
 
 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: %clangxx %cxxflags -no-pie %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{{.*}}

bolt/test/X86/vararg.test

 # Check that a function that references a label inside itself,
 # as in the case of vararg handling code generated by GCC 4.5
 # and earlier, is recognized as multi-entry.
 
 REQUIRES: x86_64-linux
 
-RUN: %clangxx %cxxflags %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
 
 CHECK: IsSimple    : 0
 CHECK: Entry Point
 CHECK: Entry Point

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

 # Check that references to local (unnamed) objects below are not
 # treated as references relative to zero-sized A object.
 
 # REQUIRES: system-linux
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 # RUN:   %s -o %t.o
-# RUN: %clang %cflags %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:    -print-only=main -o %t.out | FileCheck %s
 
   .file "rust_bug.c"
   .section  .rodata
 .LC0:
   .string "0"

bolt/test/lit.cfg.py

 llvm_config.config.environment['CLANG'] = config.bolt_clang
 llvm_config.use_clang()
 
 llvm_config.config.environment['LD_LLD'] = config.bolt_lld
 ld_lld = llvm_config.use_llvm_tool('ld.lld', required=True, search_env='LD_LLD')
 llvm_config.config.available_features.add('ld.lld')
 llvm_config.add_tool_substitutions([ToolSubst(r'ld\.lld', command=ld_lld)])
 
-config.substitutions.append(('%cflags', '-no-pie -gdwarf-4'))
-config.substitutions.append(('%cxxflags', '-no-pie -gdwarf-4'))
+config.substitutions.append(('%cflags', '-gdwarf-4'))
+config.substitutions.append(('%cxxflags', '-gdwarf-4'))
 
 link_fdata_cmd = os.path.join(config.test_source_root, 'link_fdata.py')
 
 tool_dirs = [config.llvm_tools_dir,
              config.test_source_root]
 
 tools = [
     ToolSubst('llc', unresolved='fatal'),

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

 # Check instrumentation of C++ code with exceptions
 
 REQUIRES: system-linux
 
-RUN: %clangxx %cxxflags %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: %t.exc arg1 arg2 arg3
 
 RUN: llvm-bolt %t_exc_split -o %t.exc.bolted -data %t.fdata \
 RUN:   -reorder-blocks=cache+ -reorder-functions=hfsort+ -split-functions=3 \
 RUN:   -split-eh=1 | FileCheck --check-prefix=EXCEPTIONS %s
 EXCEPTIONS-NOT: invalid (possibly stale) profile
 
 # Check that cold symbols are emitted with local binding.
 RUN: llvm-readelf -Ws %t.exc.bolted | FileCheck %s --check-prefix=CHECK-READELF
 CHECK-READELF: FUNC    LOCAL  DEFAULT   {{.*}} main.cold.{{.*}}
 
 RUN: cat %t.fdata | FileCheck --check-prefix=EXCEPTIONS-FDATA %s
 # Check that the printf "catch" ran exactly 10 times
 EXCEPTIONS-FDATA: 1 main {{.*}} 1 _Znwm@PLT 0 0 10

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

 # Test BOLT does not crash by trying to change the direction of a JRCXZ
 
 # 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 %cflags %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=cache+ -print-finalized \
 # RUN:    -o %t.out -data %t.fdata | FileCheck %s
 # RUN: %t.out 1 2 3
 
 # CHECK: BOLT-INFO
 
   .text
   .section .text.startup,"ax",@progbits

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

 # This reproduces a bug where BOLT would read __hot_end as
 # the name of a function even when -hot-text is used, which
 # means BOLT will emit another __hot_end label, eventually
 # asserting due to a symbol redefinition in MCStreamer.
 
 # 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 %cflags %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:    -data %t.fdata -o %t.out | FileCheck %s
 
 # RUN: %t.out 1
 
 # CHECK: BOLT-INFO: setting __hot_end to
 

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

 #    return interp(argv[1]);
 #}
 
 
 # REQUIRES: system-linux,bolt-runtime
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 # RUN:   %s -o %t.o
-# RUN: %clang %cflags %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:   -o %t.instrumented
 
 # Instrumented program needs to finish returning zero
 # RUN: %t.instrumented 120
 
 # Test that the instrumented data makes sense

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

 # This reproduces a bug with instrumentation when trying to count calls
 # when the target address is computed with a referece to the stack pointer.
 # Our instrumentation code uses the stack to save registers to be
 # transparent with the instrumented code, but we end up updating the stack
 # pointer while doing so, which affects this target address calculation.
 # The solution is to temporarily fix RSP. Check that we correctly instrument
 # these cases.
 
 # REQUIRES: system-linux,bolt-runtime
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 # RUN:   %s -o %t.o
-# RUN: %clang %cflags %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:   -o %t.instrumented
 
 # Instrumented program needs to finish returning zero
 # RUN: %t.instrumented arg1 arg2
 
 # Test that the instrumented data makes sense

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

 # 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
 # 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
 # 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
 # table that was written. If .interp is corrupted, the binary won't run.
 
 # REQUIRES: system-linux
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s -o %t.o
 # RUN: llvm-strip --strip-unneeded %t.o
-# RUN: %clang %cflags -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: %t.exe.bolt 1 2 3
 
   .file "test.S"
   .text
   .globl _start

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

 # 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,
 # it was failing to sign extend a negative result for the relocation (encoded
 # in the immediate operand of an LEA instruction).
 # Originally triggered by https://fossies.org/linux/glib/glib/guniprop.c
 # Line 550: const gchar *p = special_case_table + val - 0x1000000;
 
 # REQUIRES: system-linux
 
 # RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown \
 # RUN:   %s -o %t.o
 # Delete our BB symbols so BOLT doesn't mark them as entry points
 # RUN: llvm-strip --strip-unneeded %t.o
-# RUN: %clang %cflags %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: %t.out 1 2
 
   .text
   .globl  main
   .type main, %function

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

 # This reproduces a bug with shrink wrapping when trying to move
 # push-pops in a function where we are not allowed to modify the
 # stack layout for alignment reasons. In this bug, we failed to
 # propagate alignment requirement upwards in the call graph for
 # some functions when there is a cycle in the call graph.
 
 # 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
 # Delete our BB symbols so BOLT doesn't mark them as entry points
 # RUN: llvm-strip --strip-unneeded %t.o
-# RUN: %clang %cflags %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:   -lite=0 -print-only=main -data %t.fdata -o %t.out | FileCheck %s
 
 # RUN: %t.out
 
 # CHECK: BOLT-INFO: Shrink wrapping moved 1 spills inserting load/stores and 0 spills inserting push/pops
 

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

 # This reproduces a bug with shrink wrapping when moving
 # load instructions in-between the lock prefix and another
 # instruction (where the lock prefix applies).
 
 # 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
 # Delete our BB symbols so BOLT doesn't mark them as entry points
 # RUN: llvm-strip --strip-unneeded %t.o
-# RUN: %clang %cflags %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:    -print-only=main -data %t.fdata -o %t.out | FileCheck %s
 
 # RUN: %t.out 1
 
 # CHECK: BOLT-INFO: Shrink wrapping moved 1 spills inserting load/stores and 0 spills inserting push/pops
 

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

 # This reproduces a bug with shrink wrapping when trying to move
 # push-pops where restores were not validated to be POPs (and could be
 # a regular load, which violated our assumptions). Check that we
 # identify those cases.
 
 # 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
 # Delete our BB symbols so BOLT doesn't mark them as entry points
 # RUN: llvm-strip --strip-unneeded %t.o
-# RUN: %clang %cflags %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:    -print-only=main -data %t.fdata -o %t.out | FileCheck %s
 
 # RUN: %t.out
 
 # CHECK: BOLT-INFO: Shrink wrapping moved 1 spills inserting load/stores and 0 spills inserting push/pops
 

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

 int main(int argc, char **argv) {
   printf("fib(%d) = %d\n", argc, fib(argc));
   return 0;
 }
 
 /*
 REQUIRES: system-linux,bolt-runtime
 
-RUN: %clang %cflags %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:   -hugify -function-order=%p/Inputs/user_func_order.txt -o %t
 RUN: llvm-nm --numeric-sort --print-armap %t | \
 RUN:   FileCheck %s -check-prefix=CHECK-NM
 RUN: %t 1 2 3 | FileCheck %s -check-prefix=CHECK-OUTPUT
 
 CHECK-NM:      W  __hot_start
 CHECK-NM:      T main
 CHECK-NM-NEXT: T fib
 CHECK-NM-NEXT: W __hot_end
 
 CHECK-OUTPUT: fib(4) = 3
 */

bolt/test/runtime/fptr.test

 # Make sure BOLT correctly updates values based on function pointer.
 
-RUN: %clang %cflags %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: %t | FileCheck %s
 
 CHECK: Global = 0x[[#%x,ADDR:]]
 CHECK-NEXT: Local = 0x[[#ADDR]]
 CHECK-NEXT: Local2 = 0x[[#ADDR]]