From d53a4e7b4a879abd2e17a5c380a3bdee27bc87cb Mon Sep 17 00:00:00 2001 From: Arthur Eubanks Date: Wed, 1 Sep 2021 09:51:31 -0700 Subject: [PATCH] [test] Remove legacy PM tests in llvm/test/Other Differential Revision: https://reviews.llvm.org/D109180 --- llvm/test/Other/2002-01-31-CallGraph.ll | 1 - llvm/test/Other/2007-06-05-PassID.ll | 20 -- llvm/test/Other/2007-06-28-PassManager.ll | 7 - llvm/test/Other/2009-03-31-CallGraph.ll | 36 --- llvm/test/Other/constant-fold-gep.ll | 1 - llvm/test/Other/cspgo-O2-pipeline.ll | 13 - llvm/test/Other/debug-pass-npm.ll | 4 - llvm/test/Other/heat-colors-graphs.ll | 10 +- llvm/test/Other/heat-colors-multigraph.ll | 16 - llvm/test/Other/loop-pass-printer.ll | 12 - llvm/test/Other/opt-LTO-pipeline.ll | 215 -------------- llvm/test/Other/opt-O0-pipeline-enable-matrix.ll | 14 - llvm/test/Other/opt-O0-pipeline.ll | 33 --- llvm/test/Other/opt-O2-pipeline.ll | 335 --------------------- llvm/test/Other/opt-O3-pipeline-enable-matrix.ll | 345 ---------------------- llvm/test/Other/opt-O3-pipeline.ll | 340 --------------------- llvm/test/Other/opt-Os-pipeline.ll | 321 -------------------- llvm/test/Other/opt-bisect-legacy-pass-manager.ll | 178 ----------- llvm/test/Other/opt-hot-cold-split.ll | 5 +- llvm/test/Other/opt-npm.ll | 6 - llvm/test/Other/opt-pipeline-vector-passes.ll | 93 ++---- llvm/test/Other/optimization-remarks-auto.ll | 6 +- llvm/test/Other/optimize-options.ll | 8 - llvm/test/Other/pass-pipelines.ll | 118 -------- llvm/test/Other/pm-pgo-preinline.ll | 24 -- llvm/test/Other/pr49950.ll | 78 ----- llvm/test/Other/print-cfg-sccs.ll | 27 -- llvm/test/Other/print-module-scope.ll | 11 +- llvm/test/Other/printer.ll | 17 +- llvm/test/Other/scc-pass-printer.ll | 19 -- llvm/test/Other/size-remarks.ll | 281 ------------------ llvm/test/Other/statistic.ll | 5 - llvm/test/Other/time-passes.ll | 98 +++--- 33 files changed, 84 insertions(+), 2613 deletions(-) delete mode 100644 llvm/test/Other/2007-06-05-PassID.ll delete mode 100644 llvm/test/Other/2007-06-28-PassManager.ll delete mode 100644 llvm/test/Other/2009-03-31-CallGraph.ll delete mode 100644 llvm/test/Other/cspgo-O2-pipeline.ll delete mode 100644 llvm/test/Other/debug-pass-npm.ll delete mode 100644 llvm/test/Other/heat-colors-multigraph.ll delete mode 100644 llvm/test/Other/opt-LTO-pipeline.ll delete mode 100644 llvm/test/Other/opt-O0-pipeline-enable-matrix.ll delete mode 100644 llvm/test/Other/opt-O0-pipeline.ll delete mode 100644 llvm/test/Other/opt-O2-pipeline.ll delete mode 100644 llvm/test/Other/opt-O3-pipeline-enable-matrix.ll delete mode 100644 llvm/test/Other/opt-O3-pipeline.ll delete mode 100644 llvm/test/Other/opt-Os-pipeline.ll delete mode 100644 llvm/test/Other/opt-bisect-legacy-pass-manager.ll delete mode 100644 llvm/test/Other/opt-npm.ll delete mode 100644 llvm/test/Other/optimize-options.ll delete mode 100644 llvm/test/Other/pass-pipelines.ll delete mode 100644 llvm/test/Other/pm-pgo-preinline.ll delete mode 100644 llvm/test/Other/pr49950.ll delete mode 100644 llvm/test/Other/print-cfg-sccs.ll delete mode 100644 llvm/test/Other/size-remarks.ll diff --git a/llvm/test/Other/2002-01-31-CallGraph.ll b/llvm/test/Other/2002-01-31-CallGraph.ll index 52d8868..b2922f8 100644 --- a/llvm/test/Other/2002-01-31-CallGraph.ll +++ b/llvm/test/Other/2002-01-31-CallGraph.ll @@ -1,6 +1,5 @@ ; Call graph construction crash: Not handling indirect calls right ; -; RUN: opt < %s -analyze -print-callgraph -enable-new-pm=0 > /dev/null 2>&1 ; RUN: opt < %s -passes=print-callgraph > /dev/null 2>&1 ; diff --git a/llvm/test/Other/2007-06-05-PassID.ll b/llvm/test/Other/2007-06-05-PassID.ll deleted file mode 100644 index b166f05..0000000 --- a/llvm/test/Other/2007-06-05-PassID.ll +++ /dev/null @@ -1,20 +0,0 @@ -;RUN: opt < %s -analyze -dot-cfg-only -enable-new-pm=0 2>/dev/null -;RUN: opt < %s -passes=dot-cfg-only 2>/dev/null -;RUN: opt < %s -analyze -dot-cfg-only \ -;RUN: -cfg-heat-colors=true -cfg-weights=true -enable-new-pm=0 2>/dev/null -;RUN: opt < %s -analyze -dot-cfg-only \ -;RUN: -cfg-heat-colors=false -cfg-weights=false -enable-new-pm=0 2>/dev/null -;RUN: opt < %s -analyze -dot-cfg \ -;RUN: -cfg-heat-colors=true -cfg-weights=true -enable-new-pm=0 2>/dev/null -;RUN: opt < %s -analyze -dot-cfg \ -;RUN: -cfg-heat-colors=false -cfg-weights=false -enable-new-pm=0 2>/dev/null -;PR 1497 - -define void @foo() { -entry: - br label %return - -return: ; preds = %entry - ret void -} - diff --git a/llvm/test/Other/2007-06-28-PassManager.ll b/llvm/test/Other/2007-06-28-PassManager.ll deleted file mode 100644 index c6a69a2..0000000 --- a/llvm/test/Other/2007-06-28-PassManager.ll +++ /dev/null @@ -1,7 +0,0 @@ -; RUN: opt < %s -analyze -inline -enable-new-pm=0 -; PR1526 -; RUN: opt < %s -analyze -indvars -enable-new-pm=0 -; PR1539 -define i32 @test1() { - ret i32 0 -} diff --git a/llvm/test/Other/2009-03-31-CallGraph.ll b/llvm/test/Other/2009-03-31-CallGraph.ll deleted file mode 100644 index 54f2691..0000000 --- a/llvm/test/Other/2009-03-31-CallGraph.ll +++ /dev/null @@ -1,36 +0,0 @@ -; RUN: opt < %s -inline -prune-eh -disable-output -enable-new-pm=0 -define void @f2() personality i32 (...)* @__gxx_personality_v0 { - invoke void @f6() - to label %ok1 unwind label %lpad1 - -ok1: - ret void - -lpad1: - landingpad {i8*, i32} - cleanup - invoke void @f4() - to label %ok2 unwind label %lpad2 - -ok2: - call void @f8() - unreachable - -lpad2: - %exn = landingpad {i8*, i32} - cleanup - unreachable -} - -declare void @f3() - -define void @f4() { - call void @f3() - ret void -} - -declare void @f6() nounwind - -declare void @f8() - -declare i32 @__gxx_personality_v0(...) diff --git a/llvm/test/Other/constant-fold-gep.ll b/llvm/test/Other/constant-fold-gep.ll index c09d8d9..5901e4f 100644 --- a/llvm/test/Other/constant-fold-gep.ll +++ b/llvm/test/Other/constant-fold-gep.ll @@ -11,7 +11,6 @@ ; RUN: opt -S -o - -instcombine -globalopt -data-layout="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" < %s | FileCheck --check-prefix=TO %s ; "SCEV" - ScalarEvolution with default target layout -; RUN: opt -analyze -scalar-evolution < %s -enable-new-pm=0 | FileCheck --check-prefix=SCEV %s ; RUN: opt -passes='print' < %s -disable-output 2>&1 | FileCheck --check-prefix=SCEV %s diff --git a/llvm/test/Other/cspgo-O2-pipeline.ll b/llvm/test/Other/cspgo-O2-pipeline.ll deleted file mode 100644 index 26f2e33..0000000 --- a/llvm/test/Other/cspgo-O2-pipeline.ll +++ /dev/null @@ -1,13 +0,0 @@ -; Test CSGen pass in CSPGO. -; RUN: llvm-profdata merge %S/Inputs/cspgo-noncs.proftext -o %t-noncs.profdata -; RUN: llvm-profdata merge %S/Inputs/cspgo-cs.proftext -o %t-cs.profdata -; RUN: opt -enable-new-pm=0 -O2 -debug-pass=Structure -pgo-kind=pgo-instr-use-pipeline -profile-file='%t-noncs.profdata' -cspgo-kind=cspgo-instr-gen-pipeline -cs-profilegen-file=alloc %s 2>&1 |FileCheck %s --check-prefixes=CSGENDEFAULT -; CSGENDEFAULT: PGOInstrumentationUse -; CSGENDEFAULT: PGOInstrumentationGenCreateVar -; CSGENDEFAULT: PGOInstrumentationGen - -; Test CSUse pass in CSPGO. -; RUN: opt -enable-new-pm=0 -O2 -debug-pass=Structure -pgo-kind=pgo-instr-use-pipeline -profile-file='%t-cs.profdata' -cspgo-kind=cspgo-instr-use-pipeline %s 2>&1 |FileCheck %s --check-prefixes=CSUSEDEFAULT -; CSUSEDEFAULT: PGOInstrumentationUse -; CSUSEDEFAULT-NOT: PGOInstrumentationGenCreateVar -; CSUSEDEFAULT: PGOInstrumentationUse diff --git a/llvm/test/Other/debug-pass-npm.ll b/llvm/test/Other/debug-pass-npm.ll deleted file mode 100644 index 55c9baa..0000000 --- a/llvm/test/Other/debug-pass-npm.ll +++ /dev/null @@ -1,4 +0,0 @@ -; RUN: opt -enable-new-pm=0 -O1 %s -debug-pass=Structure -; RUN: not opt -enable-new-pm=1 -O1 %s -debug-pass=Structure 2>&1 | FileCheck %s - -; CHECK: does not work diff --git a/llvm/test/Other/heat-colors-graphs.ll b/llvm/test/Other/heat-colors-graphs.ll index cf19820..cfd1818 100644 --- a/llvm/test/Other/heat-colors-graphs.ll +++ b/llvm/test/Other/heat-colors-graphs.ll @@ -1,11 +1,9 @@ ; RUN: opt %s -dot-cfg -cfg-heat-colors -cfg-dot-filename-prefix=%t -disable-output -; RUN: FileCheck %s -input-file=%t.f.dot --check-prefixes=CHECK-CFG,CHECK-BOTH -; RUN: opt -enable-new-pm=0 %s -dot-callgraph -callgraph-heat-colors -callgraph-dot-filename-prefix=%t -disable-output -; RUN: FileCheck %s -input-file=%t.callgraph.dot --check-prefix=CHECK-BOTH +; RUN: FileCheck %s -input-file=%t.f.dot -; CHECK-BOTH: color="#{{[(a-z)(0-9)]+}}", style={{[a-z]+}}, fillcolor="#{{[(a-z)(0-9)]+}}" -; CHECK-CFG: color="#{{[(a-z)(0-9)]+}}", style={{[a-z]+}}, fillcolor="#{{[(a-z)(0-9)]+}}" -; CHECK-CFG: color="#{{[(a-z)(0-9)]+}}", style={{[a-z]+}}, fillcolor="#{{[(a-z)(0-9)]+}}" +; CHECK: color="#[[#%x,]]", style={{[a-z]+}}, fillcolor="#[[#%x,]]" +; CHECK: color="#[[#%x,]]", style={{[a-z]+}}, fillcolor="#[[#%x,]]" +; CHECK: color="#[[#%x,]]", style={{[a-z]+}}, fillcolor="#[[#%x,]]" define void @f(i32) { entry: diff --git a/llvm/test/Other/heat-colors-multigraph.ll b/llvm/test/Other/heat-colors-multigraph.ll deleted file mode 100644 index 4aab4f4..0000000 --- a/llvm/test/Other/heat-colors-multigraph.ll +++ /dev/null @@ -1,16 +0,0 @@ -; RUN: opt -enable-new-pm=0 %s -dot-callgraph -callgraph-multigraph -callgraph-dot-filename-prefix=%t -disable-output -; RUN: FileCheck %s -input-file=%t.callgraph.dot --check-prefix=CHECK-MULTIGRAPH -; RUN: opt -enable-new-pm=0 %s -dot-callgraph -callgraph-dot-filename-prefix=%t -disable-output -; RUN: FileCheck %s -input-file=%t.callgraph.dot --check-prefix=CHECK - -; CHECK-MULTIGRAPH: {external caller} -; CHECK-NOT: {external caller} - -define void @bar() { - ret void -} - -define void @foo() { - call void @bar() - ret void -} diff --git a/llvm/test/Other/loop-pass-printer.ll b/llvm/test/Other/loop-pass-printer.ll index 10870cc..98ad72b 100644 --- a/llvm/test/Other/loop-pass-printer.ll +++ b/llvm/test/Other/loop-pass-printer.ll @@ -2,20 +2,11 @@ ; Besides of the loop itself it should be dumping loop pre-header and exits. ; ; RUN: opt < %s 2>&1 -disable-output \ -; RUN: -loop-deletion -print-before=loop-deletion \ -; RUN: | FileCheck %s -check-prefix=DEL -; RUN: opt < %s 2>&1 -disable-output \ ; RUN: -passes='loop(loop-deletion)' -print-before=loop-deletion \ ; RUN: | FileCheck %s -check-prefix=DEL -; RUN: opt -enable-new-pm=0 < %s 2>&1 -disable-output \ -; RUN: -loop-unroll -print-after=loop-unroll -filter-print-funcs=bar \ -; RUN: | FileCheck %s -check-prefix=BAR -check-prefix=BAR-OLD ; RUN: opt < %s 2>&1 -disable-output \ ; RUN: -passes='require,loop(loop-unroll-full)' -print-after=loop-unroll-full -filter-print-funcs=bar \ ; RUN: | FileCheck %s -check-prefix=BAR -; RUN: opt -enable-new-pm=0 < %s 2>&1 -disable-output \ -; RUN: -loop-unroll -print-after=loop-unroll -filter-print-funcs=foo -print-module-scope \ -; RUN: | FileCheck %s -check-prefix=FOO-MODULE -check-prefix=FOO-MODULE-OLD ; RUN: opt < %s 2>&1 -disable-output \ ; RUN: -passes='require,loop(loop-unroll-full)' -print-after=loop-unroll-full -filter-print-funcs=foo -print-module-scope \ ; RUN: | FileCheck %s -check-prefix=FOO-MODULE @@ -43,14 +34,11 @@ ; BAR-NEXT: loop: ; BAR: ; Exit blocks ; BAR: end: -; BAR-OLD-NOT: IR Dump -; BAR-OLD-NOT: ; Loop ; FOO-MODULE: IR Dump After {{Unroll|LoopFullUnrollPass}} {{.*}}%loop ; FOO-MODULE-NEXT: ModuleID = ; FOO-MODULE: define void @foo ; FOO-MODULE: define void @bar -; FOO-MODULE-OLD-NOT: IR Dump define void @foo(){ %idx = alloca i32, align 4 diff --git a/llvm/test/Other/opt-LTO-pipeline.ll b/llvm/test/Other/opt-LTO-pipeline.ll deleted file mode 100644 index b96f555..0000000 --- a/llvm/test/Other/opt-LTO-pipeline.ll +++ /dev/null @@ -1,215 +0,0 @@ -; RUN: opt -enable-new-pm=0 -mtriple=x86_64-- -std-link-opts -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck --check-prefix=CHECK %s - -; REQUIRES: asserts - -; CHECK-LABEL: 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: Profile summary info -; CHECK-NEXT: Assumption Cache Tracker -; CHECK-NEXT: ModulePass Manager -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Module Verifier -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: Force set function attributes -; CHECK-NEXT: Infer set function attributes -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Call-site splitting -; CHECK-NEXT: PGOIndirectCallPromotion -; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Called Value Propagation -; CHECK-NEXT: CallGraph Construction -; CHECK-NEXT: Call Graph SCC Pass Manager -; CHECK-NEXT: Deduce function attributes -; CHECK-NEXT: Deduce function attributes in RPO -; CHECK-NEXT: Global splitter -; CHECK-NEXT: Whole program devirtualization -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Global Variable Optimizer -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Promote Memory to Register -; CHECK-NEXT: Merge Duplicate Global Constants -; 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: CallGraph Construction -; CHECK-NEXT: Call Graph SCC Pass Manager -; CHECK-NEXT: Function Integration/Inlining -; CHECK-NEXT: Remove unused exception handling info -; CHECK-NEXT: OpenMP specific optimizations -; CHECK-NEXT: Global Variable Optimizer -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: CallGraph Construction -; CHECK-NEXT: Call Graph SCC Pass Manager -; CHECK-NEXT: Promote 'by reference' arguments to scalars -; 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: Lazy Value Information Analysis -; CHECK-NEXT: Jump Threading -; CHECK-NEXT: SROA -; 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: CallGraph Construction -; CHECK-NEXT: Call Graph SCC Pass Manager -; CHECK-NEXT: Deduce function attributes -; CHECK-NEXT: Globals Alias Analysis -; 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: Memory SSA -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Canonicalize natural loops -; CHECK-NEXT: LCSSA Verifier -; CHECK-NEXT: Loop-Closed SSA Form Pass -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; CHECK-NEXT: Phi Values Analysis -; CHECK-NEXT: Memory Dependence 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: MemCpy Optimization -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Dead Store Elimination -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: MergedLoadStoreMotion -; 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: Induction Variable Simplification -; CHECK-NEXT: Delete dead loops -; CHECK-NEXT: Unroll 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: Post-Dominator Tree Construction -; 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: Inject TLI Mappings -; CHECK-NEXT: Loop Vectorization -; 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: Unroll loops -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Optimization Remark Emitter -; CHECK-NEXT: Warn about non-applied transformations -; CHECK-NEXT: Combine redundant instructions -; CHECK-NEXT: Simplify the CFG -; CHECK-NEXT: Sparse Conditional Constant Propagation -; 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: Demanded bits analysis -; CHECK-NEXT: Bit-Tracking Dead Code Elimination -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Optimize scalar/vector ops -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Alignment from assumptions -; CHECK-NEXT: Optimization Remark Emitter -; CHECK-NEXT: Combine redundant instructions -; CHECK-NEXT: Lazy Value Information Analysis -; CHECK-NEXT: Jump Threading -; CHECK-NEXT: Cross-DSO CFI -; CHECK-NEXT: Lower type metadata -; CHECK-NEXT: Lower type metadata -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Simplify the CFG -; CHECK-NEXT: Eliminate Available Externally Globals -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Annotation Remarks -; CHECK-NEXT: Module Verifier -; CHECK-NEXT: Bitcode Writer -; CHECK-NEXT: Pass Arguments: -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Pass Arguments: -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis - -define void @f() { - ret void -} diff --git a/llvm/test/Other/opt-O0-pipeline-enable-matrix.ll b/llvm/test/Other/opt-O0-pipeline-enable-matrix.ll deleted file mode 100644 index 15784f2..0000000 --- a/llvm/test/Other/opt-O0-pipeline-enable-matrix.ll +++ /dev/null @@ -1,14 +0,0 @@ -; RUN: opt -enable-new-pm=0 -O0 -enable-matrix -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s - -; REQUIRES: asserts - -; CHECK: Pass Arguments: -; CHECK-NEXT: Target Transform Information -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Module Verifier -; CHECK-NEXT: Lower the matrix intrinsics (minimal) - - -define void @f() { - ret void -} diff --git a/llvm/test/Other/opt-O0-pipeline.ll b/llvm/test/Other/opt-O0-pipeline.ll deleted file mode 100644 index c47642e..0000000 --- a/llvm/test/Other/opt-O0-pipeline.ll +++ /dev/null @@ -1,33 +0,0 @@ -; RUN: opt -enable-new-pm=0 -mtriple=x86_64-- -O0 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefixes=CHECK,%llvmcheckext - -; REQUIRES: asserts - -; Suppress FileCheck --allow-unused-prefixes=false diagnostics. -; CHECK-NOEXT: {{^}} - -; CHECK-LABEL: Pass Arguments: -; CHECK-NEXT: Target Transform Information -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Module Verifier -; CHECK-EXT: Good Bye World Pass -; 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: Annotation2Metadata -; 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: Annotation Remarks -; CHECK-NEXT: Module Verifier -; CHECK-NEXT: Bitcode Writer - -define void @f() { - ret void -} diff --git a/llvm/test/Other/opt-O2-pipeline.ll b/llvm/test/Other/opt-O2-pipeline.ll deleted file mode 100644 index 542a798..0000000 --- a/llvm/test/Other/opt-O2-pipeline.ll +++ /dev/null @@ -1,335 +0,0 @@ -; RUN: opt -enable-new-pm=0 -mtriple=x86_64-- -O2 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck --check-prefixes=CHECK,%llvmcheckext %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-EXT: Good Bye World Pass -; CHECK-NOEXT-NOT: Good Bye World Pass -; CHECK-NEXT: Lower 'expect' Intrinsics -; CHECK-NEXT: Simplify the CFG -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: SROA -; CHECK-NEXT: Early CSE -; 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: Annotation2Metadata -; CHECK-NEXT: Force set function attributes -; CHECK-NEXT: Infer set function attributes -; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Called Value Propagation -; CHECK-NEXT: Global Variable Optimizer -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; 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: OpenMP specific optimizations -; 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: Post-Dominator Tree Construction -; 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: Basic Alias Analysis (stateless AA impl) -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Memory SSA -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Canonicalize natural loops -; CHECK-NEXT: LCSSA Verifier -; CHECK-NEXT: Loop-Closed SSA Form Pass -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; 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: Recognize loop idioms -; CHECK-NEXT: Induction Variable Simplification -; CHECK-NEXT: Delete dead loops -; CHECK-NEXT: Unroll loops -; CHECK-NEXT: SROA -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: MergedLoadStoreMotion -; CHECK-NEXT: Phi Values Analysis -; 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: Sparse Conditional Constant Propagation -; CHECK-NEXT: Demanded bits analysis -; CHECK-NEXT: Bit-Tracking Dead Code 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: Lazy Value Information Analysis -; CHECK-NEXT: Jump Threading -; CHECK-NEXT: Value Propagation -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Aggressive Dead Code Elimination -; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Memory SSA -; CHECK-NEXT: MemCpy Optimization -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Dead Store Elimination -; 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: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; 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: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: CallGraph Construction -; CHECK-NEXT: Globals Alias Analysis -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Float to int -; CHECK-NEXT: Lower constant intrinsics -; 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: Post-Dominator Tree Construction -; 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: Inject TLI Mappings -; 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: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency 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: Inject TLI Mappings -; CHECK-NEXT: SLP Vectorizer -; CHECK-NEXT: Optimize scalar/vector ops -; 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: Memory SSA -; CHECK-NEXT: Canonicalize natural loops -; CHECK-NEXT: LCSSA Verifier -; CHECK-NEXT: Loop-Closed SSA Form Pass -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; CHECK-NEXT: Optimization Remark Emitter -; CHECK-NEXT: Warn about non-applied transformations -; CHECK-NEXT: Alignment from assumptions -; CHECK-NEXT: Strip Unused Function Prototypes -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: Merge Duplicate Global Constants -; CHECK-NEXT: Call Graph Profile -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; 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: 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: Annotation Remarks -; CHECK-NEXT: Module Verifier -; CHECK-NEXT: Bitcode Writer -; CHECK-NEXT: Pass Arguments: -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis - -define void @f() { - ret void -} diff --git a/llvm/test/Other/opt-O3-pipeline-enable-matrix.ll b/llvm/test/Other/opt-O3-pipeline-enable-matrix.ll deleted file mode 100644 index 4c5e126..0000000 --- a/llvm/test/Other/opt-O3-pipeline-enable-matrix.ll +++ /dev/null @@ -1,345 +0,0 @@ -; RUN: opt -enable-new-pm=0 -O3 -enable-matrix -debug-pass=Structure %s -disable-output 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-EXT: Good Bye World Pass -; CHECK-NOEXT-NOT: Good Bye World Pass -; CHECK-NEXT: Lower 'expect' Intrinsics -; CHECK-NEXT: Simplify the CFG -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: SROA -; CHECK-NEXT: Early CSE -; 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: Annotation2Metadata -; CHECK-NEXT: Force set function attributes -; CHECK-NEXT: Infer set function attributes -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Call-site splitting -; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Called Value Propagation -; CHECK-NEXT: Global Variable Optimizer -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; 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: OpenMP specific optimizations -; 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: Post-Dominator Tree Construction -; 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: Basic Alias Analysis (stateless AA impl) -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Memory SSA -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Canonicalize natural loops -; CHECK-NEXT: LCSSA Verifier -; CHECK-NEXT: Loop-Closed SSA Form Pass -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; 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: Recognize loop idioms -; CHECK-NEXT: Induction Variable Simplification -; CHECK-NEXT: Delete dead loops -; CHECK-NEXT: Unroll loops -; CHECK-NEXT: SROA -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: MergedLoadStoreMotion -; CHECK-NEXT: Phi Values Analysis -; 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: Sparse Conditional Constant Propagation -; CHECK-NEXT: Demanded bits analysis -; CHECK-NEXT: Bit-Tracking Dead Code 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: Lazy Value Information Analysis -; CHECK-NEXT: Jump Threading -; CHECK-NEXT: Value Propagation -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Aggressive Dead Code Elimination -; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Memory SSA -; CHECK-NEXT: MemCpy Optimization -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Dead Store Elimination -; 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: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; 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: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: CallGraph Construction -; CHECK-NEXT: Globals Alias Analysis -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Float to int -; CHECK-NEXT: Lower constant intrinsics -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Optimization Remark Emitter -; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Lower the matrix intrinsics -; CHECK-NEXT: Early CSE -; 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: Post-Dominator Tree Construction -; 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: Inject TLI Mappings -; 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: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency 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: Inject TLI Mappings -; CHECK-NEXT: SLP Vectorizer -; CHECK-NEXT: Optimize scalar/vector ops -; 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: Memory SSA -; CHECK-NEXT: Canonicalize natural loops -; CHECK-NEXT: LCSSA Verifier -; CHECK-NEXT: Loop-Closed SSA Form Pass -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; CHECK-NEXT: Optimization Remark Emitter -; CHECK-NEXT: Warn about non-applied transformations -; CHECK-NEXT: Alignment from assumptions -; CHECK-NEXT: Strip Unused Function Prototypes -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: Merge Duplicate Global Constants -; CHECK-NEXT: Call Graph Profile -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; 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: 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: Annotation Remarks -; CHECK-NEXT: Module Verifier -; CHECK-NEXT: Pass Arguments: -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -define void @f() { - ret void -} diff --git a/llvm/test/Other/opt-O3-pipeline.ll b/llvm/test/Other/opt-O3-pipeline.ll deleted file mode 100644 index 97b11fe..0000000 --- a/llvm/test/Other/opt-O3-pipeline.ll +++ /dev/null @@ -1,340 +0,0 @@ -; RUN: opt -enable-new-pm=0 -mtriple=x86_64-- -O3 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck --check-prefixes=CHECK,%llvmcheckext %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-EXT: Good Bye World Pass -; CHECK-NOEXT-NOT: Good Bye World Pass -; CHECK-NEXT: Lower 'expect' Intrinsics -; CHECK-NEXT: Simplify the CFG -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: SROA -; CHECK-NEXT: Early CSE -; 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: Annotation2Metadata -; CHECK-NEXT: Force set function attributes -; CHECK-NEXT: Infer set function attributes -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Call-site splitting -; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Called Value Propagation -; CHECK-NEXT: Global Variable Optimizer -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; 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: OpenMP specific optimizations -; 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: Post-Dominator Tree Construction -; 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: Basic Alias Analysis (stateless AA impl) -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Memory SSA -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Canonicalize natural loops -; CHECK-NEXT: LCSSA Verifier -; CHECK-NEXT: Loop-Closed SSA Form Pass -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; 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: Recognize loop idioms -; CHECK-NEXT: Induction Variable Simplification -; CHECK-NEXT: Delete dead loops -; CHECK-NEXT: Unroll loops -; CHECK-NEXT: SROA -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: MergedLoadStoreMotion -; CHECK-NEXT: Phi Values Analysis -; 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: Sparse Conditional Constant Propagation -; CHECK-NEXT: Demanded bits analysis -; CHECK-NEXT: Bit-Tracking Dead Code 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: Lazy Value Information Analysis -; CHECK-NEXT: Jump Threading -; CHECK-NEXT: Value Propagation -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Aggressive Dead Code Elimination -; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Memory SSA -; CHECK-NEXT: MemCpy Optimization -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Dead Store Elimination -; 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: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; 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: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: CallGraph Construction -; CHECK-NEXT: Globals Alias Analysis -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Float to int -; CHECK-NEXT: Lower constant intrinsics -; 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: Post-Dominator Tree Construction -; 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: Inject TLI Mappings -; 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: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency 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: Inject TLI Mappings -; CHECK-NEXT: SLP Vectorizer -; CHECK-NEXT: Optimize scalar/vector ops -; 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: Memory SSA -; CHECK-NEXT: Canonicalize natural loops -; CHECK-NEXT: LCSSA Verifier -; CHECK-NEXT: Loop-Closed SSA Form Pass -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; CHECK-NEXT: Optimization Remark Emitter -; CHECK-NEXT: Warn about non-applied transformations -; CHECK-NEXT: Alignment from assumptions -; CHECK-NEXT: Strip Unused Function Prototypes -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: Merge Duplicate Global Constants -; CHECK-NEXT: Call Graph Profile -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; 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: 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: Annotation Remarks -; CHECK-NEXT: Module Verifier -; CHECK-NEXT: Bitcode Writer -; CHECK-NEXT: Pass Arguments: -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis - -define void @f() { - ret void -} diff --git a/llvm/test/Other/opt-Os-pipeline.ll b/llvm/test/Other/opt-Os-pipeline.ll deleted file mode 100644 index b65e550..0000000 --- a/llvm/test/Other/opt-Os-pipeline.ll +++ /dev/null @@ -1,321 +0,0 @@ -; RUN: opt -enable-new-pm=0 -mtriple=x86_64-- -Os -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck --check-prefixes=CHECK,%llvmcheckext %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-EXT: Good Bye World Pass -; CHECK-NOEXT-NOT: Good Bye World Pass -; CHECK-NEXT: Lower 'expect' Intrinsics -; CHECK-NEXT: Simplify the CFG -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: SROA -; CHECK-NEXT: Early CSE -; 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: Annotation2Metadata -; CHECK-NEXT: Force set function attributes -; CHECK-NEXT: Infer set function attributes -; CHECK-NEXT: Interprocedural Sparse Conditional Constant Propagation -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Called Value Propagation -; CHECK-NEXT: Global Variable Optimizer -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; 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: OpenMP specific optimizations -; 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: Basic Alias Analysis (stateless AA impl) -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Memory SSA -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Canonicalize natural loops -; CHECK-NEXT: LCSSA Verifier -; CHECK-NEXT: Loop-Closed SSA Form Pass -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; 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: Recognize loop idioms -; CHECK-NEXT: Induction Variable Simplification -; CHECK-NEXT: Delete dead loops -; CHECK-NEXT: Unroll loops -; CHECK-NEXT: SROA -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: MergedLoadStoreMotion -; CHECK-NEXT: Phi Values Analysis -; 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: Sparse Conditional Constant Propagation -; CHECK-NEXT: Demanded bits analysis -; CHECK-NEXT: Bit-Tracking Dead Code 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: Lazy Value Information Analysis -; CHECK-NEXT: Jump Threading -; CHECK-NEXT: Value Propagation -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Aggressive Dead Code Elimination -; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) -; CHECK-NEXT: Function Alias Analysis Results -; CHECK-NEXT: Memory SSA -; CHECK-NEXT: MemCpy Optimization -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Dead Store Elimination -; 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: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; 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: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: CallGraph Construction -; CHECK-NEXT: Globals Alias Analysis -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Float to int -; CHECK-NEXT: Lower constant intrinsics -; 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: Post-Dominator Tree Construction -; 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: Inject TLI Mappings -; 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: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency 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: Inject TLI Mappings -; CHECK-NEXT: SLP Vectorizer -; CHECK-NEXT: Optimize scalar/vector ops -; 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: Memory SSA -; CHECK-NEXT: Canonicalize natural loops -; CHECK-NEXT: LCSSA Verifier -; CHECK-NEXT: Loop-Closed SSA Form Pass -; CHECK-NEXT: Scalar Evolution Analysis -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: Loop Pass Manager -; CHECK-NEXT: Loop Invariant Code Motion -; CHECK-NEXT: Optimization Remark Emitter -; CHECK-NEXT: Warn about non-applied transformations -; CHECK-NEXT: Alignment from assumptions -; CHECK-NEXT: Strip Unused Function Prototypes -; CHECK-NEXT: Dead Global Elimination -; CHECK-NEXT: Merge Duplicate Global Constants -; CHECK-NEXT: Call Graph Profile -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Lazy Branch Probability Analysis -; CHECK-NEXT: Lazy Block Frequency Analysis -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; CHECK-NEXT: Natural Loop Information -; CHECK-NEXT: Post-Dominator Tree Construction -; 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: 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: Annotation Remarks -; CHECK-NEXT: Module Verifier -; CHECK-NEXT: Bitcode Writer -; CHECK-NEXT: Pass Arguments: -; CHECK-NEXT: FunctionPass Manager -; CHECK-NEXT: Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; 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: Post-Dominator Tree Construction -; CHECK-NEXT: Branch Probability Analysis -; CHECK-NEXT: Block Frequency Analysis - -define void @f() { - ret void -} diff --git a/llvm/test/Other/opt-bisect-legacy-pass-manager.ll b/llvm/test/Other/opt-bisect-legacy-pass-manager.ll deleted file mode 100644 index 8d966de..0000000 --- a/llvm/test/Other/opt-bisect-legacy-pass-manager.ll +++ /dev/null @@ -1,178 +0,0 @@ -; This file verifies the behavior of the OptBisect class, which is used to -; diagnose optimization related failures. The tests check various -; invocations that result in different sets of optimization passes that -; are run in different ways. -; -; This set of tests exercises the legacy pass manager interface to the OptBisect -; class. Because the exact set of optimizations that will be run may -; change over time, these tests are written in a more general manner than the -; corresponding tests for the new pass manager. -; -; Don't use NEXT checks or hard-code pass numbering so that this won't fail if -; new passes are inserted. - - -; Verify that the file can be compiled to an object file at -O3 with all -; skippable passes skipped. - -; REQUIRES: default_triple -; RUN: opt -O3 -opt-bisect-limit=0 -enable-new-pm=0 < %s | llc -O3 -opt-bisect-limit=0 - - -; Verify that no skippable passes are run with -opt-bisect-limit=0. - -; RUN: opt -disable-output -disable-verify -O3 -opt-bisect-limit=0 %s -enable-new-pm=0 2>&1 \ -; RUN: | FileCheck %s --check-prefix=CHECK-SKIP-ALL -; CHECK-SKIP-ALL: BISECT: NOT running pass ({{[0-9]+}}) -; CHECK-SKIP-ALL-NOT: BISECT: running pass ({{[0-9]+}}) - - -; Verify that no passes run at -O0 are skipped -; RUN: opt -opt-bisect-limit=0 < %s 2>&1 -enable-new-pm=0 | FileCheck %s --check-prefix=OPTBISECT-O0 -; OPTBISECT-O0-NOT: BISECT: NOT running - -; FIXME: There are still some AMDGPU passes being skipped that run at -O0. -; XFAIL: r600, amdgcn - -; Verify that we can use the opt-bisect-helper.py script (derived from -; 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: --filecheckcmd=FileCheck --test=%s \ -; RUN: --prefix=CHECK-BISECT-INLINE-HELPER \ -; RUN: | FileCheck %s --check-prefix=CHECK-BISECT-INLINE-RESULT -; The helper script uses this to find the optimization that inlines the call. -; CHECK-BISECT-INLINE-HELPER: call i32 @f2() -; These checks verifies that the optimization was found. -; CHECK-BISECT-INLINE-RESULT-NOT: Last good count: 0 -; CHECK-BISECT-INLINE-RESULT: Last good count: {{[0-9]+}} - - -; Test a module pass. - -; RUN: opt -disable-output -disable-verify -deadargelim -opt-bisect-limit=-1 %s -enable-new-pm=0 \ -; RUN: 2>&1 | FileCheck %s --check-prefix=CHECK-DEADARG -; CHECK-DEADARG: BISECT: running pass ({{[0-9]+}}) Dead Argument Elimination on module - -; RUN: opt -disable-output -disable-verify -deadargelim -opt-bisect-limit=0 %s -enable-new-pm=0 \ -; RUN: 2>&1 | FileCheck %s --check-prefix=CHECK-NOT-DEADARG -; CHECK-NOT-DEADARG: BISECT: NOT running pass ({{[0-9]+}}) Dead Argument Elimination on module - - -; Test an SCC pass. - -; RUN: opt -disable-output -disable-verify -inline -opt-bisect-limit=-1 %s -enable-new-pm=0 \ -; RUN: 2>&1 | FileCheck %s --check-prefix=CHECK-INLINE -; CHECK-INLINE: BISECT: running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (<>) -; CHECK-INLINE: BISECT: running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (g) -; CHECK-INLINE: BISECT: running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (f1) -; CHECK-INLINE: BISECT: running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (f2) -; CHECK-INLINE: BISECT: running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (f3) -; CHECK-INLINE: BISECT: running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (<>) - -; RUN: opt -disable-output -disable-verify -inline -opt-bisect-limit=0 %s -enable-new-pm=0 \ -; RUN: 2>&1 | FileCheck %s --check-prefix=CHECK-NOT-INLINE -; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (<>) -; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (g) -; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (f1) -; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (f2) -; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (f3) -; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (<>) - - -; Test a function pass. - -; RUN: opt -disable-output -disable-verify -early-cse -earlycse-debug-hash -opt-bisect-limit=-1 -enable-new-pm=0 \ -; RUN: %s 2>&1 | FileCheck %s --check-prefix=CHECK-EARLY-CSE -; CHECK-EARLY-CSE: BISECT: running pass ({{[0-9]+}}) Early CSE on function (f1) -; CHECK-EARLY-CSE: BISECT: running pass ({{[0-9]+}}) Early CSE on function (f2) -; CHECK-EARLY-CSE: BISECT: running pass ({{[0-9]+}}) Early CSE on function (f3) - -; RUN: opt -disable-output -disable-verify -early-cse -earlycse-debug-hash -opt-bisect-limit=0 -enable-new-pm=0 \ -; RUN: %s 2>&1 | FileCheck %s --check-prefix=CHECK-NOT-EARLY-CSE -; CHECK-NOT-EARLY-CSE: BISECT: NOT running pass ({{[0-9]+}}) Early CSE on function (f1) -; CHECK-NOT-EARLY-CSE: BISECT: NOT running pass ({{[0-9]+}}) Early CSE on function (f2) -; CHECK-NOT-EARLY-CSE: BISECT: NOT running pass ({{[0-9]+}}) Early CSE on function (f3) - - -; Test a loop pass. - -; RUN: opt -disable-output -disable-verify -loop-reduce -opt-bisect-limit=-1 -enable-new-pm=0 \ -; RUN: %s 2>&1 | FileCheck %s --check-prefix=CHECK-LOOP-REDUCE -; CHECK-LOOP-REDUCE: BISECT: running pass ({{[0-9]+}}) Loop Strength Reduction on loop -; CHECK-LOOP-REDUCE: BISECT: running pass ({{[0-9]+}}) Loop Strength Reduction on loop -; CHECK-LOOP-REDUCE: BISECT: running pass ({{[0-9]+}}) Loop Strength Reduction on loop -; CHECK-LOOP-REDUCE: BISECT: running pass ({{[0-9]+}}) Loop Strength Reduction on loop -; CHECK-LOOP-REDUCE: BISECT: running pass ({{[0-9]+}}) Loop Strength Reduction on loop - -; RUN: opt -disable-output -disable-verify -loop-reduce -opt-bisect-limit=0 -enable-new-pm=0 \ -; RUN: %s 2>&1 | FileCheck %s --check-prefix=CHECK-NOT-LOOP-REDUCE -; CHECK-NOT-LOOP-REDUCE: BISECT: NOT running pass ({{[0-9]+}}) Loop Strength Reduction on loop -; CHECK-NOT-LOOP-REDUCE: BISECT: NOT running pass ({{[0-9]+}}) Loop Strength Reduction on loop -; CHECK-NOT-LOOP-REDUCE: BISECT: NOT running pass ({{[0-9]+}}) Loop Strength Reduction on loop -; CHECK-NOT-LOOP-REDUCE: BISECT: NOT running pass ({{[0-9]+}}) Loop Strength Reduction on loop -; CHECK-NOT-LOOP-REDUCE: BISECT: NOT running pass ({{[0-9]+}}) Loop Strength Reduction on loop - - -declare i32 @g() - -define void @f1() { -entry: - br label %loop.0 -loop.0: - br i1 undef, label %loop.0.0, label %loop.1 -loop.0.0: - br i1 undef, label %loop.0.0, label %loop.0.1 -loop.0.1: - br i1 undef, label %loop.0.1, label %loop.0 -loop.1: - br i1 undef, label %loop.1, label %loop.1.bb1 -loop.1.bb1: - br i1 undef, label %loop.1, label %loop.1.bb2 -loop.1.bb2: - br i1 undef, label %end, label %loop.1.0 -loop.1.0: - br i1 undef, label %loop.1.0, label %loop.1 -end: - ret void -} - -define i32 @f2() { -entry: - ret i32 0 -} - -define i32 @f3() { -entry: - %temp = call i32 @g() - %icmp = icmp ugt i32 %temp, 2 - br i1 %icmp, label %bb.true, label %bb.false -bb.true: - %temp2 = call i32 @f2() - ret i32 %temp2 -bb.false: - ret i32 0 -} - -; This function is here to verify that opt-bisect can skip all passes for -; functions that contain lifetime intrinsics. -define void @f4() { -entry: - %i = alloca i32, align 4 - %tmp = bitcast i32* %i to i8* - call void @llvm.lifetime.start(i64 4, i8* %tmp) - br label %for.cond - -for.cond: - br i1 undef, label %for.body, label %for.end - -for.body: - br label %for.cond - -for.end: - ret void -} - -declare void @llvm.lifetime.start(i64, i8* nocapture) - diff --git a/llvm/test/Other/opt-hot-cold-split.ll b/llvm/test/Other/opt-hot-cold-split.ll index cd01314..21c713d 100644 --- a/llvm/test/Other/opt-hot-cold-split.ll +++ b/llvm/test/Other/opt-hot-cold-split.ll @@ -1,4 +1,4 @@ -; RUN: opt -mtriple=x86_64-- -Os -hot-cold-split=true -debug-pass=Structure -enable-new-pm=0 < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=DEFAULT-Os +; RUN: opt -mtriple=x86_64-- -hot-cold-split=true -passes='default' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=DEFAULT-Os ; RUN: opt -mtriple=x86_64-- -hot-cold-split=true -passes='lto-pre-link' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=LTO-PRELINK-Os ; RUN: opt -mtriple=x86_64-- -hot-cold-split=true -passes='thinlto-pre-link' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=THINLTO-PRELINK-Os ; RUN: opt -mtriple=x86_64-- -hot-cold-split=true -passes='lto' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=LTO-POSTLINK-Os @@ -8,8 +8,7 @@ ; Splitting should occur late. -; DEFAULT-Os: Hot Cold Splitting -; DEFAULT-Os: Simplify the CFG +; DEFAULT-Os: pass: HotColdSplittingPass ; LTO-PRELINK-Os-NOT: pass: HotColdSplittingPass diff --git a/llvm/test/Other/opt-npm.ll b/llvm/test/Other/opt-npm.ll deleted file mode 100644 index 0b1e651..0000000 --- a/llvm/test/Other/opt-npm.ll +++ /dev/null @@ -1,6 +0,0 @@ -; RUN: opt -dce -enable-new-pm -disable-output -debug-pass-manager %s 2>&1 | FileCheck %s - -; CHECK: DCEPass -define void @foo() { - ret void -} diff --git a/llvm/test/Other/opt-pipeline-vector-passes.ll b/llvm/test/Other/opt-pipeline-vector-passes.ll index 7fe57da..af70299 100644 --- a/llvm/test/Other/opt-pipeline-vector-passes.ll +++ b/llvm/test/Other/opt-pipeline-vector-passes.ll @@ -1,81 +1,36 @@ -; RUN: opt -enable-new-pm=0 -O1 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefixes=OLDPM_O1 -; RUN: opt -enable-new-pm=0 -O2 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefixes=OLDPM_O2 -; RUN: opt -enable-new-pm=0 -O2 -extra-vectorizer-passes -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefixes=OLDPM_O2_EXTRA -; RUN: opt -enable-new-pm=0 -O1 -vectorize-loops=0 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefixes=OLDPM_O1_FORCE_OFF -; RUN: opt -enable-new-pm=0 -O2 -vectorize-loops=0 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefixes=OLDPM_O2_FORCE_OFF -; RUN: opt -disable-verify -debug-pass-manager -passes='default' -S %s 2>&1 | FileCheck %s --check-prefixes=NEWPM_O1 -; RUN: opt -disable-verify -debug-pass-manager -passes='default' -S %s 2>&1 | FileCheck %s --check-prefixes=NEWPM_O2 -; RUN: opt -disable-verify -debug-pass-manager -passes='default' -extra-vectorizer-passes -S %s 2>&1 | FileCheck %s --check-prefixes=NEWPM_O2_EXTRA +; RUN: opt -disable-verify -debug-pass-manager -passes='default' -S %s 2>&1 | FileCheck %s --check-prefixes=O1 +; RUN: opt -disable-verify -debug-pass-manager -passes='default' -S %s 2>&1 | FileCheck %s --check-prefixes=O2 +; RUN: opt -disable-verify -debug-pass-manager -passes='default' -extra-vectorizer-passes -S %s 2>&1 | FileCheck %s --check-prefixes=O2_EXTRA ; REQUIRES: asserts -; SLP does not run at -O1. Loop vectorization runs, but it only -; works on loops explicitly annotated with pragmas. - -; OLDPM_O1-LABEL: Pass Arguments: -; OLDPM_O1: Loop Vectorization -; OLDPM_O1-NOT: SLP Vectorizer -; OLDPM_O1: Optimize scalar/vector ops - -; Everything runs at -O2. - -; OLDPM_O2-LABEL: Pass Arguments: -; OLDPM_O2: Loop Vectorization -; OLDPM_O2: SLP Vectorizer -; OLDPM_O2: Optimize scalar/vector ops - -; Optionally run cleanup passes. - -; OLDPM_O2_EXTRA-LABEL: Pass Arguments: -; OLDPM_O2_EXTRA: Loop Vectorization -; OLDPM_O2_EXTRA: Early CSE -; OLDPM_O2_EXTRA: Value Propagation -; OLDPM_O2_EXTRA: Combine redundant instructions -; OLDPM_O2_EXTRA: Loop Invariant Code Motion -; OLDPM_O2_EXTRA: Unswitch loops -; OLDPM_O2_EXTRA: Simplify the CFG -; OLDPM_O2_EXTRA: Combine redundant instructions -; OLDPM_O2_EXTRA: SLP Vectorizer -; OLDPM_O2_EXTRA: Early CSE -; OLDPM_O2_EXTRA: Optimize scalar/vector ops - - ; The loop vectorizer still runs at both -O1/-O2 even with the ; debug flag, but it only works on loops explicitly annotated ; with pragmas. -; OLDPM_O1_FORCE_OFF-LABEL: Pass Arguments: -; OLDPM_O1_FORCE_OFF: Loop Vectorization -; OLDPM_O1_FORCE_OFF-NOT: SLP Vectorizer -; OLDPM_O1_FORCE_OFF: Optimize scalar/vector ops - -; OLDPM_O2_FORCE_OFF-LABEL: Pass Arguments: -; OLDPM_O2_FORCE_OFF: Loop Vectorization -; OLDPM_O2_FORCE_OFF: SLP Vectorizer -; OLDPM_O2_FORCE_OFF: Optimize scalar/vector ops - -; There should be no difference with the new pass manager. -; This is tested more thoroughly in other test files. - -; NEWPM_O1-LABEL: Running pass: LoopVectorizePass -; NEWPM_O1-NOT: Running pass: SLPVectorizerPass -; NEWPM_O1: Running pass: VectorCombinePass +; SLP does not run at -O1. Loop vectorization runs, but it only +; works on loops explicitly annotated with pragmas. +; O1-LABEL: Running pass: LoopVectorizePass +; O1-NOT: Running pass: SLPVectorizerPass +; O1: Running pass: VectorCombinePass -; NEWPM_O2-LABEL: Running pass: LoopVectorizePass -; NEWPM_O2: Running pass: SLPVectorizerPass -; NEWPM_O2: Running pass: VectorCombinePass +; Everything runs at -O2. +; O2-LABEL: Running pass: LoopVectorizePass +; O2: Running pass: SLPVectorizerPass +; O2: Running pass: VectorCombinePass -; NEWPM_O2_EXTRA-LABEL: Running pass: LoopVectorizePass -; NEWPM_O2_EXTRA: Running pass: EarlyCSEPass -; NEWPM_O2_EXTRA: Running pass: CorrelatedValuePropagationPass -; NEWPM_O2_EXTRA: Running pass: InstCombinePass -; NEWPM_O2_EXTRA: Running pass: LICMPass -; NEWPM_O2_EXTRA: Running pass: SimpleLoopUnswitchPass -; NEWPM_O2_EXTRA: Running pass: SimplifyCFGPass -; NEWPM_O2_EXTRA: Running pass: InstCombinePass -; NEWPM_O2_EXTRA: Running pass: SLPVectorizerPass -; NEWPM_O2_EXTRA: Running pass: EarlyCSEPass -; NEWPM_O2_EXTRA: Running pass: VectorCombinePass +; Optionally run cleanup passes. +; O2_EXTRA-LABEL: Running pass: LoopVectorizePass +; O2_EXTRA: Running pass: EarlyCSEPass +; O2_EXTRA: Running pass: CorrelatedValuePropagationPass +; O2_EXTRA: Running pass: InstCombinePass +; O2_EXTRA: Running pass: LICMPass +; O2_EXTRA: Running pass: SimpleLoopUnswitchPass +; O2_EXTRA: Running pass: SimplifyCFGPass +; O2_EXTRA: Running pass: InstCombinePass +; O2_EXTRA: Running pass: SLPVectorizerPass +; O2_EXTRA: Running pass: EarlyCSEPass +; O2_EXTRA: Running pass: VectorCombinePass define i64 @f(i1 %cond) { entry: diff --git a/llvm/test/Other/optimization-remarks-auto.ll b/llvm/test/Other/optimization-remarks-auto.ll index e544701..438c0ee 100644 --- a/llvm/test/Other/optimization-remarks-auto.ll +++ b/llvm/test/Other/optimization-remarks-auto.ll @@ -2,7 +2,7 @@ ;; ;; new PM ; RUN: rm -f %t.yaml %t.hot.yaml -; RUN: opt < %s --disable-output --enable-new-pm \ +; RUN: opt < %s --disable-output \ ; RUN: --passes='inline' \ ; RUN: --pass-remarks-output=%t.yaml --pass-remarks-filter='inline' \ ; RUN: --pass-remarks-with-hotness @@ -10,14 +10,14 @@ ; RUN: FileCheck %s -check-prefix=YAML-MISS < %t.yaml ;; test 'auto' threshold -; RUN: opt < %s --disable-output --enable-new-pm --inline-enable-cost-benefit-analysis=0 \ +; RUN: opt < %s --disable-output --inline-enable-cost-benefit-analysis=0 \ ; RUN: --passes='module(print-profile-summary,cgscc(inline))' \ ; RUN: --pass-remarks-output=%t.hot.yaml --pass-remarks-filter='inline' \ ; RUN: --pass-remarks-with-hotness --pass-remarks-hotness-threshold=auto 2>&1 | FileCheck %s ; RUN: FileCheck %s -check-prefix=YAML-PASS < %t.hot.yaml ; RUN: not FileCheck %s -check-prefix=YAML-MISS < %t.hot.yaml -; RUN: opt < %s --disable-output --enable-new-pm --inline-enable-cost-benefit-analysis=0 \ +; RUN: opt < %s --disable-output --inline-enable-cost-benefit-analysis=0 \ ; RUN: --passes='module(print-profile-summary,cgscc(inline))' \ ; RUN: --pass-remarks=inline --pass-remarks-missed=inline --pass-remarks-analysis=inline \ ; RUN: --pass-remarks-with-hotness --pass-remarks-hotness-threshold=auto 2>&1 | FileCheck %s -check-prefix=CHECK-RPASS diff --git a/llvm/test/Other/optimize-options.ll b/llvm/test/Other/optimize-options.ll deleted file mode 100644 index ab2fc8f..0000000 --- a/llvm/test/Other/optimize-options.ll +++ /dev/null @@ -1,8 +0,0 @@ -;RUN: opt -enable-new-pm=0 -S -O1 -debug-pass=Arguments %s 2>&1 | FileCheck %s -;RUN: opt -enable-new-pm=0 -S -O2 -debug-pass=Arguments %s 2>&1 | FileCheck %s -;RUN: opt -enable-new-pm=0 -S -Os -debug-pass=Arguments %s 2>&1 | FileCheck %s -;RUN: opt -enable-new-pm=0 -S -Oz -debug-pass=Arguments %s 2>&1 | FileCheck %s -;RUN: opt -enable-new-pm=0 -S -O3 -debug-pass=Arguments %s 2>&1 | FileCheck %s - -; Just check that we get a non-empty set of passes for each -O option. -;CHECK: Pass Arguments: {{.*}} -print-module diff --git a/llvm/test/Other/pass-pipelines.ll b/llvm/test/Other/pass-pipelines.ll deleted file mode 100644 index ef9c4d2..0000000 --- a/llvm/test/Other/pass-pipelines.ll +++ /dev/null @@ -1,118 +0,0 @@ -; Test the particular pass pipelines have the expected structure. This is -; particularly important in order to check that the implicit scheduling of the -; legacy pass manager doesn't introduce unexpected structural changes in the -; pass pipeline. -; -; RUN: opt -enable-new-pm=0 -disable-output -disable-verify -debug-pass=Structure \ -; RUN: -O2 %s 2>&1 \ -; RUN: | FileCheck %s --check-prefix=CHECK-O2 -; RUN: llvm-profdata merge %S/Inputs/pass-pipelines.proftext -o %t.profdata -; RUN: opt -enable-new-pm=0 -disable-output -disable-verify -debug-pass=Structure \ -; RUN: -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' \ -; RUN: -O2 %s 2>&1 \ -; RUN: | FileCheck %s --check-prefix=CHECK-O2 --check-prefix=PGOUSE -; RUN: opt -enable-new-pm=0 -disable-output -disable-verify -debug-pass=Structure \ -; RUN: -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' \ -; RUN: -hot-cold-split \ -; RUN: -O2 %s 2>&1 \ -; RUN: | FileCheck %s --check-prefix=CHECK-O2 --check-prefix=PGOUSE --check-prefix=SPLIT -; -; In the first pipeline there should just be a function pass manager, no other -; pass managers. -; CHECK-O2: Pass Arguments: -; CHECK-O2-NOT: Manager -; CHECK-O2: FunctionPass Manager -; CHECK-O2-NOT: Manager -; -; CHECK-O2: Pass Arguments: -; CHECK-O2: ModulePass Manager -; CHECK-O2-NOT: Manager -; First function pass pipeline just does early opts. -; CHECK-O2-COUNT-3: FunctionPass Manager -; CHECK-O2-NOT: Manager -; FIXME: It's a bit odd to do dead arg elim in the middle of early opts... -; CHECK-O2: Dead Argument Elimination -; CHECK-O2-NEXT: FunctionPass Manager -; CHECK-O2-NOT: Manager -; Very carefully assert the CGSCC pass pipeline as it is fragile and unusually -; susceptible to phase ordering issues. -; CHECK-O2: CallGraph Construction -; PGOUSE: Call Graph SCC Pass Manager -; PGOUSE: Function Integration/Inlining -; PGOUSE: PGOInstrumentationUsePass -; PGOUSE: PGOIndirectCallPromotion -; PGOUSE: CallGraph Construction -; CHECK-O2-NEXT: Globals Alias Analysis -; CHECK-O2-NEXT: Call Graph SCC Pass Manager -; CHECK-O2-NEXT: Remove unused exception handling info -; CHECK-O2-NEXT: Function Integration/Inlining -; CHECK-O2-NEXT: OpenMP specific optimizations -; CHECK-O2-NEXT: Deduce function attributes -; Next up is the main function pass pipeline. It shouldn't be split up and -; should contain the main loop pass pipeline as well. -; CHECK-O2-NEXT: FunctionPass Manager -; CHECK-O2-NOT: Manager -; CHECK-O2: Loop Pass Manager -; CHECK-O2-NOT: Manager -; FIXME: We shouldn't be pulling out to simplifycfg and instcombine and -; causing new loop pass managers. -; CHECK-O2: Simplify the CFG -; CHECK-O2-NOT: Manager -; CHECK-O2: Combine redundant instructions -; CHECK-O2-NOT: Manager -; CHECK-O2: Loop Pass Manager -; CHECK-O2-NOT: Manager -; FIXME: It isn't clear that we need yet another loop pass pipeline -; and run of LICM here. -; CHECK-O2-NOT: Manager -; CHECK-O2: Loop Pass Manager -; CHECK-O2-NEXT: Loop Invariant Code Motion -; CHECK-O2-NOT: Manager -; Next we break out of the main Function passes inside the CGSCC pipeline with -; a barrier pass. -; CHECK-O2: A No-Op Barrier Pass -; CHECK-O2-NEXT: Eliminate Available Externally -; Inferring function attribute should be right after the CGSCC pipeline, before -; any other optimizations/analyses. -; CHECK-O2-NEXT: CallGraph -; CHECK-O2-NEXT: Deduce function attributes in RPO -; CHECK-O2-NOT: Manager -; Reduce the size of the IR ASAP after the inliner. -; CHECK-O2-NEXT: Global Variable Optimizer -; CHECK-O2: Dead Global Elimination -; Next is the late function pass pipeline. -; CHECK-O2: FunctionPass Manager -; CHECK-O2-NOT: Manager -; We rotate loops prior to vectorization. -; CHECK-O2: Loop Pass Manager -; CHECK-O2-NEXT: Rotate Loops -; CHECK-O2-NOT: Manager -; CHECK-O2: Loop Vectorization -; CHECK-O2-NOT: Manager -; CHECK-O2: SLP Vectorizer -; CHECK-O2-NOT: Manager -; After vectorization we do partial unrolling. -; CHECK-O2: Loop Pass Manager -; CHECK-O2-NEXT: Unroll loops -; CHECK-O2-NOT: Manager -; After vectorization and unrolling we try to do any cleanup of inserted code, -; including a run of LICM. This shouldn't run in the same loop pass manager as -; the runtime unrolling though. -; CHECK-O2: Loop Pass Manager -; CHECK-O2-NEXT: Loop Invariant Code Motion -; SPLIT: Hot Cold Splitting -; CHECK-O2: FunctionPass Manager -; CHECK-O2: Loop Pass Manager -; CHECK-O2-NEXT: Loop Sink -; CHECK-O2: Simplify the CFG -; CHECK-O2-NOT: Manager -; -; 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: FunctionPass Manager -; CHECK-O2-NEXT: Dominator Tree Construction - -define void @foo() { - ret void -} diff --git a/llvm/test/Other/pm-pgo-preinline.ll b/llvm/test/Other/pm-pgo-preinline.ll deleted file mode 100644 index bb16f24..0000000 --- a/llvm/test/Other/pm-pgo-preinline.ll +++ /dev/null @@ -1,24 +0,0 @@ -; RUN: opt -disable-verify -enable-new-pm=0 -pgo-kind=pgo-instr-gen-pipeline -mtriple=x86_64-- -Os -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-Osz -; RUN: opt -disable-verify -enable-new-pm=0 -pgo-kind=pgo-instr-gen-pipeline -mtriple=x86_64-- -Oz -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-Osz - - -; CHECK-Osz: CallGraph Construction -; CHECK-Osz-NEXT: Call Graph SCC Pass Manager -; CHECK-Osz-NEXT: Function Integration/Inlining -; CHECK-Osz-NEXT: FunctionPass Manager -; CHECK-Osz-NEXT: Dominator Tree Construction -; CHECK-Osz-NEXT: SROA -; CHECK-Osz-NEXT: Early CSE -; CHECK-Osz-NEXT: Simplify the CFG -; CHECK-Osz-NEXT: Dominator Tree Construction -; CHECK-Osz-NEXT: Basic Alias Analysis (stateless AA impl) -; CHECK-Osz-NEXT: Function Alias Analysis Results -; CHECK-Osz-NEXT: Natural Loop Information -; CHECK-Osz-NEXT: Lazy Branch Probability Analysis -; CHECK-Osz-NEXT: Lazy Block Frequency Analysis -; CHECK-Osz-NEXT: Optimization Remark Emitter -; CHECK-Osz-NEXT: Combine redundant instructions - -define void @foo() { - ret void -} diff --git a/llvm/test/Other/pr49950.ll b/llvm/test/Other/pr49950.ll deleted file mode 100644 index 7a65d26..0000000 --- a/llvm/test/Other/pr49950.ll +++ /dev/null @@ -1,78 +0,0 @@ -; RUN: opt < %s -o /dev/null -enable-new-pm=0 -block-freq -opt-remark-emitter -memoryssa -inject-tli-mappings -pgo-memop-opt -verify-loop-info -debug-pass=Details 2>&1 | FileCheck %s - -; REQUIRES: asserts - -; This is a heavily reduced reproducer for the problem found in -; https://bugs.llvm.org/show_bug.cgi?id=49950 when doing fuzzy -; testing (including non-standard pipelines). -; -; The problem manifested as having a pass structure like this -; when it failed (as given by using -debug-pass=Details): -; -; Target Library Information -; Target Transform Information -; Profile summary info -; Assumption Cache Tracker -; ModulePass Manager -; FunctionPass Manager -; Dominator Tree Construction -; Natural Loop Information -; Post-Dominator Tree Construction -; Branch Probability Analysis -; Block Frequency Analysis -; -- Branch Probability Analysis -; Lazy Branch Probability Analysis -; Lazy Block Frequency Analysis -; Optimization Remark Emitter -; Basic Alias Analysis (stateless AA impl) -; Function Alias Analysis Results -; Memory SSA -; -- Dominator Tree Construction -; -- Function Alias Analysis Results -; -- Basic Alias Analysis (stateless AA impl) -; -- Memory SSA -; Inject TLI Mappings -; -- Inject TLI Mappings -; PGOMemOPSize -; -- Block Frequency Analysis -; -- Post-Dominator Tree Construction -; -- Optimization Remark Emitter -; -- Lazy Branch Probability Analysis -; -- Natural Loop Information -; -- Lazy Block Frequency Analysis -; -- PGOMemOPSize -; Module Verifier -; -- Module Verifier -; -- Target Library Information -; -- Profile summary info -; -- Assumption Cache Tracker -; Bitcode Writer -; -- Bitcode Writer -; -; One might notice that "Dominator Tree Construction" is dropped after -; "Memory SSA", while for example "Natural Loop Information" stick around -; a bit longer. This despite "Dominator Tree Construction" being transitively -; required by "Natural Loop Information". -; The end result was that we got crashes when doing verification of loop -; info after "Inject TLI Mappings" (since the dominator tree had been -; removed too early). - -; Verify that both domintator tree and loop info are kept until after -; PGOMemOPSize: -; -; CHECK: Dominator Tree Construction -; CHECK-NOT: -- Dominator Tree Construction -; CHECK: Memory SSA -; CHECK-NOT: -- Dominator Tree Construction -; CHECK: Inject TLI Mappings -; CHECK-NOT: -- Dominator Tree Construction -; CHECK: PGOMemOPSize -; CHECK-DAG: -- Dominator Tree Construction -; CHECK-DAG: -- Natural Loop Information -; CHECK-DAG: -- PGOMemOPSize -; CHECK: Bitcode Writer - -define void @foo() { -entry: - ret void -} \ No newline at end of file diff --git a/llvm/test/Other/print-cfg-sccs.ll b/llvm/test/Other/print-cfg-sccs.ll deleted file mode 100644 index 6162b2d..0000000 --- a/llvm/test/Other/print-cfg-sccs.ll +++ /dev/null @@ -1,27 +0,0 @@ -; RUN: opt -enable-new-pm=0 -print-cfg-sccs -disable-output < %s 2>&1 | FileCheck %s - -; CHECK: SCCs for Function test in PostOrder: -; CHECK-NEXT: SCC #1 : %exit, -; CHECK-NEXT: SCC #2 : %0, -; CHECK-NEXT: SCC #3 : %3, -; CHECK-NEXT: SCC #4 : %2, %1, -; CHECK-NEXT: SCC #5 : %entry, -define void @test(i1 %cond) { -entry: - br i1 %cond, label %0, label %1 - -0: - br label %exit - -1: - br label %2 - -2: - br i1 %cond, label %1, label %3 - -3: - br label %exit - -exit: - ret void -} diff --git a/llvm/test/Other/print-module-scope.ll b/llvm/test/Other/print-module-scope.ll index c356484..4a0525d 100644 --- a/llvm/test/Other/print-module-scope.ll +++ b/llvm/test/Other/print-module-scope.ll @@ -3,17 +3,14 @@ ; - all the function attributes are shown, including those of declarations ; - works on top of -print-after and -filter-print-funcs ; -; RUN: opt -enable-new-pm=0 < %s 2>&1 -disable-output \ -; RUN: -simplifycfg -print-after=simplifycfg -print-module-scope \ -; RUN: | FileCheck %s -check-prefix=CFG ; RUN: opt < %s 2>&1 -disable-output \ ; RUN: -passes=simplifycfg -print-after-all -print-module-scope \ ; RUN: | FileCheck %s -check-prefix=CFG -; RUN: opt -enable-new-pm=0 < %s 2>&1 -disable-output \ -; RUN: -simplifycfg -print-after=simplifycfg -filter-print-funcs=foo -print-module-scope \ -; RUN: | FileCheck %s -check-prefix=FOO ; RUN: opt < %s 2>&1 -disable-output \ -; RUN: -passes=simplifycfg -print-after-all -filter-print-funcs=foo -print-module-scope \ +; RUN: -passes=simplifycfg -print-after=simplifycfg -print-module-scope \ +; RUN: | FileCheck %s -check-prefix=CFG +; RUN: opt < %s 2>&1 -disable-output \ +; RUN: -passes=simplifycfg -print-after=simplifycfg -filter-print-funcs=foo -print-module-scope \ ; RUN: | FileCheck %s -check-prefix=FOO ; CFG: IR Dump After {{Simplify the CFG|SimplifyCFGPass}} {{.*}}foo diff --git a/llvm/test/Other/printer.ll b/llvm/test/Other/printer.ll index f5fdbfc..d84dd25 100644 --- a/llvm/test/Other/printer.ll +++ b/llvm/test/Other/printer.ll @@ -1,7 +1,5 @@ -; RUN: opt -enable-new-pm=0 -mem2reg -instcombine -print-after-all -disable-output < %s 2>&1 | \ -; RUN: FileCheck --check-prefixes=CHECK,OLDPM %s --implicit-check-not='IR Dump' ; RUN: opt -passes='mem2reg,instcombine' -print-after-all -disable-output < %s 2>&1 | \ -; RUN: FileCheck --check-prefixes=CHECK,NEWPM %s --implicit-check-not='IR Dump' +; RUN: FileCheck %s --implicit-check-not='IR Dump' define void @tester(){ ret void } @@ -10,14 +8,13 @@ define void @foo(){ ret void } -; NEWPM: *** IR Dump After VerifierPass -; CHECK: *** IR Dump After {{Promote Memory to Register|PromotePass}} +; CHECK: *** IR Dump After VerifierPass +; CHECK: *** IR Dump After PromotePass ; CHECK-NEXT: define void @tester -; CHECK: *** IR Dump After {{Combine redundant instructions|InstCombinePass}} +; CHECK: *** IR Dump After InstCombinePass ; CHECK-NEXT: define void @tester -; OLDPM: *** IR Dump After Module Verifier -; CHECK: *** IR Dump After {{Promote Memory to Register|PromotePass}} +; CHECK: *** IR Dump After PromotePass ; CHECK-NEXT: define void @foo -; CHECK: *** IR Dump After {{Combine redundant instructions|InstCombinePass}} +; CHECK: *** IR Dump After InstCombinePass ; CHECK-NEXT: define void @foo -; CHECK: *** IR Dump After {{Module Verifier|VerifierPass}} +; CHECK: *** IR Dump After VerifierPass diff --git a/llvm/test/Other/scc-pass-printer.ll b/llvm/test/Other/scc-pass-printer.ll index 453fbeb..a841716 100644 --- a/llvm/test/Other/scc-pass-printer.ll +++ b/llvm/test/Other/scc-pass-printer.ll @@ -1,25 +1,12 @@ -; RUN: opt -enable-new-pm=0 < %s 2>&1 -disable-output \ -; RUN: -inline -print-after-all | FileCheck %s --check-prefix=LEGACY ; RUN: opt < %s 2>&1 -disable-output \ ; RUN: -passes=inline -print-after-all | FileCheck %s -check-prefix=INL ; RUN: opt < %s 2>&1 -disable-output \ ; RUN: -passes=inliner-wrapper -print-after-all | FileCheck %s -check-prefix=INL -; RUN: opt -enable-new-pm=0 < %s 2>&1 -disable-output \ -; RUN: -inline -print-after-all -print-module-scope | FileCheck %s -check-prefix=LEGACY-MOD ; RUN: opt < %s 2>&1 -disable-output \ ; RUN: -passes=inline -print-after-all -print-module-scope | FileCheck %s -check-prefix=INL-MOD ; RUN: opt < %s 2>&1 -disable-output \ ; RUN: -passes=inliner-wrapper -print-after-all -print-module-scope | FileCheck %s -check-prefix=INL-MOD -; LEGACY: IR Dump After Function Integration/Inlining -; LEGACY: define void @bar() -; LEGACY-NEXT: call void @foo() -; LEGACY: define void @foo() -; LEGACY-NEXT: call void @bar() -; LEGACY: IR Dump After Function Integration/Inlining -; LEGACY: define void @tester() -; LEGACY-NEXT: call void @foo() - ; INL: IR Dump After InlinerPass on (foo, bar) *** ; INL: define void @foo() ; INL-NEXT: call void @bar() @@ -29,12 +16,6 @@ ; INL: define void @tester() ; INL-NEXT: call void @foo() -; LEGACY-MOD: IR Dump After Function Integration/Inlining -; LEGACY-MOD-NEXT: ModuleID = -; LEGACY-MOD: define void @tester() -; LEGACY-MOD: define void @foo() -; LEGACY-MOD: define void @bar() - ; INL-MOD-LABEL:*** IR Dump After InlinerPass on (foo, bar) *** ; INL-MOD-NEXT: ModuleID = ; INL-MOD-NEXT: source_filename = diff --git a/llvm/test/Other/size-remarks.ll b/llvm/test/Other/size-remarks.ll deleted file mode 100644 index 278a9aa..0000000 --- a/llvm/test/Other/size-remarks.ll +++ /dev/null @@ -1,281 +0,0 @@ -; Ensure that IR count remarks in the legacy pass manager work. -; What this test should check for: -; * Positive, nonzero sizes before/after for whole-module remarks -; (It's okay to have nonzero sizes in per-function remarks, since a function -; can be created/destroyed by a pass.) -; * 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 -enable-new-pm=0 < %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: :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-NEXT: remark: :0:0: Function Integration/Inlining: -; CGSCC-SAME: Function: bar: IR instruction count changed from -; CGSCC-SAME: [[ORIGFN:[1-9][0-9]*]] to [[FINALFN:[0-9][0-9]*]]; -; CGSCC-SAME: Delta: [[DELTAFN:-?[1-9][0-9]*]] -; CGSCC-NEXT: --- -; CGSCC-DAG: !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]]' -; CGSCC-DAG: --- !Analysis -; CGSCC-NEXT: Pass: size-info -; CGSCC-NEXT: Name: FunctionIRSizeChange -; CGSCC-NEXT: Function: -; CGSCC-NEXT: Args: -; CGSCC-NEXT: - Pass: 'Function Integration/Inlining' -; CGSCC-NEXT: - String: ': Function: ' -; CGSCC-NEXT: - Function: bar -; CGSCC-NEXT: - String: ': IR instruction count changed from ' -; CGSCC-NEXT: - IRInstrsBefore: '[[ORIGFN]]' -; CGSCC-NEXT: - String: ' to ' -; CGSCC-NEXT: - IRInstrsAfter: '[[FINALFN]]' -; CGSCC-NEXT: - String: '; Delta: ' -; CGSCC-NEXT: - DeltaInstrCount: '[[DELTAFN]]' -; CGSCC-NEXT: ... - -; RUN: opt -enable-new-pm=0 < %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: :0:0: Combine redundant instructions: -; FUNC-SAME: IR instruction count changed from -; FUNC-SAME: [[SIZE1:[1-9][0-9]*]] to [[SIZE2:[0-9][0-9]*]]; -; FUNC-SAME: Delta: [[DELTA1:-?[1-9][0-9]*]] -; FUNC-NEXT: remark: :0:0: Combine redundant instructions: Function: -; FUNC-SAME: foo: IR instruction count changed from -; FUNC-SAME: [[FOOSIZE1:[1-9][0-9]*]] to [[FOOSIZE2:[0-9][0-9]*]]; -; FUNC-SAME: Delta: [[DELTAFOO:-?[1-9][0-9]*]] -; FUNC-NEXT: remark: :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-NEXT: remark: :0:0: Combine redundant instructions: Function: -; FUNC-SAME: bar: IR instruction count changed from -; FUNC-SAME: [[BARSIZE1:[1-9][0-9]*]] to [[BARSIZE2:[0-9][0-9]*]]; -; FUNC-SAME: Delta: [[DELTABAR:-?[1-9][0-9]*]] -; FUNC-NEXT: --- -; FUNC-DAG: !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-DAG: --- !Analysis -; FUNC-NEXT: Pass: size-info -; FUNC-NEXT: Name: FunctionIRSizeChange -; FUNC-NEXT: Function: -; FUNC-NEXT: Args: -; FUNC-NEXT: - Pass: Combine redundant instructions -; FUNC-NEXT: - String: ': Function: ' -; FUNC-NEXT: - Function: foo -; FUNC-NEXT: - String: ': IR instruction count changed from ' -; FUNC-NEXT: - IRInstrsBefore: '[[FOOSIZE1]]' -; FUNC-NEXT: - String: ' to ' -; FUNC-NEXT: - IRInstrsAfter: '[[FOOSIZE2]]' -; FUNC-NEXT: - String: '; Delta: ' -; FUNC-NEXT: - DeltaInstrCount: '[[DELTAFOO]]' -; 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]]' -; FUNC-DAG: --- !Analysis -; FUNC-NEXT: Pass: size-info -; FUNC-NEXT: Name: FunctionIRSizeChange -; FUNC-NEXT: Function: -; FUNC-NEXT: Args: -; FUNC-NEXT: - Pass: Combine redundant instructions -; FUNC-NEXT: - String: ': Function: ' -; FUNC-NEXT: - Function: bar -; FUNC-NEXT: - String: ': IR instruction count changed from ' -; FUNC-NEXT: - IRInstrsBefore: '[[BARSIZE1]]' -; FUNC-NEXT: - String: ' to ' -; FUNC-NEXT: - IRInstrsAfter: '[[BARSIZE2]]' -; FUNC-NEXT: - String: '; Delta: ' -; FUNC-NEXT: - DeltaInstrCount: '[[DELTABAR]]' - -; RUN: opt -enable-new-pm=0 < %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-NEXT: remark: -; MODULE-SAME: Dead Global Elimination: Function: pluto: -; MODULE-SAME: IR instruction count changed from [[ORIGFN:[1-9][0-9]*]] to -; MODULE-SAME: [[FINALFN:[0-9][0-9]*]]; Delta: [[DELTAFN:-?[1-9][0-9]*]] -; MODULE-NEXT: --- -; MODULE-DAG: !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]]' -; MODULE-DAG: --- !Analysis -; MODULE-NEXT: Pass: size-info -; MODULE-NEXT: Name: FunctionIRSizeChange -; MODULE-NEXT: Function: -; MODULE-NEXT: Args: -; MODULE-NEXT: - Pass: Dead Global Elimination -; MODULE-NEXT: - String: ': Function: ' -; MODULE-NEXT: - Function: pluto -; MODULE-NEXT: - String: ': IR instruction count changed from ' -; MODULE-NEXT: - IRInstrsBefore: '[[ORIGFN]]' -; MODULE-NEXT: - String: ' to ' -; MODULE-NEXT: - IRInstrsAfter: '[[FINALFN]]' -; MODULE-NEXT: - String: '; Delta: ' -; MODULE-NEXT: - DeltaInstrCount: '[[DELTAFN]]' - -; RUN: opt -enable-new-pm=0 < %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: :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-NEXT: remark: :0:0: Dead Code Elimination: Function: bar: -; BB-SAME: IR instruction count changed from [[ORIGFN:[1-9][0-9]*]] to -; BB-SAME: [[FINALFN:[0-9][0-9]*]]; Delta: [[DELTAFN:-?[1-9][0-9]*]] -; BB-NEXT: --- -; BB-DAG: !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]]' -; BB-DAG: --- !Analysis -; BB-NEXT: Pass: size-info -; BB-NEXT: Name: FunctionIRSizeChange -; BB-NEXT: Function: -; BB-NEXT: Args: -; BB-NEXT: - Pass: Dead Code Elimination -; BB-NEXT: - String: ': Function: ' -; BB-NEXT: - Function: bar -; BB-NEXT: - String: ': IR instruction count changed from ' -; BB-NEXT: - IRInstrsBefore: '[[ORIGFN]]' -; BB-NEXT: - String: ' to ' -; BB-NEXT: - IRInstrsAfter: '[[FINALFN]]' -; BB-NEXT: - String: '; Delta: ' -; BB-NEXT: - DeltaInstrCount: '[[DELTAFN]]' - -; RUN: opt -enable-new-pm=0 < %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: :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-NEXT: remark: :0:0: Unroll loops: Function: bar: -; LOOP-SAME: IR instruction count changed from [[ORIGFN:[1-9][0-9]*]] -; LOOP-SAME: to [[FINALFN:[0-9][0-9]*]]; -; Since bar is the only function containing a loop, its delta must be identical -; to the whole module remark's delta. -; LOOP-SAME: Delta: [[DELTA]] -; LOOP-NEXT: --- -; LOOP-DAG: !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]]' -; LOOP-DAG: --- !Analysis -; LOOP-NEXT: Pass: size-info -; LOOP-NEXT: Name: FunctionIRSizeChange -; LOOP-NEXT: Function: -; LOOP-NEXT: Args: -; LOOP-NEXT: - Pass: Unroll loops -; LOOP-NEXT: - String: ': Function: ' -; LOOP-NEXT: - Function: bar -; LOOP-NEXT: - String: ': IR instruction count changed from ' -; LOOP-NEXT: - IRInstrsBefore: '[[ORIGFN]]' -; LOOP-NEXT: - String: ' to ' -; LOOP-NEXT: - IRInstrsAfter: '[[FINALFN]]' -; 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/llvm/test/Other/statistic.ll b/llvm/test/Other/statistic.ll index 66dd1f0..fb51596 100644 --- a/llvm/test/Other/statistic.ll +++ b/llvm/test/Other/statistic.ll @@ -1,16 +1,11 @@ ; RUN: opt < %s -o /dev/null -instsimplify -stats -stats-json 2>&1 | FileCheck %s --check-prefix=JSON ; RUN: opt < %s -o /dev/null -instsimplify -stats -stats-json -info-output-file %t && FileCheck %s < %t --check-prefix=JSON -; RUN: opt < %s -o /dev/null -instsimplify -stats -stats-json -time-passes -enable-new-pm=0 2>&1 | FileCheck %s --check-prefixes=JSON,JSONTIME -; RUN: opt < %s -o /dev/null -instsimplify -stats -stats-json -time-passes -info-output-file %t -enable-new-pm=0 && FileCheck %s < %t --check-prefixes=JSON,JSONTIME ; RUN: opt < %s -o /dev/null -instsimplify -stats 2>&1 | FileCheck %s --check-prefix=DEFAULT ; RUN: opt < %s -o /dev/null -instsimplify -stats -info-output-file %t && FileCheck %s < %t --check-prefix=DEFAULT ; REQUIRES: asserts ; JSON: { ; JSON-DAG: "instsimplify.NumSimplified": 1 -; 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 diff --git a/llvm/test/Other/time-passes.ll b/llvm/test/Other/time-passes.ll index 8032ce5..852c583 100644 --- a/llvm/test/Other/time-passes.ll +++ b/llvm/test/Other/time-passes.ll @@ -1,75 +1,57 @@ -; RUN: opt -enable-new-pm=0 < %s -disable-output -instcombine -instcombine -licm -time-passes 2>&1 | FileCheck %s --check-prefix=TIME --check-prefix=TIME-LEGACY -; RUN: opt -enable-new-pm=0 < %s -disable-output -instcombine -instcombine -licm -licm -time-passes 2>&1 | FileCheck %s --check-prefix=TIME --check-prefix=TIME-LEGACY --check-prefix=TIME-DOUBLE-LICM-LEGACY ; RUN: opt < %s -disable-output -passes='default' -time-passes 2>&1 | FileCheck %s --check-prefix=TIME ; ; For new pass manager, check that -time-passes-per-run emit one report for each pass run. -; RUN: opt < %s -disable-output -passes='instcombine,instcombine,loop-mssa(licm)' -time-passes-per-run 2>&1 | FileCheck %s --check-prefix=TIME --check-prefix=TIME-NEW -; RUN: opt < %s -disable-output -passes='instcombine,loop-mssa(licm),instcombine,loop-mssa(licm)' -time-passes-per-run 2>&1 | FileCheck %s --check-prefix=TIME --check-prefix=TIME-NEW -check-prefix=TIME-DOUBLE-LICM-NEW +; RUN: opt < %s -disable-output -passes='instcombine,instcombine,loop-mssa(licm)' -time-passes-per-run 2>&1 | FileCheck %s --check-prefix=TIME --check-prefix=TIME-PER-RUN +; RUN: opt < %s -disable-output -passes='instcombine,loop-mssa(licm),instcombine,loop-mssa(licm)' -time-passes-per-run 2>&1 | FileCheck %s --check-prefix=TIME --check-prefix=TIME-PER-RUN -check-prefix=TIME-DOUBLE-LICM ; ; For new pass manager, check that -time-passes emit one report for each pass. -; RUN: opt < %s -disable-output -passes='instcombine,instcombine,loop-mssa(licm)' -time-passes 2>&1 | FileCheck %s --check-prefixes=TIME,TIME-NEW-PER-PASS -; RUN: opt < %s -disable-output -passes='instcombine,loop-mssa(licm),instcombine,loop-mssa(licm)' -time-passes 2>&1 | FileCheck %s --check-prefixes=TIME,TIME-NEW-PER-PASS +; RUN: opt < %s -disable-output -passes='instcombine,instcombine,loop-mssa(licm)' -time-passes 2>&1 | FileCheck %s --check-prefixes=TIME,TIME-PER-PASS +; RUN: opt < %s -disable-output -passes='instcombine,loop-mssa(licm),instcombine,loop-mssa(licm)' -time-passes 2>&1 | FileCheck %s --check-prefixes=TIME,TIME-PER-PASS ; -; The following 4 test runs verify -info-output-file interaction (default goes to stderr, '-' goes to stdout). -; RUN: opt -enable-new-pm=0 < %s -disable-output -O2 -time-passes -info-output-file='-' 2>/dev/null | FileCheck %s --check-prefix=TIME +; The following 2 test runs verify -info-output-file interaction (default goes to stderr, '-' goes to stdout). ; RUN: opt < %s -disable-output -passes='default' -time-passes -info-output-file='-' 2>/dev/null | FileCheck %s --check-prefix=TIME ; -; RUN: rm -f %t; opt < %s -disable-output -O2 -time-passes -info-output-file=%t -; RUN: cat %t | FileCheck %s --check-prefix=TIME -; ; RUN: rm -f %t; opt < %s -disable-output -passes='default' -time-passes -info-output-file=%t ; RUN: cat %t | FileCheck %s --check-prefix=TIME ; ; TIME: Pass execution timing report ; TIME: Total Execution Time: ; TIME: Name -; TIME-LEGACY-DAG: Combine redundant instructions{{$}} -; TIME-LEGACY-DAG: Combine redundant instructions #2 -; TIME-LEGACY-DAG: Loop Invariant Code Motion{{$}} -; TIME-DOUBLE-LICM-LEGACY-DAG: Loop Invariant Code Motion #2 -; TIME-LEGACY-DAG: Scalar Evolution Analysis -; TIME-LEGACY-DAG: Loop-Closed SSA Form Pass -; TIME-LEGACY-DAG: LCSSA Verifier -; TIME-LEGACY-DAG: Canonicalize natural loops -; TIME-LEGACY-DAG: Natural Loop Information -; TIME-LEGACY-DAG: Dominator Tree Construction -; TIME-LEGACY-DAG: Module Verifier -; TIME-LEGACY-DAG: Target Library Information -; TIME-NEW-DAG: InstCombinePass #1 -; TIME-NEW-DAG: InstCombinePass #2 -; TIME-NEW-DAG: InstCombinePass #3 -; TIME-NEW-DAG: InstCombinePass #4 -; TIME-NEW-DAG: LICMPass #1 -; TIME-NEW-DAG: LICMPass #2 -; TIME-NEW-DAG: LICMPass #3 -; TIME-DOUBLE-LICM-NEW-DAG: LICMPass #4 -; TIME-DOUBLE-LICM-NEW-DAG: LICMPass #5 -; TIME-DOUBLE-LICM-NEW-DAG: LICMPass #6 -; TIME-NEW-DAG: LCSSAPass -; TIME-NEW-DAG: LoopSimplifyPass -; TIME-NEW-DAG: ScalarEvolutionAnalysis -; TIME-NEW-DAG: LoopAnalysis -; TIME-NEW-DAG: VerifierPass -; TIME-NEW-DAG: DominatorTreeAnalysis -; TIME-NEW-DAG: TargetLibraryAnalysis -; TIME-NEW-PER-PASS-DAG: InstCombinePass -; TIME-NEW-PER-PASS-DAG: LICMPass -; TIME-NEW-PER-PASS-DAG: LCSSAPass -; TIME-NEW-PER-PASS-DAG: LoopSimplifyPass -; TIME-NEW-PER-PASS-DAG: ScalarEvolutionAnalysis -; TIME-NEW-PER-PASS-DAG: LoopAnalysis -; TIME-NEW-PER-PASS-DAG: VerifierPass -; TIME-NEW-PER-PASS-DAG: DominatorTreeAnalysis -; TIME-NEW-PER-PASS-DAG: TargetLibraryAnalysis -; TIME-NEW-PER-PASS-NOT: InstCombinePass # -; TIME-NEW-PER-PASS-NOT: LICMPass # -; TIME-NEW-PER-PASS-NOT: LCSSAPass # -; TIME-NEW-PER-PASS-NOT: LoopSimplifyPass # -; TIME-NEW-PER-PASS-NOT: ScalarEvolutionAnalysis # -; TIME-NEW-PER-PASS-NOT: LoopAnalysis # -; TIME-NEW-PER-PASS-NOT: VerifierPass # -; TIME-NEW-PER-PASS-NOT: DominatorTreeAnalysis # -; TIME-NEW-PER-PASS-NOT: TargetLibraryAnalysis # +; TIME-PER-RUN-DAG: InstCombinePass #1 +; TIME-PER-RUN-DAG: InstCombinePass #2 +; TIME-PER-RUN-DAG: InstCombinePass #3 +; TIME-PER-RUN-DAG: InstCombinePass #4 +; TIME-PER-RUN-DAG: LICMPass #1 +; TIME-PER-RUN-DAG: LICMPass #2 +; TIME-PER-RUN-DAG: LICMPass #3 +; TIME-DOUBLE-LICM-DAG: LICMPass #4 +; TIME-DOUBLE-LICM-DAG: LICMPass #5 +; TIME-DOUBLE-LICM-DAG: LICMPass #6 +; TIME-PER_RUN-DAG: LCSSAPass +; TIME-PER_RUN-DAG: LoopSimplifyPass +; TIME-PER_RUN-DAG: ScalarEvolutionAnalysis +; TIME-PER_RUN-DAG: LoopAnalysis +; TIME-PER_RUN-DAG: VerifierPass +; TIME-PER_RUN-DAG: DominatorTreeAnalysis +; TIME-PER_RUN-DAG: TargetLibraryAnalysis +; TIME-PER-PASS-DAG: InstCombinePass +; TIME-PER-PASS-DAG: LICMPass +; TIME-PER-PASS-DAG: LCSSAPass +; TIME-PER-PASS-DAG: LoopSimplifyPass +; TIME-PER-PASS-DAG: ScalarEvolutionAnalysis +; TIME-PER-PASS-DAG: LoopAnalysis +; TIME-PER-PASS-DAG: VerifierPass +; TIME-PER-PASS-DAG: DominatorTreeAnalysis +; TIME-PER-PASS-DAG: TargetLibraryAnalysis +; TIME-PER-PASS-NOT: InstCombinePass # +; TIME-PER-PASS-NOT: LICMPass # +; TIME-PER-PASS-NOT: LCSSAPass # +; TIME-PER-PASS-NOT: LoopSimplifyPass # +; TIME-PER-PASS-NOT: ScalarEvolutionAnalysis # +; TIME-PER-PASS-NOT: LoopAnalysis # +; TIME-PER-PASS-NOT: VerifierPass # +; TIME-PER-PASS-NOT: DominatorTreeAnalysis # +; TIME-PER-PASS-NOT: TargetLibraryAnalysis # ; TIME: Total{{$}} define i32 @foo() { -- 2.7.4