[test] Remove legacy PM tests in llvm/test/Other

[MaskRay]

One nit

llvm/test/Other/heat-colors-graphs.ll

4–6

[[#%x,]]

[aeubanks]

address comment

llvm/test/Other/2002-01-31-CallGraph.ll

 ;  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
 ;
 
         %FunTy = type i32 (i32)
 
 define void @invoke(%FunTy* %x) {
         %foo = call i32 %x( i32 123 )           ; <i32> [#uses=0]
         ret void
 }
 
 

llvm/test/Other/2007-06-05-PassID.ll

-;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
-}
-

llvm/test/Other/2007-06-28-PassManager.ll

-; 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
-}

llvm/test/Other/2009-03-31-CallGraph.ll

-; 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(...)

llvm/test/Other/constant-fold-gep.ll

 ; "PLAIN" - No optimizations. This tests the default target layout
 ; constant folder.
 ; RUN: opt -S -o - < %s | FileCheck --check-prefix=PLAIN %s
 
 ; "OPT" - Optimizations but no targetdata. This tests default target layout
 ; folding in the optimizers.
 ; RUN: opt -S -o - -instcombine -globalopt < %s | FileCheck --check-prefix=OPT %s
 
 ; "TO" - Optimizations and targetdata. This tests target-dependent
 ; folding in the optimizers.
 ; 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
 
 
 ; The automatic constant folder in opt does not have targetdata access, so
 ; it can't fold gep arithmetic, in general. However, the constant folder run
 ; from instcombine and global opt can use targetdata.
 
 ; PLAIN: @G8 = global i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -1)

llvm/test/Other/cspgo-O2-pipeline.ll

-; 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

llvm/test/Other/debug-pass-npm.ll

-; 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

llvm/test/Other/heat-colors-graphs.ll

 ; 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:
   %check = icmp sgt i32 %0, 0
   br i1 %check, label %if, label %exit, !prof !0
 
 if:                     ; preds = %entry
   br label %exit
 exit:                   ; preds = %entry, %if
   ret void
 }
 
 !0 = !{!"branch_weights", i32 1, i32 200}

llvm/test/Other/heat-colors-multigraph.ll

-; 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
-}

llvm/test/Other/loop-pass-printer.ll

 ; This test checks -print-after/before on loop passes
 ; 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
 
 ; DEL:      IR Dump Before {{Delete dead loops|LoopDeletionPass}}
 ; DEL:      ; Preheader:
 ; DEL-NEXT:  %idx = alloca i32, align 4
 ; DEL:      ; Loop:

 
 ; BAR:      IR Dump After {{Unroll|LoopFullUnrollPass}}
 ; BAR:      ; Preheader:
 ; BAR-NEXT:  br label %loop
 ; BAR:      ; Loop:
 ; 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
   store i32 0, i32* %idx, align 4
   br label %loop
 
 loop:
   %1 = load i32, i32* %idx, align 4

llvm/test/Other/opt-LTO-pipeline.ll

-; 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
-}

llvm/test/Other/opt-O0-pipeline-enable-matrix.ll

-; 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
-}

llvm/test/Other/opt-O0-pipeline.ll

-; 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
-}

llvm/test/Other/opt-O2-pipeline.ll

-; 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
-}

llvm/test/Other/opt-O3-pipeline-enable-matrix.ll

-; 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
-}

llvm/test/Other/opt-O3-pipeline.ll

-; 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
-}

llvm/test/Other/opt-Os-pipeline.ll

-; 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
-}

llvm/test/Other/opt-bisect-legacy-pass-manager.ll

-; This file verifies the behavior of the OptBisect class, which is used to
-; diagnose optimization related failures.  The tests check various
-; invocations that result in different sets of optimization passes that
-; are run in different ways.
-;
-; This set of tests exercises the legacy pass manager interface to the OptBisect
-; class.  Because the exact set of optimizations that will be run may
-; change over time, these tests are written in a more general manner than the
-; corresponding tests for the new pass manager.
-;
-; Don't use NEXT checks or hard-code pass numbering so that this won't fail if
-; new passes are inserted.
-
-
-; Verify that the file can be compiled to an object file at -O3 with all
-; skippable passes skipped.
-
-; REQUIRES: default_triple
-; RUN: opt -O3 -opt-bisect-limit=0 -enable-new-pm=0 < %s | llc -O3 -opt-bisect-limit=0
-
-
-; Verify that no skippable passes are run with -opt-bisect-limit=0.
-
-; RUN: opt -disable-output -disable-verify -O3 -opt-bisect-limit=0 %s -enable-new-pm=0 2>&1 \
-; RUN:     | FileCheck %s --check-prefix=CHECK-SKIP-ALL
-; CHECK-SKIP-ALL: BISECT: NOT running pass ({{[0-9]+}})
-; CHECK-SKIP-ALL-NOT: BISECT: running pass ({{[0-9]+}})
-
-
-; Verify that no passes run at -O0 are skipped
-; RUN: opt -opt-bisect-limit=0 < %s 2>&1 -enable-new-pm=0 | FileCheck %s --check-prefix=OPTBISECT-O0
-; OPTBISECT-O0-NOT: BISECT: NOT running
-
-; FIXME: There are still some AMDGPU passes being skipped that run at -O0.
-; XFAIL: r600, amdgcn
-
-; Verify that we can use the opt-bisect-helper.py script (derived from
-; utils/bisect) to locate the optimization that inlines the call to
-; f2() in f3().
-
-; RUN: %python %S/opt-bisect-helper.py --start=0 --end=256 --optcmd=opt \
-; RUN:         --filecheckcmd=FileCheck --test=%s \
-; RUN:         --prefix=CHECK-BISECT-INLINE-HELPER \
-; RUN:         | FileCheck %s --check-prefix=CHECK-BISECT-INLINE-RESULT
-; The helper script uses this to find the optimization that inlines the call.
-; CHECK-BISECT-INLINE-HELPER: call i32 @f2()
-; These checks verifies that the optimization was found.
-; CHECK-BISECT-INLINE-RESULT-NOT: Last good count: 0
-; CHECK-BISECT-INLINE-RESULT: Last good count: {{[0-9]+}}
-
-
-; Test a module pass.
-
-; RUN: opt -disable-output -disable-verify -deadargelim -opt-bisect-limit=-1 %s -enable-new-pm=0 \
-; RUN:     2>&1 | FileCheck %s --check-prefix=CHECK-DEADARG
-; CHECK-DEADARG: BISECT: running pass ({{[0-9]+}}) Dead Argument Elimination on module
-
-; RUN: opt -disable-output -disable-verify -deadargelim -opt-bisect-limit=0 %s -enable-new-pm=0 \
-; RUN:     2>&1 | FileCheck %s --check-prefix=CHECK-NOT-DEADARG
-; CHECK-NOT-DEADARG: BISECT: NOT running pass ({{[0-9]+}}) Dead Argument Elimination on module
-
-
-; Test an SCC pass.
-
-; RUN: opt -disable-output -disable-verify -inline -opt-bisect-limit=-1 %s -enable-new-pm=0 \
-; RUN:     2>&1 | FileCheck %s --check-prefix=CHECK-INLINE
-; CHECK-INLINE: BISECT: running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (<<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)
-

llvm/test/Other/opt-hot-cold-split.ll

-; 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
 ; RUN: opt -mtriple=x86_64-- -hot-cold-split=true -passes='thinlto<Os>' -debug-pass-manager < %s -o /dev/null 2>&1 | FileCheck %s -check-prefix=THINLTO-POSTLINK-Os
 
 ; REQUIRES: asserts
 
 ; Splitting should occur late.
 
-; DEFAULT-Os: Hot Cold Splitting
-; DEFAULT-Os: Simplify the CFG
+; DEFAULT-Os: pass: HotColdSplittingPass
 
 ; LTO-PRELINK-Os-NOT: pass: HotColdSplittingPass
 
 ; THINLTO-PRELINK-Os-NOT: Running pass: HotColdSplittingPass
 
 ; LTO-POSTLINK-Os: HotColdSplitting
 ; THINLTO-POSTLINK-Os: HotColdSplitting

llvm/test/Other/opt-npm.ll

-; RUN: opt -dce -enable-new-pm -disable-output -debug-pass-manager %s 2>&1 | FileCheck %s
-
-; CHECK: DCEPass
-define void @foo() {
-    ret void
-}

llvm/test/Other/opt-pipeline-vector-passes.ll

-; 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
 
+; The loop vectorizer still runs at both -O1/-O2 even with the
+; debug flag, but it only works on loops explicitly annotated
+; with pragmas.
+
 ; 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
+; O1-LABEL:  Running pass: LoopVectorizePass
+; O1-NOT:    Running pass: SLPVectorizerPass
+; O1:        Running pass: VectorCombinePass
 
 ; Everything runs at -O2.
-
-; OLDPM_O2-LABEL:  Pass Arguments:
-; OLDPM_O2:        Loop Vectorization
-; OLDPM_O2:        SLP Vectorizer
-; OLDPM_O2:        Optimize scalar/vector ops
+; O2-LABEL:  Running pass: LoopVectorizePass
+; O2:        Running pass: SLPVectorizerPass
+; O2:        Running pass: VectorCombinePass
 
 ; Optionally run cleanup passes.
-
-; OLDPM_O2_EXTRA-LABEL:  Pass Arguments:
-; OLDPM_O2_EXTRA:        Loop Vectorization
-; OLDPM_O2_EXTRA:        Early CSE
-; OLDPM_O2_EXTRA:        Value Propagation
-; OLDPM_O2_EXTRA:        Combine redundant instructions
-; OLDPM_O2_EXTRA:        Loop Invariant Code Motion
-; OLDPM_O2_EXTRA:        Unswitch loops
-; OLDPM_O2_EXTRA:        Simplify the CFG
-; OLDPM_O2_EXTRA:        Combine redundant instructions
-; OLDPM_O2_EXTRA:        SLP Vectorizer
-; OLDPM_O2_EXTRA:        Early CSE
-; OLDPM_O2_EXTRA:        Optimize scalar/vector ops
-
-
-; The loop vectorizer still runs at both -O1/-O2 even with the
-; debug flag, but it only works on loops explicitly annotated
-; with pragmas.
-
-; OLDPM_O1_FORCE_OFF-LABEL:  Pass Arguments:
-; OLDPM_O1_FORCE_OFF:        Loop Vectorization
-; OLDPM_O1_FORCE_OFF-NOT:    SLP Vectorizer
-; OLDPM_O1_FORCE_OFF:        Optimize scalar/vector ops
-
-; OLDPM_O2_FORCE_OFF-LABEL:  Pass Arguments:
-; OLDPM_O2_FORCE_OFF:        Loop Vectorization
-; OLDPM_O2_FORCE_OFF:        SLP Vectorizer
-; OLDPM_O2_FORCE_OFF:        Optimize scalar/vector ops
-
-; There should be no difference with the new pass manager.
-; This is tested more thoroughly in other test files.
-
-; NEWPM_O1-LABEL:  Running pass: LoopVectorizePass
-; NEWPM_O1-NOT:    Running pass: SLPVectorizerPass
-; NEWPM_O1:        Running pass: VectorCombinePass
-
-; NEWPM_O2-LABEL:  Running pass: LoopVectorizePass
-; NEWPM_O2:        Running pass: SLPVectorizerPass
-; NEWPM_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
+; 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:
   br label %loop
 
 loop:
   %i = phi i64 [ 0, %entry ], [ %inc, %loop ]
   %inc = add i64 %i, 1
   br i1 %cond, label %loop, label %exit
 
 exit:
   ret i64 %i
 }

llvm/test/Other/optimization-remarks-auto.ll

 ;; This test verifies 'auto' hotness threshold when profile summary is available.
 ;;
 ;; 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
 ; RUN: FileCheck %s -check-prefix=YAML-PASS < %t.yaml
 ; 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
 
 ; YAML-PASS:      --- !Passed
 ; YAML-PASS-NEXT: Pass:            inline
 ; YAML-PASS-NEXT: Name:            Inlined
 ; YAML-PASS-NEXT: Function:        caller1

llvm/test/Other/optimize-options.ll

-;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

llvm/test/Other/pass-pipelines.ll

-; 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
-}

llvm/test/Other/pm-pgo-preinline.ll

-; 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
-}

llvm/test/Other/pr49950.ll

-; 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
-}
 

llvm/test/Other/print-cfg-sccs.ll

-; 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
-}

llvm/test/Other/print-module-scope.ll

 ; This test is checking basic properties of -print-module-scope options:
 ;   - dumps all the module IR at once
 ;   - 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
 ; CFG-NEXT: ModuleID =
 ; CFG: define void @foo
 ; CFG: define void @bar
 ; CFG: declare void @baz
 ; CFG: IR Dump After {{.*}}bar

llvm/test/Other/printer.ll

-; 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
 }
 
 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

llvm/test/Other/scc-pass-printer.ll

-; 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()
 ; INL:      define void @bar()
 ; INL-NEXT:   call void @foo()
 ; INL:      IR Dump After InlinerPass on (tester) ***
 ; 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 =
 ; INL-MOD: define void @tester()
 ; INL-MOD-NEXT:  call void @foo()
 ; INL-MOD: define void @foo()
 ; INL-MOD-NEXT:  call void @bar()
 ; INL-MOD: define void @bar()

llvm/test/Other/size-remarks.ll

-; 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
-}

llvm/test/Other/statistic.ll

 ; 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
 
 define i32 @foo() {
   %res = add i32 5, 4
   ret i32 %res
 }

llvm/test/Other/time-passes.ll

-; 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() {
   %res = add i32 5, 4
   br label %loop1
 loop1:
   br i1 false, label %loop1, label %end
 end: