[llvm] d53a4e7 - [test] Remove legacy PM tests in llvm/test/Other
Arthur Eubanks via llvm-commits
llvm-commits at lists.llvm.org
Thu Sep 2 12:24:23 PDT 2021
Author: Arthur Eubanks
Date: 2021-09-02T12:23:24-07:00
New Revision: d53a4e7b4a879abd2e17a5c380a3bdee27bc87cb
URL: https://github.com/llvm/llvm-project/commit/d53a4e7b4a879abd2e17a5c380a3bdee27bc87cb
DIFF: https://github.com/llvm/llvm-project/commit/d53a4e7b4a879abd2e17a5c380a3bdee27bc87cb.diff
LOG: [test] Remove legacy PM tests in llvm/test/Other
Differential Revision: https://reviews.llvm.org/D109180
Added:
Modified:
llvm/test/Other/2002-01-31-CallGraph.ll
llvm/test/Other/constant-fold-gep.ll
llvm/test/Other/heat-colors-graphs.ll
llvm/test/Other/loop-pass-printer.ll
llvm/test/Other/opt-hot-cold-split.ll
llvm/test/Other/opt-pipeline-vector-passes.ll
llvm/test/Other/optimization-remarks-auto.ll
llvm/test/Other/print-module-scope.ll
llvm/test/Other/printer.ll
llvm/test/Other/scc-pass-printer.ll
llvm/test/Other/statistic.ll
llvm/test/Other/time-passes.ll
Removed:
llvm/test/Other/2007-06-05-PassID.ll
llvm/test/Other/2007-06-28-PassManager.ll
llvm/test/Other/2009-03-31-CallGraph.ll
llvm/test/Other/cspgo-O2-pipeline.ll
llvm/test/Other/debug-pass-npm.ll
llvm/test/Other/heat-colors-multigraph.ll
llvm/test/Other/opt-LTO-pipeline.ll
llvm/test/Other/opt-O0-pipeline-enable-matrix.ll
llvm/test/Other/opt-O0-pipeline.ll
llvm/test/Other/opt-O2-pipeline.ll
llvm/test/Other/opt-O3-pipeline-enable-matrix.ll
llvm/test/Other/opt-O3-pipeline.ll
llvm/test/Other/opt-Os-pipeline.ll
llvm/test/Other/opt-bisect-legacy-pass-manager.ll
llvm/test/Other/opt-npm.ll
llvm/test/Other/optimize-options.ll
llvm/test/Other/pass-pipelines.ll
llvm/test/Other/pm-pgo-preinline.ll
llvm/test/Other/pr49950.ll
llvm/test/Other/print-cfg-sccs.ll
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 52d88688987d3..b2922f8c86c2c 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 b166f0575d5cb..0000000000000
--- 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 c6a69a210bc2b..0000000000000
--- 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 54f2691eed557..0000000000000
--- 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 c09d8d9873922..5901e4f21fc8c 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<scalar-evolution>' < %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 26f2e338cbc8b..0000000000000
--- 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 55c9baa6c5732..0000000000000
--- 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 cf19820c4ff05..cfd1818bb2295 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 4aab4f4ba06c3..0000000000000
--- 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 10870cc57bc3c..98ad72b142bca 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<opt-remark-emit>,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<opt-remark-emit>,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 b96f555cda2dd..0000000000000
--- 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 15784f23740e2..0000000000000
--- 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 c47642e1f0d42..0000000000000
--- 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 542a79820e4f2..0000000000000
--- 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 4c5e126f229fa..0000000000000
--- 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 97b11fec08b9c..0000000000000
--- 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 b65e550ce9ebe..0000000000000
--- 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 8d966deeccd70..0000000000000
--- 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
diff erent sets of optimization passes that
-; are run in
diff erent 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 (<<null function>>)
-; 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 (<<null function>>)
-
-; 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 (<<null function>>)
-; 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 (<<null function>>)
-
-
-; 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 cd01314f1f7e1..21c713d35bb74 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<Os>' -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<Os>' -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<Os>' -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<Os>' -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 0b1e651b41f73..0000000000000
--- 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 7fe57da612b58..af702995d5758 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<O1>' -S %s 2>&1 | FileCheck %s --check-prefixes=NEWPM_O1
-; RUN: opt -disable-verify -debug-pass-manager -passes='default<O2>' -S %s 2>&1 | FileCheck %s --check-prefixes=NEWPM_O2
-; RUN: opt -disable-verify -debug-pass-manager -passes='default<O2>' -extra-vectorizer-passes -S %s 2>&1 | FileCheck %s --check-prefixes=NEWPM_O2_EXTRA
+; RUN: opt -disable-verify -debug-pass-manager -passes='default<O1>' -S %s 2>&1 | FileCheck %s --check-prefixes=O1
+; RUN: opt -disable-verify -debug-pass-manager -passes='default<O2>' -S %s 2>&1 | FileCheck %s --check-prefixes=O2
+; RUN: opt -disable-verify -debug-pass-manager -passes='default<O2>' -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
diff erence 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 e5447012acfe9..438c0ee0b1d7b 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 ab2fc8f75b73b..0000000000000
--- 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 ef9c4d24a772a..0000000000000
--- 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 bb16f248cc516..0000000000000
--- 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 7a65d2670cc07..0000000000000
--- 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 6162b2d38fed5..0000000000000
--- 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 c35648424be5f..4a0525dbb380b 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 f5fdbfc1d7099..d84dd25a843a9 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 453fbeb9e74ad..a841716c16574 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 278a9aab82550..0000000000000
--- 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: <unknown>:0:0: Function Integration/Inlining:
-; CGSCC-SAME: IR instruction count changed from
-; CGSCC-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]];
-; CGSCC-SAME: Delta: [[DELTA:-?[1-9][0-9]*]]
-; CGSCC-NEXT: remark: <unknown>: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: <unknown>: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: <unknown>: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: <unknown>:0:0: Combine redundant instructions:
-; FUNC-SAME: IR instruction count changed from
-; FUNC-SAME: [[SIZE2]] to [[SIZE3:[1-9][0-9]*]];
-; FUNC-SAME: Delta: [[DELTA2:-?[1-9][0-9]*]]
-; FUNC-NEXT: remark: <unknown>: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: <unknown>:0:0: Dead Code Elimination:
-; BB-SAME: IR instruction count changed from
-; BB-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]];
-; BB-SAME: Delta: [[DELTA:-?[1-9][0-9]*]]
-; BB-NEXT: remark: <unknown>: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: <unknown>:0:0: Unroll loops:
-; LOOP-SAME: IR instruction count changed from
-; LOOP-SAME: [[ORIG:[1-9][0-9]*]] to [[FINAL:[1-9][0-9]*]];
-; LOOP-SAME: Delta: [[DELTA:-?[1-9][0-9]*]]
-; LOOP-NEXT: remark: <unknown>: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 66dd1f0bf66b3..fb5159683be67 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 8032ce5fd50df..852c583fddfc5 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<O2>' -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<O2>' -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<O2>' -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() {
More information about the llvm-commits
mailing list