diff options
Diffstat (limited to 'test/Other')
26 files changed, 1375 insertions, 113 deletions
diff --git a/test/Other/Inputs/invariant.group.barrier.ll b/test/Other/Inputs/invariant.group.barrier.ll deleted file mode 100644 index 565b0989ecb7..000000000000 --- a/test/Other/Inputs/invariant.group.barrier.ll +++ /dev/null @@ -1,15 +0,0 @@ -; RUN: opt -S -gvn < %s | FileCheck %s -; RUN: opt -S -newgvn < %s | FileCheck %s -; RUN: opt -S -O3 < %s | FileCheck %s - -; This test check if optimizer is not proving equality based on mustalias -; CHECK-LABEL: define void @dontProveEquality(i8* %a) -define void @dontProveEquality(i8* %a) { - %b = call i8* @llvm.invariant.group.barrier(i8* %a) - %r = i1 icmp eq i8* %b, i8* %a -;CHECK: call void @use(%r) - call void @use(%r) -} - -declare void @use(i1) -declare i8* @llvm.invariant.group.barrier(i8 *) diff --git a/test/Other/can-execute.txt b/test/Other/can-execute.txt index 9160e463744a..ae97d7ba8163 100644 --- a/test/Other/can-execute.txt +++ b/test/Other/can-execute.txt @@ -1,4 +1,5 @@ REQUIRES: can-execute +REQUIRES: shell This tests that we abstract two peculiarities of unix in can_execute: diff --git a/test/Other/cgscc-devirt-iteration.ll b/test/Other/cgscc-devirt-iteration.ll index 111dac5bccaf..204754e8f923 100644 --- a/test/Other/cgscc-devirt-iteration.ll +++ b/test/Other/cgscc-devirt-iteration.ll @@ -13,11 +13,11 @@ declare void @readnone() readnone ; CHECK: Function Attrs: readnone -; CHECK: declare void @readnone() +; CHECK-NEXT: declare void @readnone() declare void @unknown() ; CHECK-NOT: Function Attrs -; CHECK: declare void @unknown() +; CHECK-LABEL: declare void @unknown(){{ *$}} ; The @test1 function checks that when we refine an indirect call to a direct ; call we revisit the SCC passes to reflect the more precise information. This @@ -26,7 +26,7 @@ declare void @unknown() define void @test1() { ; BEFORE-NOT: Function Attrs ; AFTER: Function Attrs: readnone -; CHECK: define void @test1() +; CHECK-LABEL: define void @test1() entry: %fptr = alloca void ()* store void ()* @readnone, void ()** %fptr @@ -49,7 +49,7 @@ entry: declare void @readnone_with_arg(void ()**) readnone ; CHECK: Function Attrs: readnone -; CHECK: declare void @readnone_with_arg(void ()**) +; CHECK-LABEL: declare void @readnone_with_arg(void ()**) define void @test2_a(void ()** %ignore) { ; BEFORE-NOT: Function Attrs @@ -76,7 +76,7 @@ define void @test2_b() { ; BEFORE-NOT: Function Attrs ; AFTER1: Function Attrs: readonly ; AFTER2: Function Attrs: readnone -; CHECK: define void @test2_b() +; CHECK-LABEL: define void @test2_b() entry: %f2ptr = alloca void ()* store void ()* @readnone, void ()** %f2ptr @@ -96,17 +96,20 @@ entry: } declare i8* @memcpy(i8*, i8*, i64) -; CHECK: declare i8* @memcpy( +; CHECK-LABEL: declare i8* @memcpy( ; The @test3 function checks that when we refine an indirect call to an ; intrinsic we still revisit the SCC pass. This also covers cases where the ; value handle itself doesn't persist due to the nature of how instcombine ; creates the memcpy intrinsic call, and we rely on the count of indirect calls ; decreasing and the count of direct calls increasing. -define void @test3(i8* %src, i8* %dest, i64 %size) { -; CHECK-NOT: Function Attrs -; BEFORE: define void @test3(i8* %src, i8* %dest, i64 %size) -; AFTER: define void @test3(i8* nocapture readonly %src, i8* nocapture %dest, i64 %size) +; Adding 'noinline' attribute to force attributes for improved matching. +define void @test3(i8* %src, i8* %dest, i64 %size) noinline { +; CHECK: Function Attrs +; CHECK-NOT: read +; CHECK-SAME: noinline +; BEFORE-LABEL: define void @test3(i8* %src, i8* %dest, i64 %size) +; AFTER-LABEL: define void @test3(i8* nocapture readonly %src, i8* nocapture %dest, i64 %size) %fptr = alloca i8* (i8*, i8*, i64)* store i8* (i8*, i8*, i64)* @memcpy, i8* (i8*, i8*, i64)** %fptr %f = load i8* (i8*, i8*, i64)*, i8* (i8*, i8*, i64)** %fptr @@ -118,7 +121,7 @@ define void @test3(i8* %src, i8* %dest, i64 %size) { ; A boring function that just keeps our declarations around. define void @keep(i8** %sink) { ; CHECK-NOT: Function Attrs -; CHECK: define void @keep( +; CHECK-LABEL: define void @keep( entry: store volatile i8* bitcast (void ()* @readnone to i8*), i8** %sink store volatile i8* bitcast (void ()* @unknown to i8*), i8** %sink diff --git a/test/Other/cgscc-libcall-update.ll b/test/Other/cgscc-libcall-update.ll index 72369bea83cf..1bf482af7954 100644 --- a/test/Other/cgscc-libcall-update.ll +++ b/test/Other/cgscc-libcall-update.ll @@ -13,7 +13,7 @@ define i8* @wibble(i8* %arg1, i8* %arg2) { bb: %tmp = alloca [1024 x i8], align 16 %tmp2 = getelementptr inbounds [1024 x i8], [1024 x i8]* %tmp, i64 0, i64 0 - call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp2, i8* %arg1, i64 1024, i32 0, i1 false) + call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp2, i8* %arg1, i64 1024, i1 false) ; CHECK: call void @llvm.memcpy %tmp3 = call i64 @llvm.objectsize.i64.p0i8(i8* %tmp2, i1 false, i1 true) %tmp4 = call i8* @__strncpy_chk(i8* %arg2, i8* %tmp2, i64 1023, i64 %tmp3) @@ -37,7 +37,7 @@ declare i64 @llvm.objectsize.i64.p0i8(i8*, i1, i1) declare i8* @__strncpy_chk(i8*, i8*, i64, i64) -declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1) +declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) ; Check that even when we completely remove a libcall we don't get the call ; graph wrong once we handle libcalls in the call graph specially to address diff --git a/test/Other/debugcounter-earlycse.ll b/test/Other/debugcounter-earlycse.ll new file mode 100644 index 000000000000..3d0a9cdbd3a2 --- /dev/null +++ b/test/Other/debugcounter-earlycse.ll @@ -0,0 +1,27 @@ +; REQUIRES: asserts +; RUN: opt -S -debug-counter=early-cse-skip=1,early-cse-count=1 -early-cse < %s 2>&1 | FileCheck %s +;; Test that, with debug counters on, we only optimize the second CSE opportunity. +define i32 @test(i32 %a, i32 %b) { +; CHECK-LABEL: @test( +; CHECK-NEXT: bb: +; CHECK-NEXT: %add1 = add i32 %a, %b +; CHECK-NEXT: %add2 = add i32 %a, %b +; CHECK-NEXT: %add4 = add i32 %a, %b +; CHECK-NEXT: %ret1 = add i32 %add1, %add2 +; CHECK-NEXT: %ret2 = add i32 %add1, %add4 +; CHECK-NEXT: %ret = add i32 %ret1, %ret2 +; CHECK-NEXT: ret i32 %ret +; +bb: + %add1 = add i32 %a, %b + %add2 = add i32 %a, %b + %add3 = add i32 %a, %b + %add4 = add i32 %a, %b + %ret1 = add i32 %add1, %add2 + %ret2 = add i32 %add3, %add4 + %ret = add i32 %ret1, %ret2 + ret i32 %ret +} + + + diff --git a/test/Other/debugcounter-predicateinfo.ll b/test/Other/debugcounter-predicateinfo.ll index eb2ec09802fe..6c82148f9e39 100644 --- a/test/Other/debugcounter-predicateinfo.ll +++ b/test/Other/debugcounter-predicateinfo.ll @@ -8,10 +8,10 @@ define fastcc void @barney() { ; CHECK-NEXT: br label [[BB22:%.*]] ; CHECK: bb22: ; CHECK-NEXT: [[TMP23:%.*]] = icmp eq i32 undef, 2 -; CHECK: [[TMP23_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP23]]) +; CHECK: [[TMP23_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP23]]) ; CHECK-NEXT: br i1 [[TMP23]], label [[BB29:%.*]], label [[BB35:%.*]] ; CHECK: bb29: -; CHECK: [[TMP23_0_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP23_0]]) +; CHECK: [[TMP23_0_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP23_0]]) ; CHECK-NEXT: br i1 [[TMP23]], label [[BB33:%.*]], label [[BB35]] ; CHECK: bb33: ; CHECK-NEXT: br i1 [[TMP23_0_1]], label [[BB35]], label [[BB35]] diff --git a/test/Other/invariant.group.barrier.ll b/test/Other/invariant.group.barrier.ll deleted file mode 100644 index f10e4a188b16..000000000000 --- a/test/Other/invariant.group.barrier.ll +++ /dev/null @@ -1,62 +0,0 @@ -; RUN: opt -S -early-cse < %s | FileCheck %s -; RUN: opt -S -gvn < %s | FileCheck %s -; RUN: opt -S -newgvn < %s | FileCheck %s -; RUN: opt -S -O3 < %s | FileCheck %s - -; These tests checks if passes with CSE functionality can do CSE on -; invariant.group.barrier, that is prohibited if there is a memory clobber -; between barriers call. - -; CHECK-LABEL: define i8 @optimizable() -define i8 @optimizable() { -entry: - %ptr = alloca i8 - store i8 42, i8* %ptr, !invariant.group !0 -; CHECK: call i8* @llvm.invariant.group.barrier.p0i8 - %ptr2 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr) -; CHECK-NOT: call i8* @llvm.invariant.group.barrier.p0i8 - %ptr3 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr) -; CHECK: call void @clobber(i8* {{.*}}%ptr) - call void @clobber(i8* %ptr) - -; CHECK: call void @use(i8* {{.*}}%ptr2) - call void @use(i8* %ptr2) -; CHECK: call void @use(i8* {{.*}}%ptr2) - call void @use(i8* %ptr3) -; CHECK: load i8, i8* %ptr2, {{.*}}!invariant.group - %v = load i8, i8* %ptr3, !invariant.group !0 - - ret i8 %v -} - -; CHECK-LABEL: define i8 @unoptimizable() -define i8 @unoptimizable() { -entry: - %ptr = alloca i8 - store i8 42, i8* %ptr, !invariant.group !0 -; CHECK: call i8* @llvm.invariant.group.barrier.p0i8 - %ptr2 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr) - call void @clobber(i8* %ptr) -; CHECK: call i8* @llvm.invariant.group.barrier.p0i8 - %ptr3 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr) -; CHECK: call void @clobber(i8* {{.*}}%ptr) - call void @clobber(i8* %ptr) -; CHECK: call void @use(i8* {{.*}}%ptr2) - call void @use(i8* %ptr2) -; CHECK: call void @use(i8* {{.*}}%ptr3) - call void @use(i8* %ptr3) -; CHECK: load i8, i8* %ptr3, {{.*}}!invariant.group - %v = load i8, i8* %ptr3, !invariant.group !0 - - ret i8 %v -} - -declare void @use(i8* readonly) - -declare void @clobber(i8*) -; CHECK: Function Attrs: argmemonly nounwind readonly -; CHECK-NEXT: declare i8* @llvm.invariant.group.barrier.p0i8(i8*) -declare i8* @llvm.invariant.group.barrier.p0i8(i8*) - -!0 = !{} - diff --git a/test/Other/invariant.group.ll b/test/Other/invariant.group.ll new file mode 100644 index 000000000000..fdb3a009ff0a --- /dev/null +++ b/test/Other/invariant.group.ll @@ -0,0 +1,104 @@ +; RUN: opt -S -early-cse < %s | FileCheck %s +; RUN: opt -S -gvn < %s | FileCheck %s +; RUN: opt -S -newgvn < %s | FileCheck %s +; RUN: opt -S -O3 < %s | FileCheck %s + +; These tests checks if passes with CSE functionality can do CSE on +; launder.invariant.group, that is prohibited if there is a memory clobber +; between barriers call. + +; CHECK-LABEL: define i8 @optimizable() +define i8 @optimizable() { +entry: + %ptr = alloca i8 + store i8 42, i8* %ptr, !invariant.group !0 +; CHECK: call i8* @llvm.launder.invariant.group.p0i8 + %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) +; FIXME: This one could be CSE +; CHECK: call i8* @llvm.launder.invariant.group + %ptr3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) +; CHECK: call void @clobber(i8* {{.*}}%ptr) + call void @clobber(i8* %ptr) + +; CHECK: call void @use(i8* {{.*}}%ptr2) + call void @use(i8* %ptr2) +; CHECK: call void @use(i8* {{.*}}%ptr3) + call void @use(i8* %ptr3) +; CHECK: load i8, i8* %ptr3, {{.*}}!invariant.group + %v = load i8, i8* %ptr3, !invariant.group !0 + + ret i8 %v +} + +; CHECK-LABEL: define i8 @unoptimizable() +define i8 @unoptimizable() { +entry: + %ptr = alloca i8 + store i8 42, i8* %ptr, !invariant.group !0 +; CHECK: call i8* @llvm.launder.invariant.group.p0i8 + %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) + call void @clobber(i8* %ptr) +; CHECK: call i8* @llvm.launder.invariant.group.p0i8 + %ptr3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) +; CHECK: call void @clobber(i8* {{.*}}%ptr) + call void @clobber(i8* %ptr) +; CHECK: call void @use(i8* {{.*}}%ptr2) + call void @use(i8* %ptr2) +; CHECK: call void @use(i8* {{.*}}%ptr3) + call void @use(i8* %ptr3) +; CHECK: load i8, i8* %ptr3, {{.*}}!invariant.group + %v = load i8, i8* %ptr3, !invariant.group !0 + + ret i8 %v +} + +; CHECK-LABEL: define i8 @unoptimizable2() +define i8 @unoptimizable2() { + %ptr = alloca i8 + store i8 42, i8* %ptr, !invariant.group !0 +; CHECK: call i8* @llvm.launder.invariant.group + %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) + store i8 43, i8* %ptr +; CHECK: call i8* @llvm.launder.invariant.group + %ptr3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) +; CHECK: call void @clobber(i8* {{.*}}%ptr) + call void @clobber(i8* %ptr) +; CHECK: call void @use(i8* {{.*}}%ptr2) + call void @use(i8* %ptr2) +; CHECK: call void @use(i8* {{.*}}%ptr3) + call void @use(i8* %ptr3) +; CHECK: load i8, i8* %ptr3, {{.*}}!invariant.group + %v = load i8, i8* %ptr3, !invariant.group !0 + ret i8 %v +} + +; This test check if optimizer is not proving equality based on mustalias +; CHECK-LABEL: define void @dontProveEquality(i8* %a) +define void @dontProveEquality(i8* %a) { + %b = call i8* @llvm.launder.invariant.group.p0i8(i8* %a) + %r = icmp eq i8* %b, %a +; CHECK: call void @useBool(i1 %r) + call void @useBool(i1 %r) + + %b2 = call i8* @llvm.strip.invariant.group.p0i8(i8* %a) + %r2 = icmp eq i8* %b2, %a +; CHECK: call void @useBool(i1 %r2) + call void @useBool(i1 %r2) + + ret void +} + +declare void @use(i8* readonly) +declare void @useBool(i1) + +declare void @clobber(i8*) +; CHECK: Function Attrs: inaccessiblememonly nounwind speculatable{{$}} +; CHECK-NEXT: declare i8* @llvm.launder.invariant.group.p0i8(i8*) +declare i8* @llvm.launder.invariant.group.p0i8(i8*) + +; CHECK: Function Attrs: nounwind readnone speculatable{{$}} +; CHECK-NEXT: declare i8* @llvm.strip.invariant.group.p0i8(i8*) +declare i8* @llvm.strip.invariant.group.p0i8(i8*) + + +!0 = !{}
\ No newline at end of file diff --git a/test/Other/lint.ll b/test/Other/lint.ll index 8a93fa117a03..ab5df0ec2281 100644 --- a/test/Other/lint.ll +++ b/test/Other/lint.ll @@ -3,7 +3,7 @@ target datalayout = "e-p:64:64:64" declare fastcc void @bar() declare void @llvm.stackrestore(i8*) -declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind +declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind declare void @has_sret(i8* sret %p) declare void @has_noaliases(i32* noalias %p, i32* %q) declare void @one_arg(i32) @@ -78,7 +78,7 @@ define i32 @foo() noreturn { call void (float) bitcast (void (i32)* @one_arg to void (float)*)(float 0.0) ; CHECK: Write to read-only memory - call void @llvm.memcpy.p0i8.p0i8.i64(i8* bitcast (i32* @CG to i8*), i8* bitcast (i32* @CG to i8*), i64 1, i32 1, i1 0) + call void @llvm.memcpy.p0i8.p0i8.i64(i8* bitcast (i32* @CG to i8*), i8* bitcast (i32* @CG to i8*), i64 1, i1 0) ; CHECK: Undefined behavior: Buffer overflow %wider = bitcast i8* %buf to i16* diff --git a/test/Other/loop-pm-invalidation.ll b/test/Other/loop-pm-invalidation.ll index 9a4f74e1d005..a6f5302462d1 100644 --- a/test/Other/loop-pm-invalidation.ll +++ b/test/Other/loop-pm-invalidation.ll @@ -19,23 +19,39 @@ define void @no_loops() { ; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on no_loops +; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis +; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass +; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}LoopAnalysis ; CHECK-LOOP-INV-NEXT: Invalidating all non-preserved analyses ; CHECK-LOOP-INV-NEXT: Invalidating analysis: LoopAnalysis ; CHECK-LOOP-INV-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on no_loops +; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis +; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass +; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run. ; ; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on no_loops +; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis +; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Invalidating all non-preserved analyses ; CHECK-SCEV-INV-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on no_loops +; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass +; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run. entry: @@ -44,9 +60,13 @@ entry: define void @one_loop(i1* %ptr) { ; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on one_loop +; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis +; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass +; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Running analysis: AAManager ; CHECK-LOOP-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis @@ -62,7 +82,11 @@ define void @one_loop(i1* %ptr) { ; CHECK-LOOP-INV-NEXT: Invalidating analysis: ScalarEvolutionAnalysis ; CHECK-LOOP-INV-NEXT: Invalidating analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-LOOP-INV-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on one_loop +; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis +; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass +; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run. @@ -71,9 +95,13 @@ define void @one_loop(i1* %ptr) { ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run. ; ; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on one_loop +; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis +; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Running analysis: AAManager ; CHECK-SCEV-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis @@ -88,6 +116,10 @@ define void @one_loop(i1* %ptr) { ; CHECK-SCEV-INV-NEXT: Invalidating analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Invalidating analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on one_loop +; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass +; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run. @@ -108,9 +140,13 @@ exit: define void @nested_loops(i1* %ptr) { ; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on nested_loops +; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis +; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass +; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Running analysis: AAManager ; CHECK-LOOP-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis @@ -130,7 +166,11 @@ define void @nested_loops(i1* %ptr) { ; CHECK-LOOP-INV-NEXT: Invalidating analysis: ScalarEvolutionAnalysis ; CHECK-LOOP-INV-NEXT: Invalidating analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-LOOP-INV-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on nested_loops +; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis +; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass +; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run. @@ -142,9 +182,13 @@ define void @nested_loops(i1* %ptr) { ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run. ; ; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on nested_loops +; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis +; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Running analysis: AAManager ; CHECK-SCEV-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis @@ -163,6 +207,10 @@ define void @nested_loops(i1* %ptr) { ; CHECK-SCEV-INV-NEXT: Invalidating analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Invalidating analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on nested_loops +; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass +; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run. @@ -193,9 +241,13 @@ exit: define void @dead_loop() { ; CHECK-LOOP-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop +; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: AssumptionAnalysis +; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass +; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Running analysis: AAManager ; CHECK-LOOP-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis @@ -211,7 +263,11 @@ define void @dead_loop() { ; CHECK-LOOP-INV-NEXT: Invalidating analysis: ScalarEvolutionAnalysis ; CHECK-LOOP-INV-NEXT: Invalidating analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-LOOP-INV-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop +; CHECK-LOOP-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-LOOP-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-LOOP-INV-NEXT: Running analysis: LoopAnalysis +; CHECK-LOOP-INV-NEXT: Running pass: LCSSAPass +; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-LOOP-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-LOOP-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-LOOP-INV-NEXT: Starting {{.*}}Loop pass manager run. @@ -220,9 +276,13 @@ define void @dead_loop() { ; CHECK-LOOP-INV-NEXT: Finished {{.*}}Function pass manager run. ; ; CHECK-SCEV-INV-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop +; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass ; CHECK-SCEV-INV-NEXT: Running analysis: LoopAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: AssumptionAnalysis +; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Running analysis: AAManager ; CHECK-SCEV-INV-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis @@ -237,6 +297,10 @@ define void @dead_loop() { ; CHECK-SCEV-INV-NEXT: Invalidating analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Invalidating analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop +; CHECK-SCEV-INV-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-NEXT: Running pass: LoopSimplifyPass +; CHECK-SCEV-INV-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-NEXT: Starting {{.*}}Loop pass manager run. @@ -245,9 +309,13 @@ define void @dead_loop() { ; CHECK-SCEV-INV-NEXT: Finished {{.*}}Function pass manager run. ; ; CHECK-SCEV-INV-AFTER-DELETE-LABEL: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop +; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: LoopSimplifyPass ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: LoopAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: AssumptionAnalysis +; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: AAManager ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running analysis: ScalarEvolutionAnalysis @@ -264,6 +332,10 @@ define void @dead_loop() { ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Invalidating analysis: ScalarEvolutionAnalysis ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Invalidating analysis: InnerAnalysisManagerProxy<{{.*}}Loop ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}> on dead_loop +; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Starting {{.*}}Function pass manager run +; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: LoopSimplifyPass +; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Running pass: LCSSAPass +; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Finished {{.*}}Function pass manager run ; CHECK-SCEV-INV-AFTER-DELETE-NEXT: Finished {{.*}}Function pass manager run. entry: diff --git a/test/Other/new-pass-manager.ll b/test/Other/new-pass-manager.ll index 0826ecd3152b..320fd04ed9d4 100644 --- a/test/Other/new-pass-manager.ll +++ b/test/Other/new-pass-manager.ll @@ -450,10 +450,14 @@ ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}> ; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Function pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: FunctionToLoopPassAdaptor +; CHECK-REPEAT-LOOP-PASS-NEXT: Starting llvm::Function pass manager run +; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: LoopSimplify ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: LoopAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: AssumptionAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Invalidating all non-preserved analyses +; CHECK-REPEAT-LOOP-PASS-NEXT: Running pass: LCSSAPass +; CHECK-REPEAT-LOOP-PASS-NEXT: Finished llvm::Function pass manager run ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: AAManager ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-REPEAT-LOOP-PASS-NEXT: Running analysis: ScalarEvolutionAnalysis diff --git a/test/Other/new-pm-defaults.ll b/test/Other/new-pm-defaults.ll index 1964a8c2f7cb..fcbfc354b920 100644 --- a/test/Other/new-pm-defaults.ll +++ b/test/Other/new-pm-defaults.ll @@ -56,11 +56,22 @@ ; RUN: -passes='default<O3>' -S %s 2>&1 \ ; RUN: | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \ ; RUN: --check-prefix=CHECK-EP-VECTORIZER-START +; RUN: opt -disable-verify -debug-pass-manager \ +; RUN: -passes-ep-pipeline-start='no-op-module' \ +; RUN: -passes='default<O3>' -S %s 2>&1 \ +; RUN: | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \ +; RUN: --check-prefix=CHECK-EP-PIPELINE-START +; RUN: opt -disable-verify -debug-pass-manager \ +; RUN: -passes-ep-pipeline-start='no-op-module' \ +; RUN: -passes='lto-pre-link<O3>' -S %s 2>&1 \ +; RUN: | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O3 \ +; RUN: --check-prefix=CHECK-EP-PIPELINE-START ; CHECK-O: Starting llvm::Module pass manager run. ; CHECK-O-NEXT: Running pass: PassManager<{{.*}}Module{{.*}}> ; CHECK-O-NEXT: Starting llvm::Module pass manager run. ; CHECK-O-NEXT: Running pass: ForceFunctionAttrsPass +; CHECK-EP-PIPELINE-START-NEXT: Running pass: NoOpModulePass ; CHECK-O-NEXT: Running pass: PassManager<{{.*}}Module{{.*}}> ; CHECK-O-NEXT: Starting llvm::Module pass manager run. ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass @@ -102,8 +113,8 @@ ; CHECK-O-NEXT: Starting CGSCC pass manager run. ; CHECK-O-NEXT: Running pass: InlinerPass ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy<{{.*}}LazyCallGraph{{.*}}> -; CHECK-O-NEXT: Running pass: PostOrderFunctionAttrsPass ; CHECK-O-NEXT: Running analysis: FunctionAnalysisManagerCGSCCProxy +; CHECK-O-NEXT: Running pass: PostOrderFunctionAttrsPass ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass ; CHECK-O-NEXT: Running pass: CGSCCToFunctionPassAdaptor<{{.*}}PassManager{{.*}}> ; CHECK-O-NEXT: Starting llvm::Function pass manager run. @@ -115,6 +126,7 @@ ; CHECK-O-NEXT: Running analysis: LazyValueAnalysis ; CHECK-O-NEXT: Running pass: CorrelatedValuePropagationPass ; CHECK-O-NEXT: Running pass: SimplifyCFGPass +; CHECK-O3-NEXT: AggressiveInstCombinePass ; CHECK-O-NEXT: Running pass: InstCombinePass ; CHECK-O1-NEXT: Running pass: LibCallsShrinkWrapPass ; CHECK-O2-NEXT: Running pass: LibCallsShrinkWrapPass @@ -125,10 +137,16 @@ ; CHECK-O-NEXT: Running pass: ReassociatePass ; CHECK-O-NEXT: Running pass: RequireAnalysisPass<{{.*}}OptimizationRemarkEmitterAnalysis ; CHECK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LoopStandardAnalysisResults{{.*}}> +; CHECK-O-NEXT: Starting llvm::Function pass manager run. +; CHECK-O-NEXT: Running pass: LoopSimplifyPass ; CHECK-O-NEXT: Running analysis: LoopAnalysis +; CHECK-O-NEXT: Running pass: LCSSAPass +; CHECK-O-NEXT: Finished llvm::Function pass manager run. ; CHECK-O-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy ; CHECK-O-NEXT: Starting Loop pass manager run. +; CHECK-O-NEXT: Running pass: LoopInstSimplifyPass +; CHECK-O-NEXT: Running pass: LoopSimplifyCFGPass ; CHECK-O-NEXT: Running pass: LoopRotatePass ; CHECK-O-NEXT: Running pass: LICM ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy @@ -137,6 +155,10 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running pass: InstCombinePass ; CHECK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LoopStandardAnalysisResults{{.*}}> +; CHECK-O-NEXT: Starting llvm::Function pass manager run. +; CHECK-O-NEXT: Running pass: LoopSimplifyPass +; CHECK-O-NEXT: Running pass: LCSSAPass +; CHECK-O-NEXT: Finished llvm::Function pass manager run. ; CHECK-O-NEXT: Starting Loop pass manager run. ; CHECK-O-NEXT: Running pass: IndVarSimplifyPass ; CHECK-O-NEXT: Running pass: LoopIdiomRecognizePass @@ -168,6 +190,10 @@ ; CHECK-O-NEXT: Running pass: CorrelatedValuePropagationPass ; CHECK-O-NEXT: Running pass: DSEPass ; CHECK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LICMPass{{.*}}> +; CHECK-O-NEXT: Starting llvm::Function pass manager run. +; CHECK-O-NEXT: Running pass: LoopSimplifyPass +; CHECK-O-NEXT: Running pass: LCSSAPass +; CHECK-O-NEXT: Finished llvm::Function pass manager run. ; CHECK-EP-SCALAR-LATE-NEXT: Running pass: NoOpFunctionPass ; CHECK-O-NEXT: Running pass: ADCEPass ; CHECK-O-NEXT: Running analysis: PostDominatorTreeAnalysis @@ -190,6 +216,10 @@ ; CHECK-O-NEXT: Running pass: Float2IntPass ; CHECK-EP-VECTORIZER-START-NEXT: Running pass: NoOpFunctionPass ; CHECK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LoopRotatePass +; CHECK-O-NEXT: Starting llvm::Function pass manager run. +; CHECK-O-NEXT: Running pass: LoopSimplifyPass +; CHECK-O-NEXT: Running pass: LCSSAPass +; CHECK-O-NEXT: Finished llvm::Function pass manager run. ; CHECK-O-NEXT: Running pass: LoopDistributePass ; CHECK-O-NEXT: Running pass: LoopVectorizePass ; CHECK-O-NEXT: Running analysis: BlockFrequencyAnalysis @@ -205,13 +235,18 @@ ; CHECK-O-NEXT: Running pass: InstCombinePass ; CHECK-O-NEXT: Running pass: RequireAnalysisPass<{{.*}}OptimizationRemarkEmitterAnalysis ; CHECK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LICMPass +; CHECK-O-NEXT: Starting llvm::Function pass manager run. +; CHECK-O-NEXT: Running pass: LoopSimplifyPass +; CHECK-O-NEXT: Running pass: LCSSAPass +; CHECK-O-NEXT: Finished llvm::Function pass manager run. ; CHECK-O-NEXT: Running pass: AlignmentFromAssumptionsPass ; CHECK-O-NEXT: Running pass: LoopSinkPass -; CHECK-O-NEXT: Running pass: InstSimplifierPass +; CHECK-O-NEXT: Running pass: InstSimplifyPass ; CHECK-O-NEXT: Running pass: DivRemPairsPass ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running pass: SpeculateAroundPHIsPass ; CHECK-O-NEXT: Finished llvm::Function pass manager run. +; CHECK-O-NEXT: Running pass: CGProfilePass ; CHECK-O-NEXT: Running pass: GlobalDCEPass ; CHECK-O-NEXT: Running pass: ConstantMergePass ; CHECK-O-NEXT: Finished llvm::Module pass manager run. diff --git a/test/Other/new-pm-lto-defaults.ll b/test/Other/new-pm-lto-defaults.ll index 878198d1447b..5bb4d9a4eac8 100644 --- a/test/Other/new-pm-lto-defaults.ll +++ b/test/Other/new-pm-lto-defaults.ll @@ -10,7 +10,8 @@ ; RUN: | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O2 ; RUN: opt -disable-verify -debug-pass-manager \ ; RUN: -passes='lto<O3>' -S %s 2>&1 \ -; RUN: | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O2 +; RUN: | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O2 \ +; RUN: --check-prefix=CHECK-O3 ; RUN: opt -disable-verify -debug-pass-manager \ ; RUN: -passes='lto<Os>' -S %s 2>&1 \ ; RUN: | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O2 @@ -20,7 +21,7 @@ ; RUN: opt -disable-verify -debug-pass-manager \ ; RUN: -passes='lto<O3>' -S %s -passes-ep-peephole='no-op-function' 2>&1 \ ; RUN: | FileCheck %s --check-prefix=CHECK-O --check-prefix=CHECK-O2 \ -; RUN: --check-prefix=CHECK-EP-Peephole +; RUN: --check-prefix=CHECK-O3 --check-prefix=CHECK-EP-Peephole ; CHECK-O: Starting llvm::Module pass manager run. ; CHECK-O-NEXT: Running pass: PassManager<{{.*}}Module @@ -34,6 +35,7 @@ ; CHECK-O2-NEXT: Starting llvm::Function pass manager run. ; CHECK-O2-NEXT: Running pass: CallSiteSplittingPass on foo ; CHECK-O2-NEXT: Running analysis: TargetLibraryAnalysis on foo +; CHECK-O2-NEXT: Running analysis: TargetIRAnalysis on foo ; CHECK-O2-NEXT: Finished llvm::Function pass manager run. ; CHECK-O2-NEXT: PGOIndirectCallPromotion ; CHECK-O2-NEXT: Running analysis: ProfileSummaryAnalysis @@ -52,6 +54,7 @@ ; CHECK-O-NEXT: Running analysis: CallGraphAnalysis ; CHECK-O-NEXT: Running pass: GlobalSplitPass ; CHECK-O-NEXT: Running pass: WholeProgramDevirtPass +; CHECK-O1-NEXT: Running pass: LowerTypeTestsPass ; CHECK-O2-NEXT: Running pass: GlobalOptPass ; CHECK-O2-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PromotePass> ; CHECK-O2-NEXT: Running analysis: DominatorTreeAnalysis @@ -60,6 +63,7 @@ ; CHECK-O2-NEXT: Running pass: DeadArgumentEliminationPass ; CHECK-O2-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}> ; CHECK-O2-NEXT: Starting llvm::Function pass manager run. +; CHECK-O3-NEXT: Running pass: AggressiveInstCombinePass ; CHECK-O2-NEXT: Running pass: InstCombinePass ; CHECK-EP-Peephole-NEXT: Running pass: NoOpFunctionPass ; CHECK-O2-NEXT: Finished llvm::Function pass manager run. @@ -77,9 +81,9 @@ ; CHECK-O2-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor<{{.*}}PostOrderFunctionAttrsPass> ; CHECK-O2-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}> ; CHECK-O2-NEXT: Running analysis: MemoryDependenceAnalysis -; CHECK-O2-NEXT: Running analysis: TargetIRAnalysis ; CHECK-O2-NEXT: Running analysis: DemandedBitsAnalysis ; CHECK-O2-NEXT: Running pass: CrossDSOCFIPass +; CHECK-O2-NEXT: Running pass: LowerTypeTestsPass ; CHECK-O2-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}SimplifyCFGPass> ; CHECK-O2-NEXT: Running pass: EliminateAvailableExternallyPass ; CHECK-O2-NEXT: Running pass: GlobalDCEPass diff --git a/test/Other/new-pm-thinlto-defaults.ll b/test/Other/new-pm-thinlto-defaults.ll index 12fd0d7ac476..3ddae0224232 100644 --- a/test/Other/new-pm-thinlto-defaults.ll +++ b/test/Other/new-pm-thinlto-defaults.ll @@ -15,8 +15,8 @@ ; RUN: -passes='thinlto-pre-link<O2>,name-anon-globals' -S %s 2>&1 \ ; RUN: | FileCheck %s --check-prefixes=CHECK-O,CHECK-O2,CHECK-PRELINK-O,CHECK-PRELINK-O-NODIS,CHECK-PRELINK-O2 ; RUN: opt -disable-verify -debug-pass-manager \ -; RUN: -passes='thinlto-pre-link<O3>,name-anon-globals' -S %s 2>&1 \ -; RUN: | FileCheck %s --check-prefixes=CHECK-O,CHECK-O3,CHECK-PRELINK-O,CHECK-PRELINK-O-NODIS,CHECK-PRELINK-O3 +; RUN: -passes='thinlto-pre-link<O3>,name-anon-globals' -S -passes-ep-pipeline-start='no-op-module' %s 2>&1 \ +; RUN: | FileCheck %s --check-prefixes=CHECK-O,CHECK-O3,CHECK-PRELINK-O,CHECK-PRELINK-O-NODIS,CHECK-PRELINK-O3,CHECK-EP-PIPELINE-START ; RUN: opt -disable-verify -debug-pass-manager \ ; RUN: -passes='thinlto-pre-link<Os>,name-anon-globals' -S %s 2>&1 \ ; RUN: | FileCheck %s --check-prefixes=CHECK-O,CHECK-Os,CHECK-PRELINK-O,CHECK-PRELINK-O-NODIS,CHECK-PRELINK-Os @@ -34,7 +34,7 @@ ; RUN: opt -disable-verify -debug-pass-manager \ ; RUN: -passes='thinlto<O2>' -S %s 2>&1 \ ; RUN: | FileCheck %s --check-prefixes=CHECK-O,CHECK-O2,CHECK-POSTLINK-O,CHECK-POSTLINK-O2 -; RUN: opt -disable-verify -debug-pass-manager \ +; RUN: opt -disable-verify -debug-pass-manager -passes-ep-pipeline-start='no-op-module' \ ; RUN: -passes='thinlto<O3>' -S %s 2>&1 \ ; RUN: | FileCheck %s --check-prefixes=CHECK-O,CHECK-O3,CHECK-POSTLINK-O,CHECK-POSTLINK-O3 ; RUN: opt -disable-verify -debug-pass-manager \ @@ -51,6 +51,7 @@ ; CHECK-O-NEXT: Running pass: PassManager<{{.*}}Module{{.*}}> ; CHECK-O-NEXT: Starting llvm::Module pass manager run. ; CHECK-O-NEXT: Running pass: ForceFunctionAttrsPass +; CHECK-EP-PIPELINE-START-NEXT: Running pass: NoOpModulePass ; CHECK-DIS-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}AddDiscriminatorsPass{{.*}}> ; CHECK-DIS-NEXT: Running analysis: InnerAnalysisManagerProxy ; CHECK-POSTLINK-O-NEXT: Running pass: PGOIndirectCallPromotion @@ -97,8 +98,8 @@ ; CHECK-O-NEXT: Starting CGSCC pass manager run. ; CHECK-O-NEXT: Running pass: InlinerPass ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy<{{.*}}LazyCallGraph{{.*}}> -; CHECK-O-NEXT: Running pass: PostOrderFunctionAttrsPass ; CHECK-O-NEXT: Running analysis: FunctionAnalysisManagerCGSCCProxy +; CHECK-O-NEXT: Running pass: PostOrderFunctionAttrsPass ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass ; CHECK-O-NEXT: Running pass: CGSCCToFunctionPassAdaptor<{{.*}}PassManager{{.*}}> ; CHECK-O-NEXT: Starting llvm::Function pass manager run. @@ -110,6 +111,7 @@ ; CHECK-O-NEXT: Running analysis: LazyValueAnalysis ; CHECK-O-NEXT: Running pass: CorrelatedValuePropagationPass ; CHECK-O-NEXT: Running pass: SimplifyCFGPass +; CHECK-O3-NEXT: Running pass: AggressiveInstCombinePass ; CHECK-O-NEXT: Running pass: InstCombinePass ; CHECK-O1-NEXT: Running pass: LibCallsShrinkWrapPass ; CHECK-O2-NEXT: Running pass: LibCallsShrinkWrapPass @@ -119,10 +121,16 @@ ; CHECK-O-NEXT: Running pass: ReassociatePass ; CHECK-O-NEXT: Running pass: RequireAnalysisPass<{{.*}}OptimizationRemarkEmitterAnalysis ; CHECK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LoopStandardAnalysisResults{{.*}}> +; CHECK-O-NEXT: Starting llvm::Function pass manager run +; CHECK-O-NEXT: Running pass: LoopSimplifyPass ; CHECK-O-NEXT: Running analysis: LoopAnalysis +; CHECK-O-NEXT: Running pass: LCSSAPass +; CHECK-O-NEXT: Finished llvm::Function pass manager run ; CHECK-O-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy ; CHECK-O-NEXT: Starting Loop pass manager run. +; CHECK-O-NEXT: Running pass: LoopInstSimplifyPass +; CHECK-O-NEXT: Running pass: LoopSimplifyCFGPass ; CHECK-O-NEXT: Running pass: LoopRotatePass ; CHECK-O-NEXT: Running pass: LICM ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy @@ -131,6 +139,10 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running pass: InstCombinePass ; CHECK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LoopStandardAnalysisResults{{.*}}> +; CHECK-O-NEXT: Starting llvm::Function pass manager run +; CHECK-O-NEXT: Running pass: LoopSimplifyPass +; CHECK-O-NEXT: Running pass: LCSSAPass +; CHECK-O-NEXT: Finished llvm::Function pass manager run ; CHECK-O-NEXT: Starting Loop pass manager run. ; CHECK-O-NEXT: Running pass: IndVarSimplifyPass ; CHECK-O-NEXT: Running pass: LoopIdiomRecognizePass @@ -159,6 +171,10 @@ ; CHECK-O-NEXT: Running pass: CorrelatedValuePropagationPass ; CHECK-O-NEXT: Running pass: DSEPass ; CHECK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LICMPass{{.*}}> +; CHECK-O-NEXT: Starting llvm::Function pass manager run +; CHECK-O-NEXT: Running pass: LoopSimplifyPass +; CHECK-O-NEXT: Running pass: LCSSAPass +; CHECK-O-NEXT: Finished llvm::Function pass manager run ; CHECK-O-NEXT: Running pass: ADCEPass ; CHECK-O-NEXT: Running analysis: PostDominatorTreeAnalysis ; CHECK-O-NEXT: Running pass: SimplifyCFGPass @@ -178,6 +194,10 @@ ; CHECK-POSTLINK-O-NEXT: Starting llvm::Function pass manager run. ; CHECK-POSTLINK-O-NEXT: Running pass: Float2IntPass ; CHECK-POSTLINK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LoopRotatePass +; CHECK-POSTLINK-O-NEXT: Starting llvm::Function pass manager run +; CHECK-POSTLINK-O-NEXT: Running pass: LoopSimplifyPass +; CHECK-POSTLINK-O-NEXT: Running pass: LCSSAPass +; CHECK-POSTLINK-O-NEXT: Finished llvm::Function pass manager run ; CHECK-POSTLINK-O-NEXT: Running pass: LoopDistributePass ; CHECK-POSTLINK-O-NEXT: Running pass: LoopVectorizePass ; CHECK-POSTLINK-O-NEXT: Running analysis: BlockFrequencyAnalysis @@ -193,13 +213,18 @@ ; CHECK-POSTLINK-O-NEXT: Running pass: InstCombinePass ; CHECK-POSTLINK-O-NEXT: Running pass: RequireAnalysisPass<{{.*}}OptimizationRemarkEmitterAnalysis ; CHECK-POSTLINK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LICMPass +; CHECK-POSTLINK-O-NEXT: Starting llvm::Function pass manager run +; CHECK-POSTLINK-O-NEXT: Running pass: LoopSimplifyPass +; CHECK-POSTLINK-O-NEXT: Running pass: LCSSAPass +; CHECK-POSTLINK-O-NEXT: Finished llvm::Function pass manager run ; CHECK-POSTLINK-O-NEXT: Running pass: AlignmentFromAssumptionsPass ; CHECK-POSTLINK-O-NEXT: Running pass: LoopSinkPass -; CHECK-POSTLINK-O-NEXT: Running pass: InstSimplifierPass +; CHECK-POSTLINK-O-NEXT: Running pass: InstSimplifyPass ; CHECK-POSTLINK-O-NEXT: Running pass: DivRemPairsPass ; CHECK-POSTLINK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-POSTLINK-O-NEXT: Running pass: SpeculateAroundPHIsPass ; CHECK-POSTLINK-O-NEXT: Finished llvm::Function pass manager run. +; CHECK-POSTLINK-O-NEXT: Running pass: CGProfilePass ; CHECK-POSTLINK-O-NEXT: Running pass: GlobalDCEPass ; CHECK-POSTLINK-O-NEXT: Running pass: ConstantMergePass ; CHECK-POSTLINK-O-NEXT: Finished llvm::Module pass manager run. diff --git a/test/Other/opt-O0-pipeline.ll b/test/Other/opt-O0-pipeline.ll new file mode 100644 index 000000000000..090620652069 --- /dev/null +++ b/test/Other/opt-O0-pipeline.ll @@ -0,0 +1,28 @@ +; RUN: opt -mtriple=x86_64-- -O0 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s + +; REQUIRES: asserts + +; CHECK-LABEL: Pass Arguments: +; CHECK-NEXT: Target Transform Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Module Verifier +; CHECK-NEXT: Instrument function entry/exit with calls to e.g. mcount() (pre inlining) +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: Target Transform Information +; Target Pass Configuration +; CHECK: Assumption Cache Tracker +; CHECK-NEXT: Profile summary info +; CHECK-NEXT: ModulePass Manager +; CHECK-NEXT: Force set function attributes +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Call Graph SCC Pass Manager +; CHECK-NEXT: Inliner for always_inline functions +; A No-Op Barrier Pass +; CHECK: FunctionPass Manager +; CHECK-NEXT: Module Verifier +; CHECK-NEXT: Bitcode Writer + +define void @f() { + ret void +} diff --git a/test/Other/opt-O2-pipeline.ll b/test/Other/opt-O2-pipeline.ll new file mode 100644 index 000000000000..2ebb6ed909f9 --- /dev/null +++ b/test/Other/opt-O2-pipeline.ll @@ -0,0 +1,289 @@ +; RUN: opt -mtriple=x86_64-- -O2 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s + +; REQUIRES: asserts + +; CHECK-LABEL: Pass Arguments: +; CHECK-NEXT: Target Transform Information +; CHECK-NEXT: Type-Based Alias Analysis +; CHECK-NEXT: Scoped NoAlias Alias Analysis +; CHECK-NEXT: Assumption Cache Tracker +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Module Verifier +; CHECK-NEXT: Instrument function entry/exit with calls to e.g. mcount() (pre inlining) +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: SROA +; CHECK-NEXT: Early CSE +; CHECK-NEXT: Lower 'expect' Intrinsics +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: Target Transform Information +; Target Pass Configuration +; CHECK: Type-Based Alias Analysis +; CHECK-NEXT: Scoped NoAlias Alias Analysis +; CHECK-NEXT: Assumption Cache Tracker +; CHECK-NEXT: Profile summary info +; CHECK-NEXT: ModulePass Manager +; CHECK-NEXT: Force set function attributes +; CHECK-NEXT: Infer set function attributes +; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation +; CHECK-NEXT: Called Value Propagation +; CHECK-NEXT: Global Variable Optimizer +; CHECK-NEXT: Unnamed pass: implement Pass::getPassName() +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Promote Memory to Register +; CHECK-NEXT: Dead Argument Elimination +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Globals Alias Analysis +; CHECK-NEXT: Call Graph SCC Pass Manager +; CHECK-NEXT: Remove unused exception handling info +; CHECK-NEXT: Function Integration/Inlining +; CHECK-NEXT: Deduce function attributes +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: SROA +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory SSA +; CHECK-NEXT: Early CSE w/ MemorySSA +; CHECK-NEXT: Speculatively execute instructions if target has divergent branches +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Lazy Value Information Analysis +; CHECK-NEXT: Jump Threading +; CHECK-NEXT: Value Propagation +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Conditionally eliminate dead library calls +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: PGOMemOPSize +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Tail Call Elimination +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Reassociate expressions +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Rotate Loops +; CHECK-NEXT: Loop Invariant Code Motion +; CHECK-NEXT: Unswitch loops +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Induction Variable Simplification +; CHECK-NEXT: Recognize loop idioms +; CHECK-NEXT: Delete dead loops +; CHECK-NEXT: Unroll loops +; CHECK-NEXT: MergedLoadStoreMotion +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory Dependence Analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Global Value Numbering +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory Dependence Analysis +; CHECK-NEXT: MemCpy Optimization +; CHECK-NEXT: Sparse Conditional Constant Propagation +; CHECK-NEXT: Demanded bits analysis +; CHECK-NEXT: Bit-Tracking Dead Code Elimination +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Lazy Value Information Analysis +; CHECK-NEXT: Jump Threading +; CHECK-NEXT: Value Propagation +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory Dependence Analysis +; CHECK-NEXT: Dead Store Elimination +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Loop Invariant Code Motion +; CHECK-NEXT: Post-Dominator Tree Construction +; CHECK-NEXT: Aggressive Dead Code Elimination +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: A No-Op Barrier Pass +; CHECK-NEXT: Eliminate Available Externally Globals +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Deduce function attributes in RPO +; CHECK-NEXT: Global Variable Optimizer +; CHECK-NEXT: Unnamed pass: implement Pass::getPassName() +; CHECK-NEXT: Dead Global Elimination +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Globals Alias Analysis +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Float to int +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Rotate Loops +; CHECK-NEXT: Loop Access Analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Loop Distribution +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Loop Access Analysis +; CHECK-NEXT: Demanded bits analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Loop Vectorization +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Loop Access Analysis +; CHECK-NEXT: Loop Load Elimination +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Demanded bits analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: SLP Vectorizer +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Unroll loops +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Loop Invariant Code Motion +; CHECK-NEXT: Alignment from assumptions +; CHECK-NEXT: Strip Unused Function Prototypes +; CHECK-NEXT: Dead Global Elimination +; CHECK-NEXT: Merge Duplicate Global Constants +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Loop Sink +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Remove redundant instructions +; CHECK-NEXT: Hoist/decompose integer division and remainder +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Module Verifier +; CHECK-NEXT: Bitcode Writer +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis + +define void @f() { + ret void +} diff --git a/test/Other/opt-O3-pipeline.ll b/test/Other/opt-O3-pipeline.ll new file mode 100644 index 000000000000..d9ffc96d4349 --- /dev/null +++ b/test/Other/opt-O3-pipeline.ll @@ -0,0 +1,293 @@ +; RUN: opt -mtriple=x86_64-- -O3 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s + +; REQUIRES: asserts + +; CHECK-LABEL: Pass Arguments: +; CHECK-NEXT: Target Transform Information +; CHECK-NEXT: Type-Based Alias Analysis +; CHECK-NEXT: Scoped NoAlias Alias Analysis +; CHECK-NEXT: Assumption Cache Tracker +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Module Verifier +; CHECK-NEXT: Instrument function entry/exit with calls to e.g. mcount() (pre inlining) +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: SROA +; CHECK-NEXT: Early CSE +; CHECK-NEXT: Lower 'expect' Intrinsics +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: Target Transform Information +; Target Pass Configuration +; CHECK: Type-Based Alias Analysis +; CHECK-NEXT: Scoped NoAlias Alias Analysis +; CHECK-NEXT: Assumption Cache Tracker +; CHECK-NEXT: Profile summary info +; CHECK-NEXT: ModulePass Manager +; CHECK-NEXT: Force set function attributes +; CHECK-NEXT: Infer set function attributes +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Call-site splitting +; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation +; CHECK-NEXT: Called Value Propagation +; CHECK-NEXT: Global Variable Optimizer +; CHECK-NEXT: Unnamed pass: implement Pass::getPassName() +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Promote Memory to Register +; CHECK-NEXT: Dead Argument Elimination +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Globals Alias Analysis +; CHECK-NEXT: Call Graph SCC Pass Manager +; CHECK-NEXT: Remove unused exception handling info +; CHECK-NEXT: Function Integration/Inlining +; CHECK-NEXT: Deduce function attributes +; CHECK-NEXT: Promote 'by reference' arguments to scalars +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: SROA +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory SSA +; CHECK-NEXT: Early CSE w/ MemorySSA +; CHECK-NEXT: Speculatively execute instructions if target has divergent branches +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Lazy Value Information Analysis +; CHECK-NEXT: Jump Threading +; CHECK-NEXT: Value Propagation +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Combine pattern based expressions +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Conditionally eliminate dead library calls +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: PGOMemOPSize +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Tail Call Elimination +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Reassociate expressions +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Rotate Loops +; CHECK-NEXT: Loop Invariant Code Motion +; CHECK-NEXT: Unswitch loops +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Induction Variable Simplification +; CHECK-NEXT: Recognize loop idioms +; CHECK-NEXT: Delete dead loops +; CHECK-NEXT: Unroll loops +; CHECK-NEXT: MergedLoadStoreMotion +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory Dependence Analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Global Value Numbering +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory Dependence Analysis +; CHECK-NEXT: MemCpy Optimization +; CHECK-NEXT: Sparse Conditional Constant Propagation +; CHECK-NEXT: Demanded bits analysis +; CHECK-NEXT: Bit-Tracking Dead Code Elimination +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Lazy Value Information Analysis +; CHECK-NEXT: Jump Threading +; CHECK-NEXT: Value Propagation +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory Dependence Analysis +; CHECK-NEXT: Dead Store Elimination +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Loop Invariant Code Motion +; CHECK-NEXT: Post-Dominator Tree Construction +; CHECK-NEXT: Aggressive Dead Code Elimination +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: A No-Op Barrier Pass +; CHECK-NEXT: Eliminate Available Externally Globals +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Deduce function attributes in RPO +; CHECK-NEXT: Global Variable Optimizer +; CHECK-NEXT: Unnamed pass: implement Pass::getPassName() +; CHECK-NEXT: Dead Global Elimination +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Globals Alias Analysis +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Float to int +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Rotate Loops +; CHECK-NEXT: Loop Access Analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Loop Distribution +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Loop Access Analysis +; CHECK-NEXT: Demanded bits analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Loop Vectorization +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Loop Access Analysis +; CHECK-NEXT: Loop Load Elimination +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Demanded bits analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: SLP Vectorizer +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Unroll loops +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Loop Invariant Code Motion +; CHECK-NEXT: Alignment from assumptions +; CHECK-NEXT: Strip Unused Function Prototypes +; CHECK-NEXT: Dead Global Elimination +; CHECK-NEXT: Merge Duplicate Global Constants +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Loop Sink +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Remove redundant instructions +; CHECK-NEXT: Hoist/decompose integer division and remainder +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Module Verifier +; CHECK-NEXT: Bitcode Writer +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis + +define void @f() { + ret void +} diff --git a/test/Other/opt-Os-pipeline.ll b/test/Other/opt-Os-pipeline.ll new file mode 100644 index 000000000000..58bf62ffc9c0 --- /dev/null +++ b/test/Other/opt-Os-pipeline.ll @@ -0,0 +1,276 @@ +; RUN: opt -mtriple=x86_64-- -Os -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s + +; REQUIRES: asserts + +; CHECK-LABEL: Pass Arguments: +; CHECK-NEXT: Target Transform Information +; CHECK-NEXT: Type-Based Alias Analysis +; CHECK-NEXT: Scoped NoAlias Alias Analysis +; CHECK-NEXT: Assumption Cache Tracker +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Module Verifier +; CHECK-NEXT: Instrument function entry/exit with calls to e.g. mcount() (pre inlining) +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: SROA +; CHECK-NEXT: Early CSE +; CHECK-NEXT: Lower 'expect' Intrinsics +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: Target Transform Information +; Target Pass Configuration +; CHECK: Type-Based Alias Analysis +; CHECK-NEXT: Scoped NoAlias Alias Analysis +; CHECK-NEXT: Assumption Cache Tracker +; CHECK-NEXT: Profile summary info +; CHECK-NEXT: ModulePass Manager +; CHECK-NEXT: Force set function attributes +; CHECK-NEXT: Infer set function attributes +; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation +; CHECK-NEXT: Called Value Propagation +; CHECK-NEXT: Global Variable Optimizer +; CHECK-NEXT: Unnamed pass: implement Pass::getPassName() +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Promote Memory to Register +; CHECK-NEXT: Dead Argument Elimination +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Globals Alias Analysis +; CHECK-NEXT: Call Graph SCC Pass Manager +; CHECK-NEXT: Remove unused exception handling info +; CHECK-NEXT: Function Integration/Inlining +; CHECK-NEXT: Deduce function attributes +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: SROA +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory SSA +; CHECK-NEXT: Early CSE w/ MemorySSA +; CHECK-NEXT: Speculatively execute instructions if target has divergent branches +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Lazy Value Information Analysis +; CHECK-NEXT: Jump Threading +; CHECK-NEXT: Value Propagation +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Tail Call Elimination +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Reassociate expressions +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Rotate Loops +; CHECK-NEXT: Loop Invariant Code Motion +; CHECK-NEXT: Unswitch loops +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Induction Variable Simplification +; CHECK-NEXT: Recognize loop idioms +; CHECK-NEXT: Delete dead loops +; CHECK-NEXT: Unroll loops +; CHECK-NEXT: MergedLoadStoreMotion +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory Dependence Analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Global Value Numbering +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory Dependence Analysis +; CHECK-NEXT: MemCpy Optimization +; CHECK-NEXT: Sparse Conditional Constant Propagation +; CHECK-NEXT: Demanded bits analysis +; CHECK-NEXT: Bit-Tracking Dead Code Elimination +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Lazy Value Information Analysis +; CHECK-NEXT: Jump Threading +; CHECK-NEXT: Value Propagation +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Memory Dependence Analysis +; CHECK-NEXT: Dead Store Elimination +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Loop Invariant Code Motion +; CHECK-NEXT: Post-Dominator Tree Construction +; CHECK-NEXT: Aggressive Dead Code Elimination +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: A No-Op Barrier Pass +; CHECK-NEXT: Eliminate Available Externally Globals +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Deduce function attributes in RPO +; CHECK-NEXT: Global Variable Optimizer +; CHECK-NEXT: Unnamed pass: implement Pass::getPassName() +; CHECK-NEXT: Dead Global Elimination +; CHECK-NEXT: CallGraph Construction +; CHECK-NEXT: Globals Alias Analysis +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Float to int +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Rotate Loops +; CHECK-NEXT: Loop Access Analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Loop Distribution +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Loop Access Analysis +; CHECK-NEXT: Demanded bits analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Loop Vectorization +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Loop Access Analysis +; CHECK-NEXT: Loop Load Elimination +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Demanded bits analysis +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: SLP Vectorizer +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Unroll loops +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Loop Invariant Code Motion +; CHECK-NEXT: Alignment from assumptions +; CHECK-NEXT: Strip Unused Function Prototypes +; CHECK-NEXT: Dead Global Elimination +; CHECK-NEXT: Merge Duplicate Global Constants +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Canonicalize natural loops +; CHECK-NEXT: LCSSA Verifier +; CHECK-NEXT: Loop-Closed SSA Form Pass +; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) +; CHECK-NEXT: Function Alias Analysis Results +; CHECK-NEXT: Scalar Evolution Analysis +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Loop Pass Manager +; CHECK-NEXT: Loop Sink +; CHECK-NEXT: Lazy Branch Probability Analysis +; CHECK-NEXT: Lazy Block Frequency Analysis +; CHECK-NEXT: Optimization Remark Emitter +; CHECK-NEXT: Remove redundant instructions +; CHECK-NEXT: Hoist/decompose integer division and remainder +; CHECK-NEXT: Simplify the CFG +; CHECK-NEXT: Module Verifier +; CHECK-NEXT: Bitcode Writer +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis +; CHECK-NEXT: Pass Arguments: +; CHECK-NEXT: Target Library Information +; CHECK-NEXT: FunctionPass Manager +; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Natural Loop Information +; CHECK-NEXT: Branch Probability Analysis +; CHECK-NEXT: Block Frequency Analysis + +define void @f() { + ret void +} diff --git a/test/Other/opt-bisect-legacy-pass-manager.ll b/test/Other/opt-bisect-legacy-pass-manager.ll index bf89e80d4960..560675e893c5 100644 --- a/test/Other/opt-bisect-legacy-pass-manager.ll +++ b/test/Other/opt-bisect-legacy-pass-manager.ll @@ -38,7 +38,7 @@ ; utils/bisect) to locate the optimization that inlines the call to ; f2() in f3(). -; RUN: %python %S/opt-bisect-helper.py --start=0 --end=256 --optcmd=opt \ +; RUN: '%python' %S/opt-bisect-helper.py --start=0 --end=256 --optcmd=opt \ ; RUN: --filecheckcmd=FileCheck --test=%s \ ; RUN: --prefix=CHECK-BISECT-INLINE-HELPER \ ; RUN: | FileCheck %s --check-prefix=CHECK-BISECT-INLINE-RESULT diff --git a/test/Other/optimization-remarks-invalidation.ll b/test/Other/optimization-remarks-invalidation.ll index 4a9fbac15c8a..df2175dc03e1 100644 --- a/test/Other/optimization-remarks-invalidation.ll +++ b/test/Other/optimization-remarks-invalidation.ll @@ -75,6 +75,6 @@ Out: !3 = !{i32 2, !"Debug Info Version", i32 3} !4 = !{i32 1, !"PIC Level", i32 2} !5 = !{!"clang version 3.9.0 "} -!6 = distinct !DISubprogram(name: "success", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !2) +!6 = distinct !DISubprogram(name: "success", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !2) !7 = !DISubroutineType(types: !2) !8 = !DILocation(line: 2, column: 20, scope: !6) diff --git a/test/Other/optimization-remarks-lazy-bfi.ll b/test/Other/optimization-remarks-lazy-bfi.ll index bb6459acc062..159736701d7f 100644 --- a/test/Other/optimization-remarks-lazy-bfi.ll +++ b/test/Other/optimization-remarks-lazy-bfi.ll @@ -68,7 +68,7 @@ for.cond.cleanup: !2 = !{} !3 = !{i32 2, !"Dwarf Version", i32 2} !4 = !{i32 2, !"Debug Info Version", i32 3} -!7 = distinct !DISubprogram(name: "forced", scope: !1, file: !1, line: 1, type: !8, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !2) +!7 = distinct !DISubprogram(name: "forced", scope: !1, file: !1, line: 1, type: !8, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !2) !8 = !DISubroutineType(types: !2) !9 = !DILocation(line: 3, column: 20, scope: !7) !10 = !DILocation(line: 3, column: 3, scope: !7) diff --git a/test/Other/pass-pipelines.ll b/test/Other/pass-pipelines.ll index 9e5176eddaa7..dddf1338a4d0 100644 --- a/test/Other/pass-pipelines.ll +++ b/test/Other/pass-pipelines.ll @@ -93,7 +93,7 @@ ; FIXME: There really shouldn't be another pass manager, especially one that ; just builds the domtree. It doesn't even run the verifier. ; CHECK-O2: Pass Arguments: -; CHECK-O2-NEXT: FunctionPass Manager +; CHECK-O2: FunctionPass Manager ; CHECK-O2-NEXT: Dominator Tree Construction define void @foo() { diff --git a/test/Other/pr32085.ll b/test/Other/pr32085.ll index 428f91e52b5e..3676ea8e1171 100644 --- a/test/Other/pr32085.ll +++ b/test/Other/pr32085.ll @@ -1,7 +1,8 @@ ; RUN: opt -S -O1 < %s -o %t1.ll +; RUN: opt -S < %t1.ll -o %t2.ll +; RUN: opt -S -simplifycfg < %t1.ll -o %t3.ll ;; Show that there's no difference after running another simplify CFG -; RUN: opt -S -simplifycfg < %t1.ll -o %t2.ll -; RUN: diff %t1.ll %t2.ll +; RUN: diff %t2.ll %t3.ll ; Test from LoopSink pass, leaves some single-entry single-exit basic blocks. ; After LoopSink, we get a basic block .exit.loopexit which has one entry and diff --git a/test/Other/printer.ll b/test/Other/printer.ll new file mode 100644 index 000000000000..ac1abd704955 --- /dev/null +++ b/test/Other/printer.ll @@ -0,0 +1,13 @@ +; RUN: opt -mem2reg -instcombine -print-after-all -S < %s 2>&1 | FileCheck %s +define void @tester(){ + ret void +} + +define void @foo(){ + ret void +} + +;CHECK: IR Dump After Promote Memory to Register +;CHECK: IR Dump After Combine redundant instructions +;CHECK: IR Dump After Module Verifier +;CHECK-NOT: IR Dump After Print Module IR diff --git a/test/Other/size-remarks.ll b/test/Other/size-remarks.ll new file mode 100644 index 000000000000..864057b5c4b9 --- /dev/null +++ b/test/Other/size-remarks.ll @@ -0,0 +1,164 @@ +; Ensure that IR count remarks in the legacy pass manager work. +; What this test should check for: +; * Positive, nonzero sizes before/after +; * Nonzero deltas +; * Sizes are being tracked properly across multiple remarks. E.g, if we have +; original_count_1, final_count_1, and +; original_count_2, final_count_2, +; Then original_count_2 == final_count_1. + +; For these remarks, the "function" field in the YAML file doesn't matter. +; Each of the testcases work by combining the output remarks with the +; optimization record emit using -pass-remarks-output. This is done to prevent +; test flakiness wrt instruction counts, but also ensure that the output values +; are equivalent in both outputs. + +; RUN: opt < %s -inline -pass-remarks-analysis='size-info' \ +; RUN: -pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \ +; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=CGSCC +; CGSCC: remark: <unknown>:0:0: Function Integration/Inlining: +; CGSCC-SAME: IR instruction count changed from +; CGSCC-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]]; +; CGSCC-SAME: Delta: [[DELTA:-?[1-9][0-9]*]] +; CGSCC: --- !Analysis +; CGSCC-NEXT: Pass: size-info +; CGSCC-NEXT: Name: IRSizeChange +; CGSCC-NEXT: Function: +; CGSCC-NEXT: Args: +; CGSCC-NEXT: - Pass: Function Integration/Inlining +; CGSCC-NEXT: - String: ': IR instruction count changed from ' +; CGSCC-NEXT: - IRInstrsBefore: '[[ORIG]]' +; CGSCC-NEXT: - String: ' to ' +; CGSCC-NEXT: - IRInstrsAfter: '[[FINAL]]' +; CGSCC-NEXT: - String: '; Delta: ' +; CGSCC-NEXT: - DeltaInstrCount: '[[DELTA]]' + +; RUN: opt < %s -instcombine -pass-remarks-analysis='size-info' \ +; RUN:-pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \ +; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=FUNC +; FUNC: remark: <unknown>:0:0: Combine redundant instructions: +; FUNC-SAME: IR instruction count changed from +; FUNC-SAME: [[SIZE1:[1-9][0-9]*]] to [[SIZE2:[1-9][0-9]*]]; +; FUNC-SAME: Delta: [[DELTA1:-?[1-9][0-9]*]] +; FUNC-NEXT: remark: <unknown>:0:0: Combine redundant instructions: +; FUNC-SAME: IR instruction count changed from +; FUNC-SAME: [[SIZE2]] to [[SIZE3:[1-9][0-9]*]]; +; FUNC-SAME: Delta: [[DELTA2:-?[1-9][0-9]*]] +; FUNC: --- !Analysis +; FUNC-NEXT: Pass: size-info +; FUNC-NEXT: Name: IRSizeChange +; FUNC-NEXT: Function: +; FUNC-NEXT: Args: +; FUNC-NEXT: - Pass: Combine redundant instructions +; FUNC-NEXT: - String: ': IR instruction count changed from ' +; FUNC-NEXT: - IRInstrsBefore: '[[SIZE1]]' +; FUNC-NEXT: - String: ' to ' +; FUNC-NEXT: - IRInstrsAfter: '[[SIZE2]]' +; FUNC-NEXT: - String: '; Delta: ' +; FUNC-NEXT: - DeltaInstrCount: '[[DELTA1]]' +; FUNC: --- !Analysis +; FUNC-NEXT: Pass: size-info +; FUNC-NEXT: Name: IRSizeChange +; FUNC-NEXT: Function: +; FUNC-NEXT: Args: +; FUNC-NEXT: - Pass: Combine redundant instructions +; FUNC-NEXT: - String: ': IR instruction count changed from ' +; FUNC-NEXT: - IRInstrsBefore: '[[SIZE2]]' +; FUNC-NEXT: - String: ' to ' +; FUNC-NEXT: - IRInstrsAfter: '[[SIZE3]]' +; FUNC-NEXT: - String: '; Delta: ' +; FUNC-NEXT: - DeltaInstrCount: '[[DELTA2]]' + +; RUN: opt < %s -globaldce -pass-remarks-analysis='size-info' \ +; RUN: -pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \ +; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=MODULE +; MODULE: remark: +; MODULE-SAME: Dead Global Elimination: +; MODULE-SAME: IR instruction count changed from +; MODULE-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]]; +; MODULE-SAME: Delta: [[DELTA:-?[1-9][0-9]*]] +; MODULE: --- !Analysis +; MODULE-NEXT: Pass: size-info +; MODULE-NEXT: Name: IRSizeChange +; MODULE-NEXT: Function: +; MODULE-NEXT: Args: +; MODULE-NEXT: - Pass: Dead Global Elimination +; MODULE-NEXT: - String: ': IR instruction count changed from ' +; MODULE-NEXT: - IRInstrsBefore: '[[ORIG]]' +; MODULE-NEXT: - String: ' to ' +; MODULE-NEXT: - IRInstrsAfter: '[[FINAL]]' +; MODULE-NEXT: - String: '; Delta: ' +; MODULE-NEXT: - DeltaInstrCount: '[[DELTA]]' + +; RUN: opt < %s -dce -pass-remarks-analysis='size-info' \ +; RUN: -pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \ +; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=BB +; BB: remark: <unknown>:0:0: Dead Code Elimination: +; BB-SAME: IR instruction count changed from +; BB-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]]; +; BB-SAME: Delta: [[DELTA:-?[1-9][0-9]*]] +; BB: --- !Analysis +; BB-NEXT: Pass: size-info +; BB-NEXT: Name: IRSizeChange +; BB-NEXT: Function: +; BB-NEXT: Args: +; BB-NEXT: - Pass: Dead Code Elimination +; BB-NEXT: - String: ': IR instruction count changed from ' +; BB-NEXT: - IRInstrsBefore: '[[ORIG]]' +; BB-NEXT: - String: ' to ' +; BB-NEXT: - IRInstrsAfter: '[[FINAL]]' +; BB-NEXT: - String: '; Delta: ' +; BB-NEXT: - DeltaInstrCount: '[[DELTA]]' + +; RUN: opt < %s -loop-unroll -pass-remarks-analysis='size-info' \ +; RUN: -pass-remarks-output=%t.yaml -S -o /dev/null 2> %t; \ +; RUN: cat %t %t.yaml | FileCheck %s -check-prefix=LOOP +; LOOP: remark: <unknown>:0:0: Unroll loops: +; LOOP-SAME: IR instruction count changed from +; LOOP-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]]; +; LOOP-SAME: Delta: [[DELTA:-?[1-9][0-9]*]] +; LOOP: --- !Analysis +; LOOP-NEXT: Pass: size-info +; LOOP-NEXT: Name: IRSizeChange +; LOOP-NEXT: Function: +; LOOP-NEXT: Args: +; LOOP-DAG: - Pass: Unroll loops +; LOOP-NEXT: - String: ': IR instruction count changed from ' +; LOOP-NEXT: - IRInstrsBefore: '[[ORIG]]' +; LOOP-NEXT: - String: ' to ' +; LOOP-NEXT: - IRInstrsAfter: '[[FINAL]]' +; LOOP-NEXT: - String: '; Delta: ' +; LOOP-NEXT: - DeltaInstrCount: '[[DELTA]]' +declare i1 ()* @boop() + +define internal i1 @pluto() { + %F = call i1 ()* () @boop( ) + %c = icmp eq i1 ()* %F, @pluto + ret i1 %c +} + +define i32 @foo(i32 %x) { +entry: + %x.addr = alloca i32, align 4 + store i32 %x, i32* %x.addr, align 4 + %0 = load i32, i32* %x.addr, align 4 + ret i32 %0 +} + +define i32 @bar(i32 %x) { +entry: + %x.addr = alloca i32, align 4 + store i32 %x, i32* %x.addr, align 4 + %0 = load i32, i32* %x.addr, align 4 + %call = call i32 @foo(i32 %0) + br label %for.body +for.body: + %s.06 = phi i32 [ 0, %entry ], [ %add, %for.body ] + %i.05 = phi i32 [ 0, %entry ], [ %inc, %for.body ] + %add = add nsw i32 %i.05, 4 + %inc = add nsw i32 %i.05, 1 + %exitcond = icmp eq i32 %inc, 16 + br i1 %exitcond, label %for.end, label %for.body +for.end: + ret i32 %add +} diff --git a/test/Other/statistic.ll b/test/Other/statistic.ll index 7b89c9e54625..b972780fc35f 100644 --- a/test/Other/statistic.ll +++ b/test/Other/statistic.ll @@ -8,9 +8,9 @@ ; JSON: { ; JSON-DAG: "instsimplify.NumSimplified": 1 -; JSONTIME-DAG: "time.pass.Remove redundant instructions.wall" -; JSONTIME-DAG: "time.pass.Remove redundant instructions.user" -; JSONTIME-DAG: "time.pass.Remove redundant instructions.sys" +; JSONTIME-DAG: "time.pass.instsimplify.wall" +; JSONTIME-DAG: "time.pass.instsimplify.user" +; JSONTIME-DAG: "time.pass.instsimplify.sys" ; JSON: } ; DEFAULT: 1 instsimplify - Number of redundant instructions removed |