-; RUN: opt < %s -inline -disable-output
+; RUN: opt < %s -passes=inline -disable-output
declare i32 @External()
-; RUN: opt < %s -inline -disable-output
+; RUN: opt < %s -passes=inline -disable-output
define i32 @main() personality i32 (...)* @__gxx_personality_v0 {
entry:
-; RUN: opt < %s -inline -disable-output
+; RUN: opt < %s -passes=inline -disable-output
define i32 @main() personality i32 (...)* @__gxx_personality_v0 {
entry:
-; RUN: opt < %s -inline -disable-output
+; RUN: opt < %s -passes=inline -disable-output
define i32 @main() personality i32 (...)* @__gxx_personality_v0 {
entry:
-; RUN: opt < %s -inline -disable-output
+; RUN: opt < %s -passes=inline -disable-output
define i32 @reload() {
reloadentry:
-; RUN: opt < %s -inline -disable-output
+; RUN: opt < %s -passes=inline -disable-output
; Inlining the first call caused the inliner function to delete the second
; call. Then the inliner tries to inline the second call, which no longer
-; RUN: opt < %s -inline -disable-output
+; RUN: opt < %s -passes=inline -disable-output
define i32 @test() {
unreachable
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; PR1335
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; 'bar' can be overridden at link-time, don't inline it.
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
declare i1 @extern()
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
define i32 @fn2() noinline {
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; Do not inline calls with variable-sized alloca.
-; RUN: opt < %s -inline -disable-output
+; RUN: opt < %s -passes=inline -disable-output
; PR4123
%struct.S0 = type <{ i32 }>
%struct.S1 = type <{ i8, i8, i8, i8, %struct.S0 }>
-; RUN: opt -inline -mergefunc -disable-output < %s
+; RUN: opt -passes='cgscc(inline),mergefunc' -disable-output < %s
; This tests for a bug where the inliner kept the functions in a ValueMap after
; it had completed and a ModulePass started to run. LLVM would crash deleting
-; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -o - < %s -inline-threshold=0 | FileCheck %s
+; RUN: opt -passes=inline -mtriple=aarch64--linux-gnu -S -o - < %s -inline-threshold=0 | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-gnu"
; REQUIRES: asserts
-; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
+; RUN: opt -passes=inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-gnu"
; REQUIRES: asserts
-; RUN: opt -inline -mtriple=aarch64--linux-gnu -mcpu=kryo -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
+; RUN: opt -passes=inline -mtriple=aarch64--linux-gnu -mcpu=kryo -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-gnu"
-; RUN: opt < %s -mtriple=aarch64-unknown-linux-gnu -S -inline | FileCheck %s
+; RUN: opt < %s -mtriple=aarch64-unknown-linux-gnu -S -passes=inline | FileCheck %s
; RUN: opt < %s -mtriple=aarch64-unknown-linux-gnu -S -passes='cgscc(inline)' | FileCheck %s
; Check that we only inline when we have compatible target attributes.
; REQUIRES: asserts
-; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
+; RUN: opt -passes=inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-gnu"
-; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -o - < %s -inline-threshold=0 | FileCheck %s
+; RUN: opt -passes=inline -mtriple=aarch64--linux-gnu -S -o - < %s -inline-threshold=0 | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-gnu"
-; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -o - < %s -inline-threshold=0 | FileCheck %s
+; RUN: opt -passes=inline -mtriple=aarch64--linux-gnu -S -o - < %s -inline-threshold=0 | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-gnu"
-; RUN: opt < %s -mtriple=aarch64-unknown-linux-gnu -mattr=+sme -S -inline | FileCheck %s
+; RUN: opt < %s -mtriple=aarch64-unknown-linux-gnu -mattr=+sme -S -passes=inline | FileCheck %s
declare void @inlined_body() "aarch64_pstate_sm_compatible";
-; RUN: opt -mtriple=aarch64-unknown-linux-gnu -mattr=+sme -S -inline < %s | FileCheck %s
+; RUN: opt -mtriple=aarch64-unknown-linux-gnu -mattr=+sme -S -passes=inline < %s | FileCheck %s
declare void @inlined_body()
-; RUN: opt -mtriple=aarch64--linux-gnu -mattr=+sve < %s -inline -S | FileCheck %s
+; RUN: opt -mtriple=aarch64--linux-gnu -mattr=+sve < %s -passes=inline -S | FileCheck %s
define void @bar(<vscale x 2 x i64>* %a) {
entry:
-; RUN: opt < %s -inline -inline-threshold=20 -S -mtriple=aarch64-none-linux | FileCheck %s
+; RUN: opt < %s -passes=inline -inline-threshold=20 -S -mtriple=aarch64-none-linux | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -inline-threshold=20 -S -mtriple=aarch64-none-linux | FileCheck %s
define i32 @callee_range(i32 %a, i32* %P) {
-; RUN: opt -mtriple=amdgcn--amdhsa -S -inline -inline-threshold=0 < %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn--amdhsa -S -passes=inline -inline-threshold=0 < %s | FileCheck %s
; RUN: opt -mtriple=amdgcn--amdhsa -S -passes=inline -inline-threshold=0 < %s | FileCheck %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
-; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -inline < %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes=inline < %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes='cgscc(inline)' < %s | FileCheck %s
define i32 @func_default() #0 {
-; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -inline < %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes=inline < %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes='cgscc(inline)' < %s | FileCheck %s
define i32 @func_default() #0 {
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-globals
-; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -inline < %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes=inline < %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes='cgscc(inline)' < %s | FileCheck %s
define i32 @func_default() #0 {
-; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -inline --inline-threshold=1 < %s | FileCheck %s
+; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -passes=inline --inline-threshold=1 < %s | FileCheck %s
; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -passes=inline --inline-threshold=1 < %s | FileCheck %s
define hidden <16 x i32> @div_vecbonus(<16 x i32> %x, <16 x i32> %y) {
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -inline < %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes=inline < %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes='cgscc(inline)' < %s | FileCheck %s
define i32 @func_default() {
-; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -inline --inline-threshold=1 --inlinehint-threshold=4 < %s | FileCheck %s
+; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -passes=inline --inline-threshold=1 --inlinehint-threshold=4 < %s | FileCheck %s
; RUN: opt -S -mtriple=amdgcn-unknown-amdhsa -passes=inline --inline-threshold=1 --inlinehint-threshold=4 < %s | FileCheck %s
define hidden <16 x i32> @div_hint(<16 x i32> %x, <16 x i32> %y) #0 {
-; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -inline < %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes=inline < %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes='cgscc(inline)' < %s | FileCheck %s
; CHECK-LABEL: @func_no_target_cpu(
-; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -inline < %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes=inline < %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes='cgscc(inline)' < %s | FileCheck %s
; sram-ecc can be safely ignored when inlining, since no intrinisics
-; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -inline < %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes=inline < %s | FileCheck %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes='cgscc(inline)' < %s | FileCheck %s
define i32 @func_default() #0 {
-; RUN: opt -S -inline -mtriple=arm-eabi -pass-remarks=.* -pass-remarks-missed=.* < %s 2>&1 | FileCheck %s -check-prefix=NOFP
-; RUN: opt -S -inline -mtriple=arm-eabi -mattr=+vfp2 -pass-remarks=.* -pass-remarks-missed=.* < %s 2>&1 | FileCheck %s -check-prefix=FULLFP
-; RUN: opt -S -inline -mtriple=arm-eabi -mattr=+vfp2,-fp64 -pass-remarks=.* -pass-remarks-missed=.* < %s 2>&1 | FileCheck %s -check-prefix=SINGLEFP
+; RUN: opt -S -passes=inline -mtriple=arm-eabi -pass-remarks=.* -pass-remarks-missed=.* < %s 2>&1 | FileCheck %s -check-prefix=NOFP
+; RUN: opt -S -passes=inline -mtriple=arm-eabi -mattr=+vfp2 -pass-remarks=.* -pass-remarks-missed=.* < %s 2>&1 | FileCheck %s -check-prefix=FULLFP
+; RUN: opt -S -passes=inline -mtriple=arm-eabi -mattr=+vfp2,-fp64 -pass-remarks=.* -pass-remarks-missed=.* < %s 2>&1 | FileCheck %s -check-prefix=SINGLEFP
; Make sure that soft float implementations are calculated as being more expensive
; to the inliner.
-; RUN: opt < %s -mtriple=arm-unknown-linux-gnu -S -inline | FileCheck %s
+; RUN: opt < %s -mtriple=arm-unknown-linux-gnu -S -passes=inline | FileCheck %s
; RUN: opt < %s -mtriple=arm-unknown-linux-gnu -S -passes='cgscc(inline)' | FileCheck %s
; Check that we only inline when we have compatible target attributes.
; ARM has implemented a target attribute that will verify that the attribute
-; RUN: opt -inline %s -S | FileCheck %s
+; RUN: opt -passes=inline %s -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv7m-arm-none-eabi"
-; RUN: opt -inline %s -S | FileCheck %s
+; RUN: opt -passes=inline %s -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv7m-arm-none-eabi"
-; RUN: opt -inline %s -S | FileCheck %s
+; RUN: opt -passes=inline %s -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv7m-arm-none-eabi"
-; RUN: opt < %s -partial-inliner -disable-output
+; RUN: opt < %s -passes=partial-inliner -disable-output
; RUN: opt < %s -passes=partial-inliner -disable-output
define i32 @f() {
; REQUIRES: asserts
-; RUN: opt -inline -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
+; RUN: opt -passes=inline -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64le-ibm-linux-gnu"
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -mtriple=wasm32-unknown-unknown -S -inline | FileCheck %s
+; RUN: opt < %s -mtriple=wasm32-unknown-unknown -S -passes=inline | FileCheck %s
; Check that having functions can be inlined into callers only when
; they have a subset of the caller's features.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -inline | FileCheck %s
+; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -passes=inline | FileCheck %s
; Test for PR52660.
; REQUIRES: asserts
-; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
+; RUN: opt -passes=inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-unknown"
-; RUN: opt < %s -inline -inline-threshold=0 -debug-only=inline-cost -print-instruction-comments -S -mtriple=x86_64-unknown-linux-gnu 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=inline -inline-threshold=0 -debug-only=inline-cost -print-instruction-comments -S -mtriple=x86_64-unknown-linux-gnu 2>&1 | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -inline-threshold=0 -debug-only=inline-cost -print-instruction-comments -S -mtriple=x86_64-unknown-linux-gnu 2>&1 | FileCheck %s
; REQUIRES: asserts
-; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -inline | FileCheck %s
+; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -passes=inline | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -passes='cgscc(inline)' | FileCheck %s
; Check that we only inline when we have compatible target attributes.
; X86 has implemented a target attribute that will verify that the attribute
-; RUN: opt < %s -mtriple=i686-unknown-unknown -S -inline | FileCheck %s
+; RUN: opt < %s -mtriple=i686-unknown-unknown -S -passes=inline | FileCheck %s
define i32 @func_target_cpu_nocona() #0 {
ret i32 0
-; RUN: opt < %s -mtriple=x86_64-unknown-unknown -S -inline | FileCheck %s
+; RUN: opt < %s -mtriple=x86_64-unknown-unknown -S -passes=inline | FileCheck %s
define i32 @func_target_cpu_base() #0 {
ret i32 0
-; RUN: opt < %s -inline -inline-threshold=0 -debug-only=inline-cost -print-instruction-comments -S -mtriple=x86_64-unknown-linux-gnu 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=inline -inline-threshold=0 -debug-only=inline-cost -print-instruction-comments -S -mtriple=x86_64-unknown-linux-gnu 2>&1 | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -inline-threshold=0 -debug-only=inline-cost -print-instruction-comments -S -mtriple=x86_64-unknown-linux-gnu 2>&1 | FileCheck %s
; REQUIRES: asserts
-; RUN: opt < %s -inline -inline-threshold=1 -S -mtriple=x86_64-unknown-linux-gnu | FileCheck %s
+; RUN: opt < %s -passes=inline -inline-threshold=1 -S -mtriple=x86_64-unknown-linux-gnu | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -inline-threshold=1 -S -mtriple=x86_64-unknown-linux-gnu | FileCheck %s
define i32 @callee_range(i32 %a, i32* %P) {
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt -inline -preserve-alignment-assumptions-during-inlining -S < %s | FileCheck %s
+; RUN: opt -passes=inline -preserve-alignment-assumptions-during-inlining -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
-; RUN: opt -inline < %s -S -o - -inline-threshold=8 | FileCheck %s
+; RUN: opt -passes=inline < %s -S -o - -inline-threshold=8 | FileCheck %s
; RUN: opt -passes='cgscc(inline)' < %s -S -o - -inline-threshold=8 | FileCheck %s
target datalayout = "p:32:32"
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
; struct A {
; int arg0;
; double arg1[2];
; } a, b;
-;
+;
; void fn3(A p1) {
; if (p1.arg0)
; a = p1;
; }
-;
+;
; void fn4() { fn3(b); }
-;
+;
; void fn5() {
; while (1)
; fn4();
-; RUN: opt < %s -inline | llvm-dis
+; RUN: opt < %s -passes=inline | llvm-dis
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin10.0"
define internal fastcc void @a() nounwind ssp {
entry:
%al = alloca [3 x i32], align 4
- %0 = getelementptr inbounds [3 x i32], [3 x i32]* %al, i32 0, i32 2
-
+ %0 = getelementptr inbounds [3 x i32], [3 x i32]* %al, i32 0, i32 2
+
call fastcc void @c() nounwind
unreachable
}
; This test ensures that alloca instructions in the entry block for an inlined
; function are moved to the top of the function they are inlined into.
;
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
; RUN: opt -S -passes='cgscc(inline)' < %s | FileCheck %s
define i32 @func(i32 %i) {
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt -inline -S < %s | FileCheck --check-prefixes=CHECK,NO_ASSUME %s
-; RUN: opt -inline -S --enable-knowledge-retention < %s | FileCheck %s --check-prefixes=CHECK,USE_ASSUME
+; RUN: opt -passes=inline -S < %s | FileCheck --check-prefixes=CHECK,NO_ASSUME %s
+; RUN: opt -passes=inline -S --enable-knowledge-retention < %s | FileCheck %s --check-prefixes=CHECK,USE_ASSUME
; The callee guarantees that the pointer argument is nonnull and dereferenceable.
; That information should transfer to the caller.
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
%struct.A = type { i32 }
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
; CHECK-NEXT: ret i32
}
-; Check that no-jump-tables flag propagates from inlined callee to caller
+; Check that no-jump-tables flag propagates from inlined callee to caller
define i32 @no-use-jump-tables_callee0(i32 %i) {
ret i32 %i
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
; PR10162
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt -inline -preserve-alignment-assumptions-during-inlining -S < %s | FileCheck %s
+; RUN: opt -passes=inline -preserve-alignment-assumptions-during-inlining -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt -inline -preserve-alignment-assumptions-during-inlining -S < %s | FileCheck %s
+; RUN: opt -passes=inline -preserve-alignment-assumptions-during-inlining -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -tailcallelim -inline -instcombine -dse -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes='function(tailcallelim),cgscc(inline,function(instcombine,dse))' -S | FileCheck %s
; PR7272
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; The verifier does catch problems with inlining of byval arguments that has a
; different address space compared to the alloca. But running instcombine
; after inline used to trigger asserts unless we disallow such inlining.
-; RUN: opt < %s -inline -instcombine -disable-output 2>/dev/null
+; RUN: opt < %s -passes=inline,instcombine -disable-output 2>/dev/null
target datalayout = "p:32:32-p1:64:64-p2:16:16-n16:32:64"
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
; By inlining foo, an alloca is created in main to hold the byval argument, so
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; Always prefer call site attribute over function attribute
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
; RUN: opt -passes='module-inline' -S < %s | FileCheck %s
-; RUN: opt < %s -inline -loop-rotate -verify-dom-info -verify-loop-info -disable-output
+; RUN: opt < %s -passes=inline,loop-rotate -verify-dom-info -verify-loop-info -disable-output
; PR3601
declare void @solve()
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; RUN: opt < %s -passes='module-inline' -S | FileCheck %s
; This test ensures that inlining an "empty" function does not destroy the CFG
;
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
define i32 @func(i32 %i) {
ret i32 %i
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
; RUN: opt -passes='module-inline' -S < %s | FileCheck %s
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; RUN: opt < %s -passes='module-inline' -S | FileCheck %s
-; RUN: opt < %s -always-inline -S | FileCheck %s
+; RUN: opt < %s -passes=always-inline -S | FileCheck %s
; RUN: opt -passes='always-inline' -S < %s | FileCheck %s
; Original input generated from clang -emit-llvm -S -c -mllvm -disable-llvm-optzns
-; RUN: opt < %s -always-inline -S | FileCheck %s
+; RUN: opt < %s -passes=always-inline -S | FileCheck %s
; Test that the debug location is preserved when rewriting an inlined call as an invoke
-; RUN: opt -S -always-inline < %s | FileCheck %s
+; RUN: opt -S -passes=always-inline < %s | FileCheck %s
declare void @f()
declare i32 @g()
-; RUN: opt -S -always-inline < %s | FileCheck %s
+; RUN: opt -S -passes=always-inline < %s | FileCheck %s
declare cc42 i32 @llvm.experimental.deoptimize.i32(...)
attributes #0 = { "deopt-lowering"="live-in" }
; CHECK: declare cc42 void @llvm.experimental.deoptimize.isVoid(...)
-; CHECK: attributes #1 = { "deopt-lowering"="live-in" }
\ No newline at end of file
+; CHECK: attributes #1 = { "deopt-lowering"="live-in" }
-; RUN: opt -S -always-inline < %s | FileCheck %s
+; RUN: opt -S -passes=always-inline < %s | FileCheck %s
declare cc42 i32 @llvm.experimental.deoptimize.i32(...)
-; RUN: opt -S -always-inline < %s | FileCheck %s
+; RUN: opt -S -passes=always-inline < %s | FileCheck %s
declare i8 @llvm.experimental.deoptimize.i8(...)
declare i32 @llvm.experimental.deoptimize.i32(...)
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -inline < %s -S -o - | FileCheck %s
+; RUN: opt -passes=inline < %s -S -o - | FileCheck %s
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0"
; Functions with dynamic allocas can only be inlined into functions that
; already have dynamic allocas.
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
;
; FIXME: This test is xfailed because the inline cost rewrite disabled *all*
; inlining of functions which contain a dynamic alloca. It should be re-enabled
-; RUN: opt -S -inline %s -debug-only=inline-cost 2>&1 | FileCheck %s
+; RUN: opt -S -passes=inline %s -debug-only=inline-cost 2>&1 | FileCheck %s
; REQUIRES: asserts
@a = global i32 4
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
declare void @foo()
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
define available_externally i32 @test_function() {
; CHECK-NOT: @test_function
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
; RUN: opt -passes='module-inline' -S < %s | FileCheck %s
-; RUN: opt -S -always-inline < %s | FileCheck %s
+; RUN: opt -S -passes=always-inline < %s | FileCheck %s
declare void @llvm.experimental.guard(i1, ...)
-; RUN: opt < %s -S -inline -inline-threshold=2 | FileCheck %s
-; RUN: opt < %s -S -strip-debug -inline -inline-threshold=2 | FileCheck %s
+; RUN: opt < %s -S -passes=inline -inline-threshold=2 | FileCheck %s
+; RUN: opt < %s -S -strip-debug -passes=inline -inline-threshold=2 | FileCheck %s
; RUN: opt < %s -S -passes='cgscc(inline)' -inline-threshold=2 | FileCheck %s
; RUN: opt < %s -S -strip-debug -passes='cgscc(inline)' -inline-threshold=2 | FileCheck %s
;
-; RUN: opt -always-inline -S < %s | FileCheck %s
+; RUN: opt -passes=always-inline -S < %s | FileCheck %s
; RUN: opt -passes=always-inline -S < %s | FileCheck %s
; We used to misclassify inalloca as a static alloca in the inliner. This only
-; RUN: opt -S -o - %s -inline | FileCheck %s
+; RUN: opt -S -o - %s -passes=inline | FileCheck %s
define void @f1() {
bb.0:
-; RUN: opt -inline -S -o - < %s | FileCheck %s
+; RUN: opt -passes=inline -S -o - < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
; RUN: opt -passes='module-inline' -S < %s | FileCheck %s
; Test that inliner skips @llvm.icall.branch.funnel
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
target datalayout = "e-p:64:64"
target triple = "x86_64-unknown-linux-gnu"
-; RUN: opt -S -inline -inline-threshold=275 < %s | FileCheck %s
+; RUN: opt -S -passes=inline -inline-threshold=275 < %s | FileCheck %s
; RUN: opt -S -passes='cgscc(inline)' -inline-threshold=275 < %s | FileCheck %s
; PR13095
; Check that calls are not inlined if the call penalty is low. The value of the
; call penalty is provided with the '--inline-call-penalty' option.
;
-; RUN: opt < %s -inline --inline-call-penalty=0 --inline-threshold=5 -S | FileCheck %s
-; RUN: opt < %s -inline --inline-threshold=5 -S | FileCheck %s -check-prefix=DEFAULT_CALL_PENALTY
+; RUN: opt < %s -passes=inline --inline-call-penalty=0 --inline-threshold=5 -S | FileCheck %s
+; RUN: opt < %s -passes=inline --inline-threshold=5 -S | FileCheck %s -check-prefix=DEFAULT_CALL_PENALTY
declare void @extern()
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
; RUN: opt -S -passes='cgscc(inline)' < %s | FileCheck %s
; RUN: opt -S -passes='module-inline' < %s | FileCheck %s
; a direct call to g with bitcasted arguments, leaving the original bitcast
; as a dead use of g.
-; RUN: opt < %s -instcombine -inline -pass-remarks=inline -S 2>&1 \
+; RUN: opt < %s -passes='function(instcombine),cgscc(inline)' -pass-remarks=inline -S 2>&1 \
; RUN: | FileCheck %s
; Inline costs of f and g should be the same.
-; RUN: opt < %s -S -inline -inline-threshold=20 | FileCheck %s
+; RUN: opt < %s -S -passes=inline -inline-threshold=20 | FileCheck %s
; RUN: opt < %s -S -passes='cgscc(inline)' -inline-threshold=20 | FileCheck %s
; RUN: opt < %s -S -passes='module-inline' -inline-threshold=20 | FileCheck %s
; Check that we don't drop FastMathFlag when estimating inlining profitability.
-; RUN: opt -inline -S %s | FileCheck %s
+; RUN: opt -passes=inline -S %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S %s | FileCheck %s
declare void @g()
-; RUN: opt -inline -early-cse -earlycse-debug-hash < %s
+; RUN: opt -passes=inline,early-cse -earlycse-debug-hash < %s
; This test used to crash (PR35469).
define void @func1() {
-; RUN: opt < %s -inline -disable-output 2>/dev/null
+; RUN: opt < %s -passes=inline -disable-output 2>/dev/null
; This test used to trigger an assertion in the assumption cache when
; inlining the indirect call
declare void @llvm.assume(i1)
-; RUN: opt < %s -inline -S | not grep "tail call void @llvm.memcpy.p0i8.p0i8.i32"
+; RUN: opt < %s -passes=inline -S | not grep "tail call void @llvm.memcpy.p0i8.p0i8.i32"
; PR3550
define internal void @foo(i32* %p, i32* %q) {
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
target triple = "x86_64-apple-darwin"
-; RUN: opt %s -inline -S | FileCheck %s
+; RUN: opt %s -passes=inline -S | FileCheck %s
define internal void @innerSmall() "min-legal-vector-width"="128" {
ret void
; Test to ensure no inlining is allowed into a caller with fewer nobuiltin attributes.
-; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -inline | FileCheck %s
+; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -passes=inline | FileCheck %s
; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -passes='cgscc(inline)' | FileCheck %s
; Make sure we don't inline callees into a caller with a superset of the
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s --passes=inline -S | FileCheck %s
; Test that functions with attribute optnone are not inlined.
-; RUN: opt %s -inline -S | FileCheck %s
+; RUN: opt %s -passes=inline -S | FileCheck %s
define internal void @inner() "probe-stack"="__probestackinner" {
ret void
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; InlineCost used to have problems with the ptrtoint, leading to
; crashes when visiting the trunc in pr47969_help and the icmp in
; Check the recursive inliner doesn't inline a function with a stack size exceeding a given limit.
-; RUN: opt < %s -inline -S | FileCheck --check-prefixes=ALL,UNLIMITED %s
-; RUN: opt < %s -inline -S -recursive-inline-max-stacksize=256 | FileCheck --check-prefixes=ALL,LIMITED %s
+; RUN: opt < %s -passes=inline -S | FileCheck --check-prefixes=ALL,UNLIMITED %s
+; RUN: opt < %s -passes=inline -S -recursive-inline-max-stacksize=256 | FileCheck --check-prefixes=ALL,LIMITED %s
declare void @init([65 x i32]*)
-; RUN: opt < %s -inline -inline-remark-attribute --inline-threshold=0 -S | FileCheck %s
+; RUN: opt < %s -passes=inline -inline-remark-attribute --inline-threshold=0 -S | FileCheck %s
; Test that the inliner adds inline remark attributes to non-inlined callsites.
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
@g0 = global i8* null, align 8
declare i8* @foo0()
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
define void @func() {
; CHECK-LABEL: func
; Check that @callee1 gets inlined while @callee2 is not, because of
; SemanticInterposition.
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
define internal i32 @callee1(i32 %A) {
ret i32 %A
-; RUN: opt < %s -S -inline | FileCheck %s
-; RUN: opt < %s -S -strip-debug -inline | FileCheck %s
+; RUN: opt < %s -S -passes=inline | FileCheck %s
+; RUN: opt < %s -S -strip-debug -passes=inline | FileCheck %s
; https://bugs.llvm.org/show_bug.cgi?id=43291
; The purpose of this test is to check if there is use_empty in the inner loop when scanning
-; RUN: opt %s -inline -S | FileCheck %s
+; RUN: opt %s -passes=inline -S | FileCheck %s
define internal void @innerSmall() "stack-probe-size"="4096" {
ret void
; Check the inliner doesn't inline a function with a stack size exceeding a given limit.
-; RUN: opt < %s -inline -S | FileCheck --check-prefixes=ALL,UNLIMITED %s
-; RUN: opt < %s -inline -S -inline-max-stacksize=256 | FileCheck --check-prefixes=ALL,LIMITED %s
+; RUN: opt < %s -passes=inline -S | FileCheck --check-prefixes=ALL,UNLIMITED %s
+; RUN: opt < %s -passes=inline -S -inline-max-stacksize=256 | FileCheck --check-prefixes=ALL,LIMITED %s
declare void @init([65 x i32]*)
-; RUN: opt -inline %s -S | FileCheck %s
+; RUN: opt -passes=inline %s -S | FileCheck %s
; Ordinary function is inlined into strictfp function.
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; We have to apply the less restrictive TailCallKind of the call site being
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline,function(instcombine))' -S | FileCheck %s
declare void @ext_method(i8*, i32)
-; RUN: opt -S -inline %s -o - | FileCheck %s
+; RUN: opt -S -passes=inline %s -o - | FileCheck %s
; RUN: opt -S -passes='cgscc(inline)' %s -o - | FileCheck %s
; RUN: opt -S -passes='module-inline' %s -o - | FileCheck %s
; Test that the inliner doesn't leave around dead allocas, and that it folds
; uncond branches away after it is done specializing.
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
@A = weak global i32 0 ; <i32*> [#uses=1]
-; RUN: opt < %s -inline -inline-threshold=20 -S | FileCheck %s
+; RUN: opt < %s -passes=inline -inline-threshold=20 -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -inline-threshold=20 -S | FileCheck %s
define internal i32 @callee1(i32 %A, i32 %B) {
-; RUN: opt < %s -S -inline | FileCheck %s
+; RUN: opt < %s -S -passes=inline | FileCheck %s
; RUN: opt < %s -S -passes='cgscc(inline)' | FileCheck %s
;
; The purpose of this test is to check that inline pass preserves debug info
-; This checks to ensure that the inline pass deletes functions if they get
+; This checks to ensure that the inline pass deletes functions if they get
; inlined into all of their callers.
-; RUN: opt < %s -inline -S | \
+; RUN: opt < %s -passes=inline -S | \
; RUN: not grep @reallysmall
define internal i32 @reallysmall(i32 %A) {
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; Test that the inliner correctly handles inlining into invoke sites
-; RUN: opt -inline -inline-threshold=225 -inlinehint-threshold=360 -S < %s | FileCheck %s
+; RUN: opt -passes=inline -inline-threshold=225 -inlinehint-threshold=360 -S < %s | FileCheck %s
@data = common global i32* null, align 8
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; PR42084
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
define internal i32 @callee1(i32 %A, i32 %B) {
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; Check that functions with "returns_twice" calls are only inlined,
-; RUN: opt -inline %s -S | FileCheck %s
+; RUN: opt -passes=inline %s -S | FileCheck %s
; RUN: opt -passes='cgscc(inline)' %s -S | FileCheck %s
; Ensure SSP attributes are propagated correctly when inlining.
; First with legacy PM
-; RUN: opt -S -inline -inliner-function-import-stats=basic < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-BASIC,CHECK
-; RUN: opt -S -inline -inliner-function-import-stats=verbose < %s 2>&1 | FileCheck %s --check-prefixes="CHECK-VERBOSE",CHECK
+; RUN: opt -S -passes=inline -inliner-function-import-stats=basic < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-BASIC,CHECK
+; RUN: opt -S -passes=inline -inliner-function-import-stats=verbose < %s 2>&1 | FileCheck %s --check-prefixes="CHECK-VERBOSE",CHECK
; Do again with new PM
; RUN: opt -S -passes=inline -inliner-function-import-stats=basic < %s 2>&1 | FileCheck %s --check-prefixes=CHECK-BASIC,CHECK
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; CHECK-LABEL: caller
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
@a = global i32 4
; This test checks that the !llvm.loop metadata has been updated after inlining
; so that the start and end locations refer to the inlined DILocations.
-; RUN: opt -inline -always-inline %s -S 2>&1 | FileCheck %s
+; RUN: opt -passes='cgscc(inline),always-inline' %s -S 2>&1 | FileCheck %s
; CHECK: br i1 %{{.*}}, label %middle.block.i, label %vector.body.i, !dbg !{{[0-9]+}}, !llvm.loop [[VECTOR:![0-9]+]]
; CHECK: br i1 %{{.*}}, label %for.cond.cleanup.loopexit.i, label %for.body.i, !dbg !{{[0-9]+}}, !llvm.loop [[SCALAR:![0-9]+]]
; CHECK-DAG: [[VECTOR]] = distinct !{[[VECTOR]], [[START:![0-9]+]], [[END:![0-9]+]], [[IS_VECTORIZED:![0-9]+]]}
; This test checks that the !llvm.loop metadata has been updated after inlining
; so that the start and end locations refer to the inlined DILocations.
-; RUN: opt -inline -always-inline %s -S 2>&1 | FileCheck %s
+; RUN: opt -passes='cgscc(inline),always-inline' %s -S 2>&1 | FileCheck %s
; CHECK: br i1 %{{.*}}, label %middle.block.i, label %vector.body.i, !dbg !{{[0-9]+}}, !llvm.loop [[VECTOR:![0-9]+]]
; CHECK: br i1 %{{.*}}, label %for.cond.cleanup.loopexit.i, label %for.body.i, !dbg !{{[0-9]+}}, !llvm.loop [[SCALAR:![0-9]+]]
; CHECK-DAG: [[VECTOR]] = distinct !{[[VECTOR]], [[START:![0-9]+]], [[END:![0-9]+]], [[IS_VECTORIZED:![0-9]+]]}
; Test that the inliner can handle deleting functions within an SCC while still
; processing the calls in that SCC.
;
-; RUN: opt < %s -S -inline | FileCheck %s
+; RUN: opt < %s -S -passes=inline | FileCheck %s
; RUN: opt < %s -S -passes=inline | FileCheck %s
; RUN: opt < %s -S -passes=inliner-wrapper | FileCheck %s
-; RUN: opt %s -inline -S | FileCheck %s
+; RUN: opt %s -passes=inline -S | FileCheck %s
; RUN: opt %s -passes='cgscc(inline)' -S | FileCheck %s
; RUN: opt %s -passes='module-inline' -S | FileCheck %s
-; RUN: opt -inline < %s -S -o - -inline-threshold=100 | FileCheck %s
+; RUN: opt -passes=inline < %s -S -o - -inline-threshold=100 | FileCheck %s
; RUN: opt -passes='cgscc(inline)' < %s -S -o - -inline-threshold=100 | FileCheck %s
target datalayout = "p:32:32"
; Test that we can inline a simple function, turning the calls in it into invoke
; instructions
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; RUN: opt < %s -passes='module-inline' -S | FileCheck %s
; Test that if an invoked function is inlined, and if that function cannot
; throw, that the dead handler is now unreachable.
-; RUN: opt < %s -inline -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S | FileCheck %s
+; RUN: opt < %s -passes=inline,simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S | FileCheck %s
declare void @might_throw()
; Test that any rethrown exceptions in an inlined function are automatically
; turned into branches to the invoke destination.
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; RUN: opt < %s -passes='module-inline' -S | FileCheck %s
; Inlining should not clone label annotations.
; Currently we block all duplication for simplicity.
-; RUN: opt < %s -S -inline | FileCheck %s
+; RUN: opt < %s -S -passes=inline | FileCheck %s
@the_global = global i32 0
; callsites big enough, loop unrolling pass with very high threshold is used to
; preprocess the test.
-; RUN: opt < %s -loop-unroll -inline -unroll-threshold=15000 -inline-threshold=250 -S | FileCheck %s
; RUN: opt < %s -passes='function(require<opt-remark-emit>,loop-unroll),require<profile-summary>,cgscc(inline)' -unroll-threshold=15000 -inline-threshold=250 -S | FileCheck %s
; CHECK-LABEL: define internal i32 @bar()
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
; RUN: opt -S -O3 < %s | FileCheck %s
-; RUN: opt -S -inline -inline-threshold=1 < %s | FileCheck %s
+; RUN: opt -S -passes=inline -inline-threshold=1 < %s | FileCheck %s
%struct.A = type <{ i32 (...)**, i32, [4 x i8] }>
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
declare void @use(i8* %a)
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;; }
-; RUN: opt -inline %s -S | FileCheck %s
+; RUN: opt -passes=inline %s -S | FileCheck %s
; ModuleID = 'memprof_inline.cc'
source_filename = "memprof_inline.cc"
;; return 0;
;; }
-; RUN: opt -inline %s -S | FileCheck %s
+; RUN: opt -passes=inline %s -S | FileCheck %s
; ModuleID = 'memprof_inline2.cc'
source_filename = "memprof_inline2.cc"
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; RUN: opt < %s -passes='module-inline' -S | FileCheck %s
; Test that bar and bar2 are both inlined throughout and removed.
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; This tests that functions with the attribute `no-inline-line-tables` have the
; correct debug information when they are inlined.
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+; RUN: opt -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+; RUN: opt -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
-; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+; RUN: opt -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
-; RUN: opt -inline -enable-noalias-to-md-conversion --enable-knowledge-retention -S < %s | FileCheck %s
+; RUN: opt -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s
+; RUN: opt -passes=inline -enable-noalias-to-md-conversion --enable-knowledge-retention -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
define void @caller(i8* %ptr) {
; CHECK-LABEL: define {{[^@]+}}@caller
; This effectively is just peeling off the first iteration of a loop, and the
; inliner heuristics are not set up for this.
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; PR6682
declare void @foo() nounwind
-; RUN: opt -S -inline %s | FileCheck %s
+; RUN: opt -S -passes=inline %s | FileCheck %s
; RUN: opt -S -passes='cgscc(inline)' %s | FileCheck %s
; RUN: opt -S -passes='module-inline' %s | FileCheck %s
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
define void @test(ptr %p1, ptr %p2) {
; CHECK-LABEL: @test(
-; RUN: opt < %s -S -inline -pass-remarks=inline \
+; RUN: opt < %s -S -passes=inline -pass-remarks=inline \
; RUN: -pass-remarks-with-hotness 2>&1 | FileCheck %s
; RUN: opt < %s -S -passes=inline -pass-remarks-output=%t -pass-remarks=inline \
-; RUN: opt < %s -S -inline -pass-remarks-output=%t -pass-remarks=inline \
+; RUN: opt < %s -S -passes=inline -pass-remarks-output=%t -pass-remarks=inline \
; RUN: -pass-remarks-missed=inline -pass-remarks-analysis=inline \
; RUN: -pass-remarks-with-hotness 2>&1 | FileCheck %s
; RUN: cat %t | FileCheck -check-prefixes=YAML,YAML-NO-ANNOTATE %s
-; RUN: opt < %s -inline -pass-remarks=inline -pass-remarks-missed=inline \
+; RUN: opt < %s -passes=inline -pass-remarks=inline -pass-remarks-missed=inline \
; RUN: -pass-remarks-analysis=inline -pass-remarks-with-hotness -S 2>&1 \
; RUN: | FileCheck %s
; RUN: opt < %s -passes=inline -pass-remarks=inline -pass-remarks-missed=inline \
-; RUN: opt < %s -S -inline -pass-remarks-missed=inline \
+; RUN: opt < %s -S -passes=inline -pass-remarks-missed=inline \
; RUN: -pass-remarks-with-hotness -pass-remarks-hotness-threshold 15 \
; RUN: -pass-remarks-output=%t 2>&1 | FileCheck %s
; RUN: cat %t | FileCheck -check-prefix=YAML %s
-; RUN: opt < %s -S -inline -pass-remarks-with-hotness -pass-remarks-output=%t
+; RUN: opt < %s -S -passes=inline -pass-remarks-with-hotness -pass-remarks-output=%t
; RUN: cat %t | FileCheck -check-prefix=YAML %s
;
; Verify that remarks that don't meet the hotness threshold are not output.
-; RUN: opt < %s -S -inline -pass-remarks-missed=inline \
+; RUN: opt < %s -S -passes=inline -pass-remarks-missed=inline \
; RUN: -pass-remarks-with-hotness -pass-remarks-hotness-threshold 100 \
; RUN: -pass-remarks-output=%t.threshold 2>&1 | \
; RUN: FileCheck -check-prefix=THRESHOLD %s
; RUN: test ! -s %t.threshold
-; RUN: opt < %s -S -inline \
+; RUN: opt < %s -S -passes=inline \
; RUN: -pass-remarks-with-hotness -pass-remarks-hotness-threshold 100 \
; RUN: -pass-remarks-output=%t.threshold
; The remarks output file should be empty.
-; RUN: opt < %s -inline -pass-remarks=inline -pass-remarks-missed=inline \
+; RUN: opt < %s -passes=inline -pass-remarks=inline -pass-remarks-missed=inline \
; RUN: -pass-remarks-analysis=inline -S 2>&1 | \
; RUN: FileCheck -check-prefixes=CHECK,NO_HOTNESS,ALWAYS %s
-; RUN: opt < %s -inline -pass-remarks=inline -pass-remarks-missed=inline \
+; RUN: opt < %s -passes=inline -pass-remarks=inline -pass-remarks-missed=inline \
; RUN: -pass-remarks-analysis=inline -pass-remarks-with-hotness -S 2>&1 | \
; RUN: FileCheck -check-prefixes=CHECK,HOTNESS,ALWAYS %s
%mul = fmul float %conv, %call2
%conv3 = fptosi float %mul to i32
%call3 = call i32 @fox()
- %add = add i32 %conv3, %call
+ %add = add i32 %conv3, %call
ret i32 %add
}
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
;
; Check that the !llvm.access.group is still present after inlining.
;
-; RUN: opt -always-inline -globalopt -S < %s | FileCheck %s
+; RUN: opt -passes=always-inline,globalopt -S < %s | FileCheck %s
;
; static void __attribute__((always_inline)) callee(long n, double A[static const restrict n], long i) {
; for (long j = 0; j < n; j += 1)
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
; RUN: opt -S -passes='cgscc(inline)' < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
-; RUN: opt < %s -partial-inliner -skip-partial-inlining-cost-analysis -disable-output
+; RUN: opt < %s -passes=partial-inliner -skip-partial-inlining-cost-analysis -disable-output
; This testcase tests the assumption cache
define internal i32 @inlinedFunc(i1 %cond, i32* align 4 %align.val) {
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
; RUN: opt < %s -passes='module-inline' -S | FileCheck %s
-; RUN: opt -S -inline -inline-threshold=100 -inline-cold-callsite-threshold=100 < %s | FileCheck %s
+; RUN: opt -S -passes=inline -inline-threshold=100 -inline-cold-callsite-threshold=100 < %s | FileCheck %s
; RUN: opt -S -passes='cgscc(inline)' -inline-threshold=100 -inline-cold-callsite-threshold=100 < %s | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc18.0.0"
-; RUN: opt -inline < %s
+; RUN: opt -passes=inline < %s
define void @patatino() {
for.cond:
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
declare void @external_function(i8*)
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
; This tests cases where instructions in the callee are simplified to
; instructions in the caller, thus making VMap contain instructions from
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
; Test interaction of simplification during cloning with insertion of scoped
; noalias metadata.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -inline < %s | FileCheck %s
+; RUN: opt -S -passes=inline < %s | FileCheck %s
; Check that the exception handling code is fully pruned, and does not
; leave behind invalid IR.
-; RUN: opt < %s -S -inline | FileCheck %s
+; RUN: opt < %s -S -passes=inline | FileCheck %s
; RUN: opt < %s -S -passes='cgscc(inline)' | FileCheck %s
; Make sure that profile and unpredictable metadata is preserved when cloning a select.
-; RUN: opt -inline < %s -S -o - -inline-threshold=10 | FileCheck %s
+; RUN: opt -passes=inline < %s -S -o - -inline-threshold=10 | FileCheck %s
target datalayout = "p:32:32-p1:64:64-p2:16:16-n16:32:64"
ret i32 %x
}
-declare void @extern()
\ No newline at end of file
+declare void @extern()
; Inlining in the presence of recursion presents special challenges that we
; test here.
;
-; RUN: opt -inline -S < %s | FileCheck %s
+; RUN: opt -passes=inline -S < %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
define i32 @large_stack_callee(i32 %param) {
-; RUN: opt -inline < %s -S -o - -inline-threshold=3 | FileCheck %s
+; RUN: opt -passes=inline < %s -S -o - -inline-threshold=3 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -inline-threshold=0 -always-inline -S | FileCheck %s
+; RUN: opt < %s -inline-threshold=0 -passes=always-inline -S | FileCheck %s
; RUN: opt < %s -passes=always-inline -S | FileCheck %s
declare i8* @foo(i8*) nounwind willreturn
-; RUN: opt < %s -inline -inline-threshold=20 -S | FileCheck %s
+; RUN: opt < %s -passes=inline -inline-threshold=20 -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -inline-threshold=20 -S | FileCheck %s
define i32 @callee(i32 %a) {
-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -passes=inline -S | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
-; RUN: opt < %s -inline -inline-threshold=35 -S | FileCheck %s
+; RUN: opt < %s -passes=inline -inline-threshold=35 -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -inline-threshold=35 -S | FileCheck %s
define i32 @bar(<4 x i32> %v, i32 %i) #0 {
; The code in this test is very similar to vector-bonus.ll except for
; the fact that the call to bar is cold thereby preventing the application of
; the vector bonus.
-; RUN: opt < %s -inline -inline-threshold=35 -S | FileCheck %s
+; RUN: opt < %s -passes=inline -inline-threshold=35 -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -inline-threshold=35 -S | FileCheck %s
define i32 @bar(<4 x i32> %v, i32 %i) #0 {
-; RUN: opt -inline -S %s | FileCheck %s
+; RUN: opt -passes=inline -S %s | FileCheck %s
; RUN: opt -passes='cgscc(inline)' -S %s | FileCheck %s
define void @f() {