[test][NewPM] Remove RUN lines using -analyze

[aeubanks]

Summary

Only tests in llvm/test/Analysis.

-analyze is legacy PM-specific.

This only touches files with -passes.

I looked through everything and made sure that everything had a new PM equivalent.

[aeubanks]

update

[MaskRay]

If you haven't done so, may be worth checking whether the -analyze -enable-new-pm=0 line may use FileCheck --check-prefix or --check-prefixes differently from the -passes line. If yes, there may be redundant check prefixes which can be cleaned up.

[aeubanks]

remove some redundant --check-prefix

llvm/test/Analysis/BlockFrequencyInfo/bad_input.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 declare void @g(i32 %x)
 
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'branch_weight_0':
 ; CHECK-NEXT: block-frequency-info: branch_weight_0
 define void @branch_weight_0(i32 %a) {
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]

llvm/test/Analysis/BlockFrequencyInfo/basic.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
-; RUN: opt < %s -analyze -lazy-block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 define i32 @test1(i32 %i, i32* %a) {
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'test1':
 ; CHECK-NEXT: block-frequency-info: test1
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
 entry:
   br label %body

llvm/test/Analysis/BlockFrequencyInfo/double_backedge.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 define void @double_backedge(i1 %x) {
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'double_backedge':
 ; CHECK-NEXT: block-frequency-info: double_backedge
 entry:
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
   br label %loop

llvm/test/Analysis/BlockFrequencyInfo/double_exit.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'double_exit':
 ; CHECK-NEXT: block-frequency-info: double_exit
 define i32 @double_exit(i32 %N) {
 ; Mass = 1
 ; Frequency = 1
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]

llvm/test/Analysis/BlockFrequencyInfo/extremely-likely-loop-successor.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 ; PR21622: Check for a crasher when the sum of exits to the same successor of a
 ; loop overflows.
 
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'extremely_likely_loop_successor':
 ; CHECK-NEXT: block-frequency-info: extremely_likely_loop_successor
 define void @extremely_likely_loop_successor() {

llvm/test/Analysis/BlockFrequencyInfo/irreducible.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 ; A loop with multiple exits isn't irreducible.  It should be handled
 ; correctly.
 ;
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'multiexit':
 ; CHECK-NEXT: block-frequency-info: multiexit
 define void @multiexit(i1 %x) {

llvm/test/Analysis/BlockFrequencyInfo/irreducible_loop_crash.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @fn1(i32* %f) {
 entry:
   %tobool7 = icmp eq i32 undef, 0

llvm/test/Analysis/BlockFrequencyInfo/irreducible_pgo.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 ; Function Attrs: noinline norecurse nounwind readnone uwtable
 define i32 @_Z11irreducibleii(i32 %iter_outer, i32 %iter_inner) local_unnamed_addr !prof !27 {
 entry:
   %cmp24 = icmp sgt i32 %iter_outer, 0
   br i1 %cmp24, label %for.body, label %entry.for.cond.cleanup_crit_edge, !prof !28
 

llvm/test/Analysis/BlockFrequencyInfo/loop_with_branch.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'loop_with_branch':
 ; CHECK-NEXT: block-frequency-info: loop_with_branch
 define void @loop_with_branch(i32 %a) {
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
 entry:
   %skip_loop = call i1 @foo0(i32 %a)

llvm/test/Analysis/BlockFrequencyInfo/loop_with_invoke.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'loop_with_invoke':
 ; CHECK-NEXT: block-frequency-info: loop_with_invoke
 define void @loop_with_invoke(i32 %n) personality i8 0 {
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
 entry:
   br label %loop

llvm/test/Analysis/BlockFrequencyInfo/loops_with_profile_info.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 ; This code contains three loops. One is triple-nested, the
 ; second is double nested and the third is a single loop. At
 ; runtime, all three loops execute 1,000,000 times each. We use to
 ; give different frequencies to each of the loops because loop
 ; scales were limited to no more than 4,096.
 ;

llvm/test/Analysis/BlockFrequencyInfo/nested_loop_with_branches.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'nested_loop_with_branches'
 ; CHECK-NEXT: block-frequency-info: nested_loop_with_branches
 define void @nested_loop_with_branches(i32 %a) {
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
 entry:
   %v0 = call i1 @foo0(i32 %a)

llvm/test/Analysis/BlockFrequencyInfo/redundant_edges.ll

-; RUN: opt < %s -analyze -block-freq -enable-new-pm=0 | FileCheck %s
-; RUN: opt < %s -analyze -lazy-block-freq -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
 
 define void @test1() {
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'test1':
 ; CHECK-NEXT: block-frequency-info: test1
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
 entry:
   br label %loop

llvm/test/Analysis/BranchProbabilityInfo/basic.ll

-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
-; RUN: opt < %s -analyze -lazy-branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 define i32 @test1(i32 %i, i32* %a) {
 ; CHECK: Printing analysis {{.*}} for function 'test1'
 entry:
   br label %body
 ; CHECK: edge entry -> body probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 

llvm/test/Analysis/BranchProbabilityInfo/deopt-intrinsic.ll

-; RUN: opt -analyze -branch-prob < %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 declare i32 @llvm.experimental.deoptimize.i32(...)
 
 define i32 @test1(i32 %a, i32 %b) {
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'test1':
 entry:
   %cond = icmp eq i32 %a, 42

llvm/test/Analysis/BranchProbabilityInfo/deopt-invoke.ll

-; RUN: opt -analyze -branch-prob < %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 declare i32* @"personality_function"() #1
 declare void @foo(i32)
 declare void @bar() 
 declare void @llvm.experimental.deoptimize.isVoid(...)
 declare void @cold() cold
 

llvm/test/Analysis/BranchProbabilityInfo/fcmp.ll

-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 ; This function tests the floating point unorder comparison. The probability
 ; of NaN should be extremely small.
 ; CHECK: Printing analysis {{.*}} for function 'uno'
 ; CHECK:  edge  -> a probability is 0x00000800 / 0x80000000 = 0.00%
 ; CHECK:  edge  -> b probability is 0x7ffff800 / 0x80000000 = 100.00% [HOT edge]
 

llvm/test/Analysis/BranchProbabilityInfo/hoist.ll

-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: no_hoist
 ; CHECK: edge entry -> if.end probability is 0x40000000 / 0x80000000 = 50.00%
 ; CHECK: edge entry -> if.then probability is 0x40000000 / 0x80000000 = 50.00%
 ; CHECK: edge if.end -> if.end4 probability is 0x40000000 / 0x80000000 = 50.00%
 ; CHECK: edge if.end -> if.then3 probability is 0x40000000 / 0x80000000 = 50.00%
 define dso_local void @no_hoist(i64 %arg1, i64 %arg2) local_unnamed_addr #0 {

llvm/test/Analysis/BranchProbabilityInfo/libfunc_call.ll

-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
-; RUN: opt < %s -analyze -lazy-branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 declare i32 @strcmp(i8*, i8*)
 declare i32 @strncmp(i8*, i8*, i32)
 declare i32 @strcasecmp(i8*, i8*)
 declare i32 @strncasecmp(i8*, i8*, i32)
 declare i32 @memcmp(i8*, i8*)
 declare i32 @bcmp(i8*, i8*)

llvm/test/Analysis/BranchProbabilityInfo/loop.ll

 ; Test the static branch probability heuristics for no-return functions.
-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' --disable-output 2>&1 | FileCheck %s
 
 declare void @g1()
 declare void @g2()
 declare void @g3()
 declare void @g4()
 declare i32 @g5()
 

llvm/test/Analysis/BranchProbabilityInfo/noreturn.ll

 ; Test the static branch probability heuristics for no-return functions.
-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 declare void @abort() noreturn
 
 define i32 @test1(i32 %a, i32 %b) {
 ; CHECK: Printing analysis {{.*}} for function 'test1'
 entry:
   %cond = icmp eq i32 %a, 42

llvm/test/Analysis/BranchProbabilityInfo/pr18705.ll

-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 ; Since neither of while.body's out-edges is an exit or a back edge,
 ; calcLoopBranchHeuristics should return early without setting the weights.
 ; calcFloatingPointHeuristics, which is run later, sets the weights.
 ;
 ; CHECK: edge while.body -> if.then probability is 0x50000000 / 0x80000000 = 62.50%
 ; CHECK: edge while.body -> if.else probability is 0x30000000 / 0x80000000 = 37.50%

llvm/test/Analysis/BranchProbabilityInfo/pr22718.ll

-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 ; In this test, the else clause is taken about 90% of the time. This was not
 ; reflected in the probability computation because the weight is larger than
 ; the branch weight cap (about 2 billion).
 ;
 ; CHECK: edge for.body -> if.then probability is 0x0cccba45 / 0x80000000 = 10.00%
 ; CHECK: edge for.body -> if.else probability is 0x733345bb / 0x80000000 = 90.00% [HOT edge]

llvm/test/Analysis/BranchProbabilityInfo/switch.ll

-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
-; RUN: opt < %s -analyze -lazy-branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 declare void @g(i32)
 
 ; Check correctness of reported probabilities in case of multiple edges between
 ; basic blocks. In this case sum of probabilities over all edges should be
 ; returned by BranchProbabilityInfo::getEdgeProbability.
 

llvm/test/Analysis/BranchProbabilityInfo/unreachable.ll

-; RUN: opt -analyze -branch-prob < %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 declare void @bar() cold
 
 ; Both 'l1' and 'r1' has one edge leading to 'cold' and another one to
 ; 'unreachable' blocks. Check that 'cold' paths are preferred. Also ensure both
 ; paths from 'entry' block are equal.
 define void @test1(i32 %0) {

llvm/test/Analysis/BranchProbabilityInfo/zero_heuristics.ll

-; RUN: opt < %s -analyze -branch-prob -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
 
 @A = global i32 0, align 4
 @B = global i32 0, align 4
 
 ; CHECK-LABEL: eq_opaque_minus_one
 define void @eq_opaque_minus_one(i32* %base) {
 entry:

llvm/test/Analysis/Delinearization/a.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 ;
 ; void foo(long n, long m, long o, int A[n][m][o]) {
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[2*i+3][3*j-4][5*k+7] = 1;
 ; }

llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll

-; RUN: opt -delinearize -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='print<delinearization>' -disable-output < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; CHECK:      Inst:  %tmp = load float, float* %arrayidx, align 4
 ; CHECK-NEXT: In Loop with Header: for.inc
 ; CHECK-NEXT: AccessFunction: {(4 * %N * %call),+,4}<nsw><%for.inc>
 ; CHECK-NEXT: Base offset: %A

llvm/test/Analysis/Delinearization/divide_by_one.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32"
 
 ; Check that division by 1 can be delinearized.
 ;
 ; void test1(unsigned char *dst, int stride, int bs) {
 ;   for (int r = bs; r >= 0; --r)

llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll

-; RUN: opt < %s -basic-aa -da -analyze -enable-new-pm=0 -delinearize
 ; RUN: opt < %s -aa-pipeline=basic-aa -passes='require<da>,print<delinearization>' -disable-output
 ;
 ; a, b, c, d, g, h;
 ; char *f;
 ; static fn1(p1) {
 ;   char *e = p1;
 ;   for (; d;) {
 ;     a = 0;

llvm/test/Analysis/Delinearization/himeno_1.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; #define MR(mt,n,r,c,d)  mt->m[(n) * mt->mrows * mt->mcols * mt->mdeps + (r) * mt->mcols* mt->mdeps + (c) * mt->mdeps + (d)]
 ;
 ; struct Mat {
 ;   float* m;
 ;   int mnums;
 ;   int mrows;

llvm/test/Analysis/Delinearization/himeno_2.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; #define MR(mt,n,r,c,d)  mt->m[(n) * mt->mrows * mt->mcols * mt->mdeps + (r) * mt->mcols* mt->mdeps + (c) * mt->mdeps + (d)]
 ;
 ; struct Mat {
 ;   float* m;
 ;   int mnums;
 ;   int mrows;

llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; Derived from the following code:
 ;
 ; void foo(long n, long m, long b, double A[n][m]) {
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       A[2i+b][2j] = 1.0;

llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize  | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output  2>&1 | FileCheck %s
 
 ; void foo(long n, long m, long o, double A[n][m][o]) {
 ;
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[i+3][j-4][k+7] = 1.0;

llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; void foo(long n, long m, long o, long p, double A[n][m][o+p]) {
 ;
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[i+3][j-4][k+7] = 1.0;

llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) {
 ;
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[i+p][j+q][k+r] = 1.0;

llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; Derived from the following code:
 ;
 ; void foo(long n, long m, double A[n][m]) {
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       A[i][j] = 1.0;

llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 ; XFAIL: *
 ; We do not recognize anymore variable size arrays.
 
 ; extern void bar(long n, long m, double A[n][m]);
 ;
 ; void foo(long a, long b) {
 ;   for (long n = 1; n < a; ++n)

llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; void foo(long n, long m, long o, double A[n][m][o]) {
 ;
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[i][j][k] = 1.0;

llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 ; void foo(int n, int m, int o, double A[n][m][o]) {
 ;
 ;   for (int i = 0; i < n; i++)
 ;     for (int j = 0; j < m; j++)
 ;       for (int k = 0; k < o; k++)
 ;         A[i][j][k] = 1.0;
 ; }

llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll

-; RUN: opt -basic-aa -da -analyze -enable-new-pm=0 < %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='require<da>,print<delinearization>' -disable-output < %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Derived from the following code:
 ;
 ; void foo(long n, long m, double *A) {
 ;   for (long i = 0; i < n; i++)

llvm/test/Analysis/Delinearization/parameter_addrec_product.ll

-; RUN: opt -delinearize -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='print<delinearization>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ;    void foo(float *A, long *p) {
 ;      for (long i = 0; i < 100; i++)
 ;        for (long j = 0; j < 100; j++)
 ;          A[i * (*p) + j] += i + j;
 ;    }
 ;

llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll

 ; REQUIRES: asserts
-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize -debug 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output -debug 2>&1 2>&1 | FileCheck %s
 ; void foo (int m, int n, char *A) {
 ;    for (int i=0; i < m; i++)
 ;      for(int j=0; j< n; j++)
 ;        A[i*n+j] += 1;
 ;}
 
 ; ModuleID = 'delin.cpp'

llvm/test/Analysis/Delinearization/type_mismatch.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output
 ; REQUIRES: asserts
 
 ; Test that SCEV divide code doesn't crash when attempting to create a SCEV
 ; with operands of different types. In this case, the visitAddRecExpr
 ; function tries to create an AddRec where the start and step are different
 ; types.
 

llvm/test/Analysis/Delinearization/undef.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo(double* %Ey) {
 entry:
   br i1 undef, label %for.cond55.preheader, label %for.end324
 

llvm/test/Analysis/DemandedBits/add.ll

-; RUN: opt -S -demanded-bits -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -S -disable-output -passes="print<demanded-bits>" < %s 2>&1 | FileCheck %s
 
 ; CHECK-DAG: DemandedBits: 0x1e for   %1 = and i32 %a, 9
 ; CHECK-DAG: DemandedBits: 0x1a for   %2 = and i32 %b, 9
 ; CHECK-DAG: DemandedBits: 0x1a for   %3 = and i32 %c, 13
 ; CHECK-DAG: DemandedBits: 0x1a for   %4 = and i32 %d, 4
 ; CHECK-DAG: DemandedBits: 0x1a for   %5 = or i32 %2, %3
 ; CHECK-DAG: DemandedBits: 0x1a for   %6 = or i32 %4, %5

llvm/test/Analysis/DemandedBits/basic.ll

-; RUN: opt -S -demanded-bits -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -S -disable-output -passes="print<demanded-bits>" < %s 2>&1 | FileCheck %s
  
 ; CHECK-DAG: DemandedBits: 0xff for   %1 = add nsw i32 %a, 5
 ; CHECK-DAG: DemandedBits: 0xff for   %3 = trunc i32 %2 to i8
 ; CHECK-DAG: DemandedBits: 0xff for   %2 = mul nsw i32 %1, %b
 ; CHECK-DAG: DemandedBits: 0x1 for   %4 = trunc i32 %2 to i1
 ; CHECK-DAG: DemandedBits: 0xff for   %5 = zext i1 %4 to i8
 ; CHECK-DAG: DemandedBits: 0xff for   %6 = add nsw i8 %3, %5

llvm/test/Analysis/DemandedBits/intrinsics.ll

-; RUN: opt -S -demanded-bits -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -S -disable-output -passes="print<demanded-bits>" < %s 2>&1 | FileCheck %s
 
 ; CHECK-DAG: DemandedBits: 0xff000000 for   %1 = or i32 %x, 1
 ; CHECK-DAG: DemandedBits: 0xff for   %2 = call i32 @llvm.bitreverse.i32(i32 %1)
 ; CHECK-DAG: DemandedBits: 0xff for   %3 = trunc i32 %2 to i8
 define i8 @test_bswap(i32 %x) {
   %1 = or i32 %x, 1
   %2 = call i32 @llvm.bswap.i32(i32 %1)

llvm/test/Analysis/DemandedBits/vectors-inseltpoison.ll

-; RUN: opt -S -demanded-bits -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -S -disable-output -passes="print<demanded-bits>" < %s 2>&1 | FileCheck %s
 
 ; CHECK-DAG: DemandedBits: 0xff00 for   %x = or <2 x i32> %a, zeroinitializer
 ; CHECK-DAG: DemandedBits: 0xff00 for   %y = or <2 x i32> %b, zeroinitializer
 ; CHECK-DAG: DemandedBits: 0xff00 for   %z = or <2 x i32> %x, %y
 ; CHECK-DAG: DemandedBits: 0xff for   %u = lshr <2 x i32> %z, <i32 8, i32 8>
 ; CHECK-DAG: DemandedBits: 0xff for   %r = trunc <2 x i32> %u to <2 x i8>
 define <2 x i8> @test_basic(<2 x i32> %a, <2 x i32> %b) {

llvm/test/Analysis/DemandedBits/vectors.ll

-; RUN: opt -S -demanded-bits -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -S -disable-output -passes="print<demanded-bits>" < %s 2>&1 | FileCheck %s
 
 ; CHECK-DAG: DemandedBits: 0xff00 for   %x = or <2 x i32> %a, zeroinitializer
 ; CHECK-DAG: DemandedBits: 0xff00 for   %y = or <2 x i32> %b, zeroinitializer
 ; CHECK-DAG: DemandedBits: 0xff00 for   %z = or <2 x i32> %x, %y
 ; CHECK-DAG: DemandedBits: 0xff for   %u = lshr <2 x i32> %z, <i32 8, i32 8>
 ; CHECK-DAG: DemandedBits: 0xff for   %r = trunc <2 x i32> %u to <2 x i8>
 define <2 x i8> @test_basic(<2 x i32> %a, <2 x i32> %b) {

llvm/test/Analysis/DependenceAnalysis/AA.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>"                            \
 ; RUN: "-aa-pipeline=basic-aa,tbaa" 2>&1 | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -tbaa -da | FileCheck %s
 
 ; CHECK-LABEL: 'Dependence Analysis' for function 'test_no_noalias'
 ; CHECK: da analyze - none!
 ; CHECK: da analyze - confused!
 ; CHECK: da analyze - none!
 define void @test_no_noalias(i32* %A, i32* %B) {
   store i32 1, i32* %A
   store i32 2, i32* %B

llvm/test/Analysis/DependenceAnalysis/Banerjee.ll

 ; RUN: opt < %s -disable-output -da-delinearize=false "-passes=print<da>"      \
 ; RUN: -aa-pipeline=basic-aa 2>&1 | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da -da-delinearize=false | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s -check-prefix=DELIN
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s -check-prefix=DELIN
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long int i = 1; i <= 10; i++)
 ;;    for (long int j = 1; j <= 10; j++) {
 ;;      A[10*i + j] = 0;

llvm/test/Analysis/DependenceAnalysis/BasePtrBug.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da  | FileCheck %s
 
 ; Test that the dependence analysis generates the correct results when using
 ; an aliased object that points to a different element in the same array.
 ; PR33567 - https://bugs.llvm.org/show_bug.cgi?id=33567
 
 ; void test1(int *A, int *B, int N) {
 ;   int *top = A;
 ;   int *bot = A + N/2;

llvm/test/Analysis/DependenceAnalysis/Constraints.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da
 ;; Check that this code doesn't abort. Test case is reduced version of lnt Polybench benchmark test case dynprog.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @sum_c = common global [10 x [10 x [10 x i32]]] zeroinitializer
 @c = common global [10 x [10 x i32]] zeroinitializer
 @W = common global [10 x [10 x i32]] zeroinitializer

llvm/test/Analysis/DependenceAnalysis/Coupled.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long int i = 0; i < 50; i++) {
 ;;    A[i][i] = i;
 ;;    *B++ = A[i + 10][i + 9];

llvm/test/Analysis/DependenceAnalysis/DADelin.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv8m.main-arm-none-eabi"
 
 ; CHECK-LABEL: t1
 ;;  for (int i = 0; i < n; i++)
 ;;   for (int j = 0; j < m; j++)
 ;;    for (int k = 0; k < o; k++)

llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 ; ModuleID = 'ExactRDIV.bc'
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long int i = 0; i < 10; i++)
 ;;    A[4*i + 10] = i;

llvm/test/Analysis/DependenceAnalysis/ExactSIV.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long unsigned i = 0; i < 10; i++) {
 ;;    A[i + 10] = i;
 ;;    *B++ = A[2*i + 1];

llvm/test/Analysis/DependenceAnalysis/GCD.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s -check-prefix=DELIN
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s -check-prefix=DELIN
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long int i = 0; i < 100; i++)
 ;;    for (long int j = 0; j < 100; j++) {
 ;;      A[2*i - 4*j] = i;

llvm/test/Analysis/DependenceAnalysis/Invariant.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 ; Test for a bug, which caused an assert when an invalid
 ; SCEVAddRecExpr is created in addToCoefficient.
 
 ; float foo (float g, float* rr[40]) {
 ;   float res= 0.0f;
 ;   for (int i = 0; i < 40; i += 5) {
 ;     for (int j = 0; j < 40; j += 5) {

llvm/test/Analysis/DependenceAnalysis/MIVCheckConst.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da
 ; RUN: opt < %s -passes="print<da>"
 
 ; Test that the dependence analysis pass does seg-fault due to a null pointer
 ; dereference. The code in gcdMIVTest requires a null check for the result of
 ; getConstantPart.
 
 target datalayout = "e-m:e-p:32:32-i1:32-i64:64-a:0-v32:32-n16:32"
 

llvm/test/Analysis/DependenceAnalysis/NonAffineExpr.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da
 ;
 ; CHECK: da analyze - consistent input [S S]!
 ; CHECK: da analyze - confused!
 ; CHECK: da analyze - input [* *]!
 ;
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64"
 target triple = "thumbv7--linux-gnueabi"
 

llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s -check-prefix=DELIN
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s -check-prefix=DELIN
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 ; for (int i = 0; i < 100; ++i) {
 ;   int t0 = a[i][i];
 ;   int t1 = t0 + 1;
 ;   a[i][5] = t1;

llvm/test/Analysis/DependenceAnalysis/PR21585.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>"                            \
 ; RUN: "-aa-pipeline=basic-aa,globals-aa" 2>&1 | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -globals-aa -da | FileCheck %s
 define void @i32_subscript(i32* %a) {
 entry:
   br label %for.body
 
 for.body:
   %i = phi i32 [ 0, %entry ], [ %i.inc, %for.body ]
   %a.addr = getelementptr i32, i32* %a, i32 %i
   %a.addr.2 = getelementptr i32, i32* %a, i32 5

llvm/test/Analysis/DependenceAnalysis/Preliminary.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;int p0(int n, int *A, int *B) {
 ;;  A[0] = n;
 ;;  return B[1];

llvm/test/Analysis/DependenceAnalysis/Propagating.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long int i = 0; i < 100; i++)
 ;;    for (long int j = 0; j < 100; j++) {
 ;;      A[i + 1][i + j] = i;

llvm/test/Analysis/DependenceAnalysis/Separability.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long int i = 0; i < 50; i++)
 ;;    for (long int j = 0; j < 50; j++)
 ;;      for (long int k = 0; k < 50; k++)

llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheckFixedSize.ll

 ; RUN: opt < %s -disable-output -passes="print<da>" 2>&1 | FileCheck %s
-; RUN: opt < %s -da -analyze -enable-new-pm=0 | FileCheck %s
 
 ; Note: exact results can be achived even if
 ; "-da-disable-delinearization-checks" is not used
 
 ; CHECK-LABEL: t1
 ; CHECK: da analyze - none!
 ; CHECK: da analyze - consistent anti [1 -2]!
 ; CHECK: da analyze - none!

llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (int i = 0; i < n; i++) {
 ;;    A[i + 2] = i;
 ;;    *B++ = A[i];

llvm/test/Analysis/DependenceAnalysis/SymbolicRDIV.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 ; ModuleID = 'SymbolicRDIV.bc'
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long int i = 0; i < n1; i++)
 ;;    A[2*i + n1] = i;

llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long int i = 0; i < n; i++) {
 ;;    A[2*i + n] = i;
 ;;    *B++ = A[3*i + 3*n];

llvm/test/Analysis/DependenceAnalysis/UsefulGEP.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da
 ;; Check this doesn't crash.
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ;; struct s {
 ;;   int A[10][10];
 ;;   int C[10][10][10]; 
 ;; } S;

llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 ; ModuleID = 'WeakCrossingSIV.bc'
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (long unsigned i = 0; i < n; i++) {
 ;;    A[1 + n*i] = i;

llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 ; ModuleID = 'WeakZeroDstSIV.bc'
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (int i = 0; i < N; i++) {
 ;;    A[i] = 1;

llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 ; ModuleID = 'WeakZeroSrcSIV.bc'
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  for (int i = 0; i < N; i++) {
 ;;    A[0] = 1;

llvm/test/Analysis/DependenceAnalysis/ZIV.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
 ; RUN: | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -da | FileCheck %s
 
 ; ModuleID = 'ZIV.bc'
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.6.0"
 
 
 ;;  A[n + 1] = 0;
 ;;  *B = A[1 + n];

llvm/test/Analysis/DependenceAnalysis/lcssa.ll

 ; RUN: opt < %s -disable-output "-passes=print<da>"                            \
 ; RUN: "-aa-pipeline=basic-aa,tbaa" 2>&1 | FileCheck %s
-; RUN: opt < %s -analyze -enable-new-pm=0 -basic-aa -tbaa -da | FileCheck %s
 
 ; CHECK:      Src:  %v = load i32, i32* %arrayidx1, align 4 --> Dst:  store i32 %add, i32* %a.lcssa, align 4
 ; CHECK-NEXT: da analyze - confused!
 
 define void @f(i32 *%a, i32 %n, i64 %n2) {
 entry:
   br label %while.body
 

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/always_uniform.ll

-; RUN: opt  -mtriple amdgcn-unknown-amdhsa -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: for function 'readfirstlane':
 define amdgpu_kernel void @readfirstlane() {
   %id.x = call i32 @llvm.amdgcn.workitem.id.x()
 ; CHECK: DIVERGENT:  %id.x = call i32 @llvm.amdgcn.workitem.id.x()
   %first.lane = call i32 @llvm.amdgcn.readfirstlane(i32 %id.x)
 ; CHECK-NOT: DIVERGENT:  %first.lane = call i32 @llvm.amdgcn.readfirstlane(i32 %id.x)

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/atomics.ll

-; RUN: opt -mtriple=amdgcn-- -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-- -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK: DIVERGENT: %orig = atomicrmw xchg i32* %ptr, i32 %val seq_cst
 define i32 @test1(i32* %ptr, i32 %val) #0 {
   %orig = atomicrmw xchg i32* %ptr, i32 %val seq_cst
   ret i32 %orig
 }
 

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/b42473-r1-crash.ll

-; RUN: opt -mtriple amdgcn-unknown-amdhsa -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 declare i32 @gf2(i32)
 declare i32 @gf1(i32)
 
 define  void @tw1(i32 addrspace(4)* noalias nocapture readonly %A, i32 addrspace(4)* noalias nocapture %B) local_unnamed_addr #2 {
 ; CHECK: Divergence Analysis' for function 'tw1':
 ; CHECK: DIVERGENT: i32 addrspace(4)* %A

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/control-flow-intrinsics.ll

-; RUN: opt -mtriple=amdgcn-mesa-mesa3d -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-mesa-mesa3d -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; Tests control flow intrinsics that should be treated as uniform
 
 ; CHECK: Divergence Analysis' for function 'test_if_break':
 ; CHECK: DIVERGENT: %cond = icmp eq i32 %arg0, 0
 ; CHECK-NOT: DIVERGENT
 ; CHECK: ret void

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/hidden_loopdiverge.ll

-; RUN: opt -mtriple amdgcn-unknown-amdhsa -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; divergent loop (H<header><exiting to X>, B<exiting to Y>)
 ; the divergent join point in %exit is obscured by uniform control joining in %X
 define amdgpu_kernel void @hidden_loop_diverge(i32 %n, i32 %a, i32 %b) #0 {
 ; CHECK-LABEL: Divergence Analysis' for function 'hidden_loop_diverge'
 ; CHECK-NOT: DIVERGENT: %uni.
 ; CHECK-NOT: DIVERGENT: br i1 %uni.

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/inline-asm.ll

-; RUN: opt -mtriple=amdgcn-unknown-amdhsa -mcpu=tahiti -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
-; RUN: opt -mtriple=amdgcn-unknown-amdhsa -mcpu=gfx908 -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -mcpu=tahiti -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -mcpu=gfx908 -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 ; Make sure nothing crashes on targets with or without AGPRs
 
 ; CHECK: Divergence Analysis' for function 'inline_asm_1_sgpr_virtreg_output':
 ; CHECK-NOT: DIVERGENT
 define i32 @inline_asm_1_sgpr_virtreg_output() {
   %sgpr = call i32 asm "s_mov_b32 $0, 0", "=s"()

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/interp_f16.ll

-; RUN: opt -mtriple=amdgcn-- -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-- -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK: for function 'interp_p1_f16'
 ; CHECK: DIVERGENT:       %p1 = call float @llvm.amdgcn.interp.p1.f16
 define amdgpu_ps float @interp_p1_f16(float inreg %i, float inreg %j, i32 inreg %m0) #0 {
 main_body:
   %p1 = call float @llvm.amdgcn.interp.p1.f16(float %i, i32 1, i32 2, i1 0, i32 %m0)
   ret float %p1

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/intrinsics.ll

-; RUN: opt -mtriple=amdgcn-- -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-- -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK: DIVERGENT: %swizzle = call i32 @llvm.amdgcn.ds.swizzle(i32 %src, i32 100) #0
 define amdgpu_kernel void @ds_swizzle(i32 addrspace(1)* %out, i32 %src) #0 {
   %swizzle = call i32 @llvm.amdgcn.ds.swizzle(i32 %src, i32 100) #0
   store i32 %swizzle, i32 addrspace(1)* %out, align 4
   ret void
 }

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/irreducible.ll

-; RUN: opt %s -mtriple amdgcn-- -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis | FileCheck %s
 ; RUN: opt %s -mtriple amdgcn-- -passes='print<divergence>' -disable-output 2>&1 | FileCheck %s
 
 ; NOTE: The new pass manager does not fall back on legacy divergence
 ; analysis even when the function contains an irreducible loop. The
 ; (new) divergence analysis conservatively reports all values as
 ; divergent. This test does not check for this conservative
 ; behaviour. Instead, it only checks for the values that are known to
 ; be divergent according to the legacy analysis.

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/join-at-loop-exit.ll

-; RUN: opt -mtriple amdgcn-unknown-amdhsa -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK: bb3:
 ; CHECK: DIVERGENT:       %Guard.bb4 = phi i1 [ true, %bb1 ], [ false, %bb2 ]
 ; CHECK: DIVERGENT:       br i1 %Guard.bb4, label %bb4, label %bb5
 
 ; Function Attrs: nounwind readnone speculatable
 declare i32 @llvm.amdgcn.workitem.id.x() #0

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/kernel-args.ll

-; RUN: opt %s -mtriple amdgcn-- -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis | FileCheck %s
 ; RUN: opt -mtriple amdgcn-- -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: Divergence Analysis' for function 'test_amdgpu_ps':
 ; CHECK: DIVERGENT:  [4 x <16 x i8>] addrspace(4)* %arg0
 ; CHECK-NOT: DIVERGENT
 ; CHECK: DIVERGENT:  <2 x i32> %arg3
 ; CHECK: DIVERGENT:  <3 x i32> %arg4
 ; CHECK: DIVERGENT:  float %arg5

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/llvm.amdgcn.buffer.atomic.ll

-;RUN: opt -mtriple=amdgcn-mesa-mesa3d -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-mesa-mesa3d -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ;CHECK: DIVERGENT: %orig = call i32 @llvm.amdgcn.buffer.atomic.swap.i32(
 define float @buffer_atomic_swap(<4 x i32> inreg %rsrc, i32 inreg %data) #0 {
 main_body:
   %orig = call i32 @llvm.amdgcn.buffer.atomic.swap.i32(i32 %data, <4 x i32> %rsrc, i32 0, i32 0, i1 0)
   %r = bitcast i32 %orig to float
   ret float %r

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/llvm.amdgcn.image.atomic.ll

-;RUN: opt -mtriple=amdgcn-mesa-mesa3d -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-mesa-mesa3d -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ;CHECK: DIVERGENT: %orig = call i32 @llvm.amdgcn.image.atomic.swap.1d.i32.i32(
 define float @image_atomic_swap(<8 x i32> inreg %rsrc, i32 inreg %addr, i32 inreg %data) #0 {
 main_body:
   %orig = call i32 @llvm.amdgcn.image.atomic.swap.1d.i32.i32(i32 %data, i32 %addr, <8 x i32> %rsrc, i32 0, i32 0)
   %r = bitcast i32 %orig to float
   ret float %r

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/no-return-blocks.ll

-; RUN: opt %s -mtriple amdgcn-- -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis | FileCheck %s
 ; RUN: opt -mtriple amdgcn-- -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK: DIVERGENT:  %tmp5 = getelementptr inbounds float, float addrspace(1)* %arg, i64 %tmp2
 ; CHECK: DIVERGENT:  %tmp10 = load volatile float, float addrspace(1)* %tmp5, align 4
 ; CHECK: DIVERGENT:  %tmp11 = load volatile float, float addrspace(1)* %tmp5, align 4
 
 ; The post dominator tree does not have a root node in this case
 define amdgpu_kernel void @no_return_blocks(float addrspace(1)* noalias nocapture readonly %arg, float addrspace(1)* noalias nocapture readonly %arg1) #0 {

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/phi-undef.ll

-; RUN: opt -mtriple=amdgcn-- -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-- -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: 'test1':
 ; CHECK-NEXT: DIVERGENT: i32 %bound
 ; CHECK: {{^  *}}%counter =
 ; CHECK-NEXT: DIVERGENT: %break = icmp sge i32 %counter, %bound
 ; CHECK-NEXT: DIVERGENT: br i1 %break, label %footer, label %body
 ; CHECK: {{^  *}}%counter.next =

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/propagate-loop-live-out.ll

-; RUN: opt -mtriple amdgcn-unknown-amdhsa -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK: bb6:
 ; CHECK: DIVERGENT:       %.126.i355.i = phi i1 [ false, %bb5 ], [ true, %bb4 ]
 ; CHECK: DIVERGENT:       br i1 %.126.i355.i, label %bb7, label %bb8
 
 ; Function Attrs: nounwind readnone speculatable
 declare i32 @llvm.amdgcn.workitem.id.x() #0

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/temporal_diverge.ll

-; RUN: opt -mtriple amdgcn-unknown-amdhsa -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; temporal-divergent use of value carried by divergent loop
 define amdgpu_kernel void @temporal_diverge(i32 %n, i32 %a, i32 %b) #0 {
 ; CHECK-LABEL: Divergence Analysis' for function 'temporal_diverge':
 ; CHECK-NOT: DIVERGENT: %uni.
 ; CHECK-NOT: DIVERGENT: br i1 %uni.
 

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/trivial-join-at-loop-exit.ll

-; RUN: opt -mtriple amdgcn-unknown-amdhsa -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK: bb2:
 ; CHECK-NOT: DIVERGENT:       %Guard.bb2 = phi i1 [ true, %bb1 ], [ false, %bb0 ]
 
 ; Function Attrs: nounwind readnone speculatable
 declare i32 @llvm.amdgcn.workitem.id.x() #0
 

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/unreachable-loop-block.ll

-; RUN: opt %s -mtriple amdgcn-- -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis | FileCheck %s
 ; RUN: opt -mtriple amdgcn-- -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK: DIVERGENT:  %tmp = cmpxchg volatile
 define amdgpu_kernel void @unreachable_loop(i32 %tidx) #0 {
 entry:
   unreachable
 
 unreachable_loop:                                        ; preds = %do.body.i, %if.then11

llvm/test/Analysis/DivergenceAnalysis/AMDGPU/workitem-intrinsics.ll

-; RUN: opt  -mtriple amdgcn-unknown-amdhsa -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis %s | FileCheck %s
 ; RUN: opt -mtriple amdgcn-unknown-amdhsa -passes='print<divergence>' -disable-output %s 2>&1 | FileCheck %s
 
 declare i32 @llvm.amdgcn.workitem.id.x() #0
 declare i32 @llvm.amdgcn.workitem.id.y() #0
 declare i32 @llvm.amdgcn.workitem.id.z() #0
 declare i32 @llvm.amdgcn.mbcnt.lo(i32, i32) #0
 declare i32 @llvm.amdgcn.mbcnt.hi(i32, i32) #0
 

llvm/test/Analysis/DivergenceAnalysis/NVPTX/daorder.ll

-; RUN: opt %s -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis | FileCheck %s
 ; RUN: opt %s -passes='print<divergence>' -disable-output 2>&1 | FileCheck %s
 
 target datalayout = "e-i64:64-v16:16-v32:32-n16:32:64"
 target triple = "nvptx64-nvidia-cuda"
 
 define i32 @daorder(i32 %n) {
 ; CHECK-LABEL: Divergence Analysis' for function 'daorder'
 entry:

llvm/test/Analysis/DivergenceAnalysis/NVPTX/diverge.ll

-; RUN: opt %s -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis | FileCheck %s
 ; RUN: opt %s -passes='print<divergence>' -disable-output 2>&1 | FileCheck %s
 
 target datalayout = "e-i64:64-v16:16-v32:32-n16:32:64"
 target triple = "nvptx64-nvidia-cuda"
 
 ; return (n < 0 ? a + threadIdx.x : b + threadIdx.x)
 define i32 @no_diverge(i32 %n, i32 %a, i32 %b) {
 ; CHECK-LABEL: Divergence Analysis' for function 'no_diverge'

llvm/test/Analysis/DivergenceAnalysis/NVPTX/hidden_diverge.ll

-; RUN: opt %s -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis | FileCheck %s
 ; RUN: opt %s -passes='print<divergence>' -disable-output 2>&1 | FileCheck %s
 
 target datalayout = "e-i64:64-v16:16-v32:32-n16:32:64"
 target triple = "nvptx64-nvidia-cuda"
 
 define i32 @hidden_diverge(i32 %n, i32 %a, i32 %b) {
 ; CHECK-LABEL: Divergence Analysis' for function 'hidden_diverge'
 entry:

llvm/test/Analysis/DivergenceAnalysis/NVPTX/irreducible.ll

-; RUN: opt %s -enable-new-pm=0 -analyze -divergence -use-gpu-divergence-analysis | FileCheck %s
 ; RUN: opt %s -passes='print<divergence>' -disable-output 2>&1 | FileCheck %s
 
 ; NOTE: The new pass manager does not fall back on legacy divergence
 ; analysis even when the function contains an irreducible loop. The
 ; (new) divergence analysis conservatively reports all values as
 ; divergent. This test does not check for this conservative
 ; behaviour. Instead, it only checks for the values that are known to
 ; be divergent according to the legacy analysis.

llvm/test/Analysis/Dominators/2006-10-02-BreakCritEdges.ll

-; RUN: opt < %s -domtree -break-crit-edges -analyze -domtree -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='require<domtree>,break-crit-edges,print<domtree>' -disable-output 2>&1| FileCheck %s
 ; PR932
 
 ; CHECK: [3] %brtrue {{{[0-9]+}},{{[0-9]+}}}
 
 declare void @use1(i32)
 
 define void @f(i32 %i, i1 %c) {

llvm/test/Analysis/Dominators/basic.ll

-; RUN: opt < %s -domtree -analyze -enable-new-pm=0 | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-OLDPM
-; RUN: opt < %s -disable-output -passes='print<domtree>' 2>&1 | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-NEWPM
+; RUN: opt < %s -disable-output -passes='print<domtree>' 2>&1 | FileCheck %s
 
 define void @test1() {
-; CHECK-OLDPM-LABEL: 'Dominator Tree Construction' for function 'test1':
-; CHECK-NEWPM-LABEL: DominatorTree for function: test1
+; CHECK-LABEL: DominatorTree for function: test1
 ; CHECK:      [1] %entry
 ; CHECK-NEXT:   [2] %a
 ; CHECK-NEXT:   [2] %c
 ; CHECK-NEXT:     [3] %d
 ; CHECK-NEXT:     [3] %e
 ; CHECK-NEXT:   [2] %b
 
 entry:

 d:
   ret void
 
 e:
   ret void
 }
 
 define void @test2() {
-; CHECK-OLDPM-LABEL: 'Dominator Tree Construction' for function 'test2':
-; CHECK-NEWPM-LABEL: DominatorTree for function: test2
+; CHECK-LABEL: DominatorTree for function: test2
 ; CHECK:      [1] %entry
 ; CHECK-NEXT:   [2] %a
 ; CHECK-NEXT:     [3] %b
 ; CHECK-NEXT:       [4] %c
 ; CHECK-NEXT:         [5] %d
 ; CHECK-NEXT:         [5] %ret
 
 entry:

llvm/test/Analysis/IVUsers/quadradic-exit-value.ll

-; This test ensures that IVUsers works correctly in the legacy pass manager
-; without LCSSA and in the specific ways that some of its users (LSR) require.
-;
-; FIXME: We need some way to match the precision here in the new PM where loop
-; passes *always* work on LCSSA. This should stop using a different set of
-; checks at that point.
-
-; RUN: opt < %s -analyze -iv-users -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,CHECK-NO-LCSSA
-; RUN: opt < %s -disable-output -passes='print<iv-users>' 2>&1 | FileCheck %s
-
-; Provide legal integer types.
-target datalayout = "n8:16:32:64"
-
-; The value of %r is dependent on a polynomial iteration expression.
-;
-; CHECK-LABEL: IV Users for loop %foo.loop
-; CHECK-NO-LCSSA: {1,+,3,+,2}<%foo.loop>
-define i64 @foo(i64 %n) {
-entry:
-  br label %foo.loop
-
-foo.loop:
-  %indvar = phi i64 [ 0, %entry ], [ %indvar.next, %foo.loop ]
-  %indvar.next = add i64 %indvar, 1
-  %c = icmp eq i64 %indvar.next, %n
-  br i1 %c, label %exit, label %foo.loop
-
-exit:
-  %r = mul i64 %indvar.next, %indvar.next
-  ret i64 %r
-}
-
-; PR15470: LSR miscompile. The test1 function should return '1'.
-; It is valid to fold SCEVUnknown into the recurrence because it
-; was defined before the loop.
-;
-; SCEV does not know how to denormalize chained recurrences, so make
-; sure they aren't marked as post-inc users.
-;
-; CHECK-LABEL: IV Users for loop %test1.loop
-; CHECK-NO-LCSSA: %sext.us = {0,+,(16777216 + (-16777216 * %sub.us)<nuw><nsw>)<nuw><nsw>,+,33554432}<%test1.loop> (post-inc with loop %test1.loop) in    %f = ashr i32 %sext.us, 24
-define i32 @test1(i1 %cond) {
-entry:
-  %sub.us = select i1 %cond, i32 0, i32 0
-  br label %test1.loop
-
-test1.loop:
-  %inc1115.us = phi i32 [ 0, %entry ], [ %inc11.us, %test1.loop ]
-  %inc11.us = add nsw i32 %inc1115.us, 1
-  %cmp.us = icmp slt i32 %inc11.us, 2
-  br i1 %cmp.us, label %test1.loop, label %for.end
-
-for.end:
-  %tobool.us = icmp eq i32 %inc1115.us, 0
-  %mul.us = shl i32 %inc1115.us, 24
-  %sub.cond.us = sub nsw i32 %inc1115.us, %sub.us
-  %sext.us = mul i32 %mul.us, %sub.cond.us
-  %f = ashr i32 %sext.us, 24
-  br label %exit
-
-exit:
-  ret i32 %f
-}
-
-; PR15470: LSR miscompile. The test2 function should return '1'.
-; It is illegal to fold SCEVUnknown (sext.us) into the recurrence
-; because it is defined after the loop where this recurrence belongs.
-;
-; SCEV does not know how to denormalize chained recurrences, so make
-; sure they aren't marked as post-inc users.
-;
-; CHECK-LABEL: IV Users for loop %test2.loop
-; CHECK-NO-LCSSA: %sub.cond.us = ((-1 * %sub.us)<nuw><nsw> + {0,+,1}<nuw><nsw><%test2.loop>) (post-inc with loop %test2.loop) in    %sext.us = mul i32 %mul.us, %sub.cond.us
-define i32 @test2() {
-entry:
-  br label %test2.loop
-
-test2.loop:
-  %inc1115.us = phi i32 [ 0, %entry ], [ %inc11.us, %test2.loop ]
-  %inc11.us = add nsw i32 %inc1115.us, 1
-  %cmp.us = icmp slt i32 %inc11.us, 2
-  br i1 %cmp.us, label %test2.loop, label %for.end
-
-for.end:
-  %tobool.us = icmp eq i32 %inc1115.us, 0
-  %sub.us = select i1 %tobool.us, i32 0, i32 0
-  %mul.us = shl i32 %inc1115.us, 24
-  %sub.cond.us = sub nsw i32 %inc1115.us, %sub.us
-  %sext.us = mul i32 %mul.us, %sub.cond.us
-  %f = ashr i32 %sext.us, 24
-  br label %exit
-
-exit:
-  ret i32 %f
-}

llvm/test/Analysis/LoopAccessAnalysis/backward-dep-different-types.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output < %s  2>&1 | FileCheck %s
 
 ; In this loop just because we access A through different types (int, float)
 ; we still have a dependence cycle:
 ;
 ;   for (i = 0; i < n; i++) {
 ;    A_float = (float *) A;
 ;    A_float[i + 1] = A[i] * B[i];

llvm/test/Analysis/LoopAccessAnalysis/forward-loop-carried.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ;   for (unsigned i = 0; i < 100; i++) {
 ;     A[i+8] = B[i] + 2;
 ;     C[i] = A[i] * 2;
 ;   }
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"

llvm/test/Analysis/LoopAccessAnalysis/forward-loop-independent.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Check that loop-indepedent forward dependences are discovered properly.
 ;
 ; FIXME: This does not actually always work which is pretty confusing.  Right
 ; now there is hack in LAA that tries to figure out loop-indepedent forward
 ; dependeces *outside* of the MemoryDepChecker logic (i.e. proper dependence
 ; analysis).

llvm/test/Analysis/LoopAccessAnalysis/independent-interleaved.ll

-; RUN: opt < %s -store-to-load-forwarding-conflict-detection=false -loop-accesses -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -store-to-load-forwarding-conflict-detection=false  -disable-output  < %s 2>&1 | FileCheck %s
 
 ; This test checks that we prove the strided accesses to be independent before
 ; concluding that there is a forward dependence.
 
 ; struct pair {
 ;   int x;
 ;   int y;

llvm/test/Analysis/LoopAccessAnalysis/memcheck-for-loop-invariant.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Handle memchecks involving loop-invariant addresses:
 ;
 ; extern int *A, *b;
 ; for (i = 0; i < N; ++i) {
 ;  A[i] = b;
 ; }

llvm/test/Analysis/LoopAccessAnalysis/memcheck-off-by-one-error.ll

-; RUN: opt -analyze --loop-accesses %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt -passes=print-access-info %s -disable-output 2>&1 | FileCheck %s
 
 ; This test verifies run-time boundary check of memory accesses.
 ; The original loop:
 ;   void fastCopy(const char* src, char* op) {
 ;     int len = 32;
 ;     while (len > 0) {
 ;       *(reinterpret_cast<long long*>(op)) = *(reinterpret_cast<const long long*>(src));

llvm/test/Analysis/LoopAccessAnalysis/memcheck-store-vs-alloc-size.ll

-; RUN: opt -analyze --loop-accesses %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt -passes=print-access-info %s -disable-output 2>&1 | FileCheck %s
 
 ; This test defends against accidentally using alloc size instead of store size when performing run-time
 ; boundary check of memory accesses. The IR in this file is based on
 ; llvm/test/Analysis/LoopAccessAnalysis/memcheck-off-by-one-error.ll.
 ; Here, we use i19 instead of i64 because it has a different alloc size to its store size.
 
 ;CHECK: function 'fastCopy':

llvm/test/Analysis/LoopAccessAnalysis/memcheck-wrapping-pointers.ll

-; RUN: opt -basic-aa -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes=print-access-info %s -disable-output 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 ; i and i + 1 can overflow in the following kernel:
 ; void test1(unsigned long long x, int *a, int *b) {
 ;  for (unsigned i = 0; i < x; ++i)
 ;    b[i] = a[i+1] + 1;

llvm/test/Analysis/LoopAccessAnalysis/multiple-strides-rt-memory-checks.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 -S < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; This is the test case from PR26314.
 ; When we were retrying dependence checking with memchecks only, 
 ; the loop-invariant access in the inner loop was incorrectly determined to be wrapping 
 ; because it was not strided in the inner loop.
  
 ; #define Z 32

llvm/test/Analysis/LoopAccessAnalysis/non-wrapping-pointer.ll

-; RUN: opt -basic-aa -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s  2>&1 | FileCheck %s
 
 ; For this loop:
 ;   for (int i = 0; i < n; i++)
 ;    A[2 * i] = A[2 * i] + B[i];
 ;
 ; , SCEV is unable to prove that A[2 * i] does not overflow.  However,
 ; analyzing the IR helps us to conclude it and in turn allow dependence

llvm/test/Analysis/LoopAccessAnalysis/nullptr.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 %s  | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Test that the loop accesses are proven safe in this case.
 ; The analyzer uses to be confused by the "diamond" because getUnderlyingObjects
 ; is saying that the two pointers can both points to null. The loop analyzer
 ; needs to ignore null in the results returned by getUnderlyingObjects.
 
 ; CHECK: Memory dependences are safe with run-time checks

llvm/test/Analysis/LoopAccessAnalysis/number-of-memchecks.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64--linux-gnueabi"
 
 ; 3 reads and 3 writes should need 12 memchecks
 ; CHECK: function 'testf':
 ; CHECK: Memory dependences are safe with run-time checks

llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 %s1 = type { [32000 x double], [32000 x double], [32000 x double] }
 
 define i32 @load_with_pointer_phi_no_runtime_checks(%s1* %data) {
 ; CHECK-LABEL: load_with_pointer_phi_no_runtime_checks
 ; CHECK-NEXT:  loop.header:
 ; CHECK-NEXT:    Report: cannot identify array bounds

llvm/test/Analysis/LoopAccessAnalysis/pointer-with-unknown-bounds.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; We shouldn't quit the analysis if we encounter a pointer without known
 ; bounds *unless* we actually need to emit a memcheck for it.  (We only
 ; compute bounds for SCEVAddRecs so A[i*i] is deemed not having known bounds.)
 ;

llvm/test/Analysis/LoopAccessAnalysis/pr31098.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Check that the compile-time-unknown depenendece-distance is resolved 
 ; statically. Due to the non-unit stride of the accesses in this testcase
 ; we are currently not able to create runtime dependence checks, and therefore
 ; if we don't resolve the dependence statically we cannot vectorize the loop.

llvm/test/Analysis/LoopAccessAnalysis/resort-to-memchecks-only.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; We give up analyzing the dependences in this loop due to non-constant
 ; distance between A[i+offset] and A[i] and add memchecks to prove
 ; independence.  Make sure that no dependences are reported in
 ; this case.
 ;
 ;   for (i = 0; i < n; i++)

llvm/test/Analysis/LoopAccessAnalysis/reverse-memcheck-bounds.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; The runtime memory check code and the access grouping
 ; algorithm both assume that the start and end values
 ; for an access range are ordered (start <= stop).
 ; When generating checks for accesses with negative stride
 ; we need to take this into account and swap the interval
 ; ends.

llvm/test/Analysis/LoopAccessAnalysis/runtime-pointer-checking-insert-typesize.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 %s
 ; RUN: opt -passes='print-access-info' -disable-output < %s
 
 ; This regression test is defending against a use of the wrong interface
 ; of TypeSize (implicit conversion to a scalar). This issue cropped up
 ; in RuntimePointerChecking::insert when performing loop load elimination
 ; because this function was previously unaware of scalable types.
 
 define void @runtime_pointer_checking_insert_typesize(<vscale x 4 x i32>* %a,

llvm/test/Analysis/LoopAccessAnalysis/safe-no-checks.ll

-; RUN: opt -basic-aa -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s  2>&1 | FileCheck %s
 
 ; If the arrays don't alias this loop is safe with no memchecks:
 ;   for (i = 0; i < n; i++)
 ;    A[i] = A[i+1] * B[i] * C[i];
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"

llvm/test/Analysis/LoopAccessAnalysis/safe-with-dep-distance.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Analyze this loop:
 ;   for (i = 0; i < n; i++)
 ;    A[i + 4] = A[i] * 2;
 
 ; CHECK: Memory dependences are safe with a maximum dependence distance of 8 bytes
 

llvm/test/Analysis/LoopAccessAnalysis/store-to-invariant-check1.ll

-; RUN: opt < %s -loop-accesses -analyze -enable-new-pm=0 | FileCheck -check-prefix=OLDPM %s
-; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck -check-prefix=NEWPM %s
+; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Test to confirm LAA will find multiple stores to an invariant address in the
 ; inner loop.
 ;
 ;  for(; i < itr; i++) {
 ;    for(; j < itr; j++) {
 ;      var1[i] = var2[j] + var1[i];
 ;      var1[i]++;
 ;    }
 ;  }
 
 ; The LAA with the new PM is a loop pass so we go from inner to outer loops.
 
-; OLDPM: for.cond1.preheader:
-; OLDPM:   Non vectorizable stores to invariant address were not found in loop.
-; OLDPM: for.body3:
-; OLDPM:   Non vectorizable stores to invariant address were found in loop.
-
-; NEWPM: for.body3:
-; NEWPM:   Non vectorizable stores to invariant address were found in loop.
-; NEWPM: for.cond1.preheader:
-; NEWPM:   Non vectorizable stores to invariant address were not found in loop.
+; CHECK: for.body3:
+; CHECK:   Non vectorizable stores to invariant address were found in loop.
+; CHECK: for.cond1.preheader:
+; CHECK:   Non vectorizable stores to invariant address were not found in loop.
 
 define i32 @foo(i32* nocapture %var1, i32* nocapture readonly %var2, i32 %itr) #0 {
 entry:
   %cmp20 = icmp eq i32 %itr, 0
   br i1 %cmp20, label %for.end10, label %for.cond1.preheader
 
 for.cond1.preheader:                              ; preds = %entry, %for.inc8
   %indvars.iv23 = phi i64 [ %indvars.iv.next24, %for.inc8 ], [ 0, %entry ]

llvm/test/Analysis/LoopAccessAnalysis/store-to-invariant-check2.ll

-; RUN: opt < %s -loop-accesses -analyze -enable-new-pm=0  | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Test to confirm LAA will not find store to invariant address.
 ; Inner loop has no store to invariant address.
 ;
 ;  for(; i < itr; i++) {
 ;    for(; j < itr; j++) {
 ;      var2[j] = var2[j] + var1[i];

llvm/test/Analysis/LoopAccessAnalysis/store-to-invariant-check3.ll

-; RUN: opt < %s -loop-accesses -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Inner loop has a store to invariant address, but LAA does not need to identify
 ; the store to invariant address, since it is a single store.
 ;
 ;  for(; i < itr; i++) {
 ;    for(; j < itr; j++) {
 ;      var1[j] = ++var2[i] + var1[j];

llvm/test/Analysis/LoopAccessAnalysis/stride-access-dependence.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
 
 ; Following cases are no dependence.
 
 ; void nodep_Read_Write(int *A) {
 ;   int *B = A + 1;

llvm/test/Analysis/LoopAccessAnalysis/uncomputable-backedge-taken-count.ll

-; RUN: opt -basic-aa -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s  2>&1 | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; TODO: Loop iteration counts are only required if we generate memory
 ;       runtime checks. Missing iteration counts should not prevent
 ;       analysis, if no runtime checks are required.

llvm/test/Analysis/LoopAccessAnalysis/underlying-objects-1.ll

-; RUN: opt -basic-aa -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; In:
 ;
 ;   store_ptr = A;
 ;   load_ptr = &A[2];
 ;   for (i = 0; i < n; i++)
 ;    *store_ptr++ = *load_ptr++ *10;  // A[i] = A[i+2] * 10

llvm/test/Analysis/LoopAccessAnalysis/underlying-objects-2.ll

-; RUN: opt -basic-aa -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; This loop:
 ;
 ;   int **A;
 ;   for (i)
 ;     for (j) {
 ;        A[i][j] = A[i-1][j] * B[j]

llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks-convergent.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Analyze this loop:
 ;   for (i = 0; i < n; i++)
 ;    A[i + 1] = A[i] * B[i] * C[i];
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 

llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks.ll

-; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Analyze this loop:
 ;   for (i = 0; i < n; i++)
 ;    A[i + 1] = A[i] * B[i] * C[i];
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"

llvm/test/Analysis/LoopAccessAnalysis/wrapping-pointer-versioning.ll

-; RUN: opt -basic-aa -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s -check-prefix=LAA
 ; RUN: opt -passes='require<aa>,require<scalar-evolution>,require<aa>,loop(print-access-info)' -aa-pipeline='basic-aa' -disable-output < %s  2>&1 | FileCheck %s --check-prefix=LAA
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; For this loop:
 ;   unsigned index = 0;
 ;   for (int i = 0; i < n; i++) {
 ;    A[2 * index] = A[2 * index] + B[i];

llvm/test/Analysis/LoopInfo/2003-02-19-LoopInfoNestingBug.ll

 ; LoopInfo is incorrectly calculating loop nesting!  In this case it doesn't 
 ; figure out that loop "Inner" should be nested inside of leep "LoopHeader", 
 ; and instead nests it just inside loop "Top"
 ;
-; RUN: opt < %s -analyze -loops -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<loops>' -disable-output 2>&1 | FileCheck %s
 
 ; CHECK:  Loop at depth 3 containing: %Inner<header><latch><exiting>
 define void @test() {
         br label %Top
 
 Top:            ; preds = %Out, %0
         br label %LoopHeader

llvm/test/Analysis/LoopInfo/2003-05-15-NestingProblem.ll

 ; This testcase was incorrectly computing that the loopentry.7 loop was
 ; not a child of the loopentry.6 loop.
 ;
-; RUN: opt < %s -analyze -loops -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<loops>' -disable-output 2>&1 | FileCheck %s
 
 ; CHECK: Loop at depth 4 containing: %loopentry.7<header><latch><exiting>
 
 define void @getAndMoveToFrontDecode() {
   br label %endif.2
 
 endif.2:    ; preds = %loopexit.5, %0

llvm/test/Analysis/LoopInfo/annotated-parallel-complex.ll

-; RUN: opt -loops -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='print<loops>' -disable-output %s 2>&1 | FileCheck %s
 ;
 ; void func(long n, double A[static const restrict 4*n], double B[static const restrict 4*n]) {
 ;   for (long i = 0; i < n; i += 1)
 ;     for (long j = 0; j < n; j += 1)
 ;       for (long k = 0; k < n; k += 1)
 ;         for (long l = 0; l < n; l += 1) {
 ;           A[i + j + k + l] = 21;

llvm/test/Analysis/LoopInfo/annotated-parallel-simple.ll

-; RUN: opt -loops -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='print<loops>' -disable-output %s 2>&1 | FileCheck %s
 ;
 ; void func(long n, double A[static const restrict n]) {
 ;   for (long i = 0; i < n; i += 1)
 ;     A[i] = 21;
 ; }
 ;
 ; Check that isAnnotatedParallel is working as expected.

llvm/test/Analysis/MemorySSA/assume.ll

-; RUN: opt -basic-aa -memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Ensures that assumes are treated as not reading or writing memory.
 
 declare void @llvm.assume(i1)
 
 define i32 @foo(i32* %a, i32* %b, i1 %c) {
 ; CHECK: 1 = MemoryDef(liveOnEntry)

llvm/test/Analysis/MemorySSA/atomic-clobber.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Ensures that atomic loads count as MemoryDefs
 
 ; CHECK-LABEL: define i32 @foo
 define i32 @foo(i32* %a, i32* %b) {
 ; CHECK: 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT: store i32 4

llvm/test/Analysis/MemorySSA/constant-memory.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>' -verify-memoryssa < %s 2>&1 | FileCheck %s
 ;
 ; Things that BasicAA can prove points to constant memory should be
 ; liveOnEntry, as well.
 
 declare void @clobberAllTheThings()
 
 @str = private unnamed_addr constant [2 x i8] c"hi"

llvm/test/Analysis/MemorySSA/cyclicphi.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 
 %struct.hoge = type { i32, %struct.widget }
 %struct.widget = type { i64 }
 
 define hidden void @quux(%struct.hoge *%f) align 2 {
   %tmp = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1, i32 0
   %tmp24 = getelementptr inbounds %struct.hoge, %struct.hoge* %f, i64 0, i32 1

llvm/test/Analysis/MemorySSA/function-clobber.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Ensuring that external functions without attributes are MemoryDefs
 
 @g = external global i32
 declare void @modifyG()
 
 define i32 @foo() {

llvm/test/Analysis/MemorySSA/function-mem-attrs.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Test that various function attributes give us sane results.
 
 @g = external global i32
 
 declare void @readonlyFunction() readonly
 declare void @noattrsFunction()

llvm/test/Analysis/MemorySSA/lifetime-simple.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ; This test checks that lifetime markers are considered clobbers of %P,
 ; and due to lack of noalias information, of %Q as well.
 
 define i8 @test(i8* %P, i8* %Q) {
 entry:
 ; CHECK:  1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT:   call void @llvm.lifetime.start.p0i8(i64 32, i8* %P)

llvm/test/Analysis/MemorySSA/load-invariant.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>' -verify-memoryssa -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Invariant loads should be considered live on entry, because, once the
 ; location is known to be dereferenceable, the value can never change.
 
 @g = external global i32
 
 declare void @clobberAllTheThings()

llvm/test/Analysis/MemorySSA/many-dom-backedge.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; many-dom.ll, with an added back-edge back into the switch.
 ; Because people love their gotos.
 
 declare i1 @getBool() readnone
 
 define i32 @foo(i32* %p) {

llvm/test/Analysis/MemorySSA/many-doms.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Testing many dominators, specifically from a switch statement in C.
 
 declare i1 @getBool() readnone
 
 define i32 @foo(i32* %p) {
 entry:

llvm/test/Analysis/MemorySSA/multi-edges.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Makes sure we have a sane model if both successors of some block is the same
 ; block.
 
 define i32 @foo(i1 %a) {
 entry:
   %0 = alloca i32, align 4

llvm/test/Analysis/MemorySSA/multiple-backedges-hal.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 
 ; hfinkel's case
 ; [entry]
 ;  |
 ; .....
 ; (clobbering access - b)
 ;  |

llvm/test/Analysis/MemorySSA/multiple-locations.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Checks that basicAA is doing some amount of disambiguation for us
 
 define i32 @foo(i1 %cond) {
   %a = alloca i32, align 4
   %b = alloca i32, align 4
 ; CHECK: 1 = MemoryDef(liveOnEntry)

llvm/test/Analysis/MemorySSA/no-disconnected.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; This test ensures we don't end up with multiple reaching defs for a single
 ; use/phi edge If we were to optimize defs, we would end up with 2=
 ; MemoryDef(liveOnEntry) and 4 = MemoryDef(liveOnEntry) Both would mean both
 ; 1,2, and 3,4 would reach the phi node.  Because the phi node can only have one
 ; entry on each edge, it would choose 2, 4 and disconnect 1 and 3 completely
 ; from the SSA graph, even though they are not dead

llvm/test/Analysis/MemorySSA/noalias-scope-decl.ll

-; RUN: opt -basic-aa -memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Ensures that llvm.experimental.noalias.scope.decl is treated as not reading or writing memory.
 
 declare void @llvm.experimental.noalias.scope.decl(metadata)
 
 define i32 @foo(i32* %a, i32* %b, i1 %c) {
 ; CHECK: 1 = MemoryDef(liveOnEntry)

llvm/test/Analysis/MemorySSA/optimize-use.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,NOLIMIT
-; RUN: opt -memssa-check-limit=0 -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,LIMIT
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,NOLIMIT
 ; RUN: opt -memssa-check-limit=0 -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,LIMIT
 
 ; Function Attrs: ssp uwtable
 define i32 @main() {
 entry:
 ; CHECK: 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT:   %call = call noalias i8* @_Znwm(i64 4)

llvm/test/Analysis/MemorySSA/phi-translation.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,NOLIMIT
-; RUN: opt -memssa-check-limit=0 -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,LIMIT
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,NOLIMIT
 ; RUN: opt -memssa-check-limit=0 -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,LIMIT
 
 ; %ptr can't alias %local, so we should be able to optimize the use of %local to
 ; point to the store to %local.
 ; CHECK-LABEL: define void @check
 define void @check(i8* %ptr, i1 %bool) {
 entry:

llvm/test/Analysis/MemorySSA/pr28880.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 
 ; This testcase is reduced from SingleSource/Benchmarks/Misc/fbench.c
 ; It is testing to make sure that the MemorySSA use optimizer
 ; comes up with right answers when dealing with multiple MemoryLocations
 ; over different blocks. See PR28880 for more details.
 @global = external hidden unnamed_addr global double, align 8
 @global.1 = external hidden unnamed_addr global double, align 8

llvm/test/Analysis/MemorySSA/pr36883.ll

-; RUN: opt -basic-aa -memoryssa -enable-new-pm=0 -analyze < %s 2>&1 -S | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -S < %s 2>&1 | FileCheck %s
 ;
 ; We weren't properly considering the args in callsites in equality or hashing.
 
 target triple = "armv7-dcg-linux-gnueabi"
 
 ; CHECK-LABEL: define <8 x i16> @vpx_idct32_32_neon
 define <8 x i16> @vpx_idct32_32_neon(i8* %p, <8 x i16> %v) {

llvm/test/Analysis/MemorySSA/print-dot-cfg-mssa.ll

-; RUN: opt -basic-aa -print-memoryssa -dot-cfg-mssa=out.dot -enable-new-pm=0 -analyze < %s 2>&1 > /dev/null
 ;RUN: FileCheck %s -input-file=out.dot
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>' -dot-cfg-mssa=out.dot < %s 2>&1 > /dev/null
 ;RUN: FileCheck %s -input-file=out.dot
 
 ; Test -dot-cfg-mssa option for -print-memoryssa.
 ; Test is based on following C code with some forwarding basic blocks
 ; added to show that only those blocks with memory ssa comments
 ; are colourized.

llvm/test/Analysis/MemorySSA/ptr-const-mem.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze -memssa-check-limit=0 < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>' -verify-memoryssa -disable-output -memssa-check-limit=0 < %s 2>&1 | FileCheck %s
 target datalayout = "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64"
 target triple = "amdgcn"
 
 @g4 = external unnamed_addr constant i8, align 1
 
 define signext i8 @cmp_constant(i8* %q, i8 %v) local_unnamed_addr {
 entry:

llvm/test/Analysis/MemorySSA/scalable-vec.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>' -verify-memoryssa -disable-output < %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: define <vscale x 4 x i32> @f(
 ; CHECK: 1 = MemoryDef(liveOnEntry)
 ; CHECK: MemoryUse(1) MustAlias
 define <vscale x 4 x i32> @f(<vscale x 4 x i32> %z) {
   %a = alloca <vscale x 4 x i32>
   store <vscale x 4 x i32> %z, <vscale x 4 x i32>* %a

llvm/test/Analysis/MemorySSA/volatile-clobber.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -enable-new-pm=0 -analyze < %s 2>&1 | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='print<memoryssa>,verify<memoryssa>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; Ensures that volatile stores/loads count as MemoryDefs
 
 ; CHECK-LABEL: define i32 @foo
 define i32 @foo() {
   %1 = alloca i32, align 4
 ; CHECK: 1 = MemoryDef(liveOnEntry)

llvm/test/Analysis/PostDominators/infinite-loop.ll

-; RUN: opt < %s -postdomtree -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
 
 @a = external global i32, align 4
 
 define void @fn1() {
 entry:
   store i32 5, i32* @a, align 4
   %call = call i32 (...) @foo()

llvm/test/Analysis/PostDominators/infinite-loop2.ll

-; RUN: opt < %s -postdomtree -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
 
 @a = external global i32, align 4
 
 define void @fn1() {
 entry:
   store i32 5, i32* @a, align 4
   %call = call i32 (...) @foo()

llvm/test/Analysis/PostDominators/infinite-loop3.ll

-; RUN: opt < %s -postdomtree -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
 
 @a = external global i32, align 4
 
 define void @fn1() {
 entry:
   store i32 5, i32* @a, align 4
   %call = call i32 (...) @foo()

llvm/test/Analysis/PostDominators/pr1098.ll

-; RUN: opt < %s -postdomtree -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
 ; PR932
 
 define void @foo(i1 %x) {
 ; CHECK: entry
 entry:
         br i1 %x, label %bb1, label %bb0
 bb0:            ; preds = %entry, bb0
         br label %bb0
 bb1:            ; preds = %entry
         br label %bb2
 bb2:            ; preds = %bb1
         ret void
 }
 

llvm/test/Analysis/PostDominators/pr24415.ll

-; RUN: opt < %s -postdomtree -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
 
 ; Function Attrs: nounwind ssp uwtable
 define void @foo() {
   br label %1
 
 ; <label>:1                                       ; preds = %0, %1
   br label %1

llvm/test/Analysis/PostDominators/pr6047_a.ll

-; RUN: opt < %s -postdomtree -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
 define internal void @f() {
 entry:
   br i1 undef, label %bb35, label %bb3.i
 
 bb3.i:
   br label %bb3.i
 

llvm/test/Analysis/PostDominators/pr6047_b.ll

-; RUN: opt < %s -postdomtree -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
 define internal void @f() {
 entry:
   br i1 undef, label %a, label %bb3.i
 
 a:
   br i1 undef, label %bb35, label %bb3.i
 

llvm/test/Analysis/PostDominators/pr6047_c.ll

-; RUN: opt < %s -postdomtree -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
 define internal void @f() {
 entry:
   br i1 undef, label %bb35, label %bb3.i
 
 bb3.i:
   br label %bb3.i
 

llvm/test/Analysis/PostDominators/pr6047_d.ll

-; RUN: opt < %s -postdomtree -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='print<postdomtree>' 2>&1 | FileCheck %s
 define internal void @f() {
 entry:
   br i1 1, label %a, label %b
 
 a:
 br label %c
 

llvm/test/Analysis/RegionInfo/20100809_bb_not_in_domtree.ll

-; RUN: opt -regions < %s
 ; RUN: opt < %s -passes='print<regions>'
 
 define i32 @main() nounwind {
 entry:
   br label %for.cond
 
 test:
   br label %for.cond

llvm/test/Analysis/RegionInfo/bad_node_traversal.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='print<regions>' -disable-output < %s 2>&1 | FileCheck %s
 
 ; While working on improvements to the region info analysis, this test
 ; case caused an incorrect region 3 => 8 to be detected.
 
 define internal i8 @wibble() {
 bb:
   br i1 true, label %bb1, label %bb8

llvm/test/Analysis/RegionInfo/block_sort.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @BZ2_blockSort() nounwind {
 start:

llvm/test/Analysis/RegionInfo/cond_loop.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @normal_condition() nounwind {
 "5":

llvm/test/Analysis/RegionInfo/condition_complicated.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define internal fastcc zeroext i8 @handle_compress() nounwind {
 end165:

llvm/test/Analysis/RegionInfo/condition_complicated_2.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define internal fastcc void @compress() nounwind {
 end33:

llvm/test/Analysis/RegionInfo/condition_forward_edge.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @normal_condition() nounwind {
 "0":

llvm/test/Analysis/RegionInfo/condition_same_exit.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @normal_condition() nounwind {
 "0":

llvm/test/Analysis/RegionInfo/condition_simple.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @normal_condition() nounwind {
 "0":

llvm/test/Analysis/RegionInfo/exit_in_condition.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define internal fastcc zeroext i8 @handle_compress() nounwind {
 entry:

llvm/test/Analysis/RegionInfo/infinite_loop.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s 
-; RUN: opt -passes='print<regions>' -disable-output < %s 2>&1
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
+; RUN: opt -stats -passes='print<regions>' -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
 
 define void @normal_condition() nounwind {
 0:
   br label %1
 1:
   br i1 1, label %2, label %3
 2:
   br label %2
 3:
   br label %4
 4:
   ret void
 }
-; CHECK-NOT: =>
-; CHECK: [0] 0 => <Function Return>
 ; STAT: 1 region - The # of regions

llvm/test/Analysis/RegionInfo/infinite_loop_2.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s 
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 ; RUN: opt -passes='print<regions>' -disable-output < %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @normal_condition() nounwind {
 "0":
   br label %"1"

llvm/test/Analysis/RegionInfo/infinite_loop_3.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s 
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @normal_condition() nounwind {
 "0":

llvm/test/Analysis/RegionInfo/infinite_loop_4.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s 
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @normal_condition() nounwind {
 "0":

llvm/test/Analysis/RegionInfo/infinite_loop_5_a.ll

-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='print<regions>' -disable-output < %s 2>&1 | FileCheck %s
 
 define void @normal_condition() nounwind {
 "0":
     br label %"7"
 "7":
     br i1 1, label %"1", label %"8"
 "1":

llvm/test/Analysis/RegionInfo/infinite_loop_5_b.ll

-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='print<regions>' -disable-output < %s 2>&1 | FileCheck %s
 
 define void @normal_condition() nounwind {
 "0":
     br label %"7"
 "7":
     br i1 1, label %"1", label %"9"
 "9":

llvm/test/Analysis/RegionInfo/infinite_loop_5_c.ll

-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='print<regions>' -disable-output < %s 2>&1 | FileCheck %s
 
 define void @normal_condition() nounwind {
 "0":
     br label %"7"
 "7":
     br i1 1, label %"1", label %"8"
 "1":

llvm/test/Analysis/RegionInfo/loop_with_condition.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @normal_condition() nounwind {
 "0":

llvm/test/Analysis/RegionInfo/loops_1.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define internal fastcc zeroext i8 @loops_1() nounwind {
 entry:

llvm/test/Analysis/RegionInfo/loops_2.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @meread_() nounwind {
 entry:

llvm/test/Analysis/RegionInfo/mix_1.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @a_linear_impl_fig_1() nounwind {
 "0":

llvm/test/Analysis/RegionInfo/multiple_exiting_edge.ll

-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb -disable-output < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn -disable-output < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @normal_condition_0() nounwind {
 bb38:                                             ; preds = %bb34, %bb34, %bb37
   switch i32 undef, label %bb42 [
     i32 67, label %bb42
     i32 90, label %bb41

llvm/test/Analysis/RegionInfo/nested_loops.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define internal fastcc zeroext i8 @handle_compress() nounwind {
 entry:

llvm/test/Analysis/RegionInfo/next.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt -passes='print<regions>' -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb  < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn  < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @MAIN__() nounwind {
 entry:

llvm/test/Analysis/RegionInfo/outgoing_edge.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 
 ; While working on improvements to the region info analysis, this test
 ; case caused an incorrect region bb2 => bb3 to be detected. It is incorrect
 ; because bb2 has an outgoing edge to bb4. This is interesting because
 ; bb2 dom bb3 and bb3 pdom bb2, which should have been enough to prevent incoming
 ; forward edges into the region and outgoing forward edges from the region.
 

llvm/test/Analysis/RegionInfo/outgoing_edge_1.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 
 ; While working on improvements to region info analysis, this test
 ; case caused an incorrect region bb2 => bb3 to be detected.
 
 define internal i8 @main_read() nounwind {
 bb:
    br label %bb1

llvm/test/Analysis/RegionInfo/paper.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define void @a_linear_impl_fig_1() nounwind {
 "0":

llvm/test/Analysis/RegionInfo/two_loops_same_header.ll

 ; REQUIRES: asserts
-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
-; RUN: opt -regions -stats -disable-output < %s 2>&1 | FileCheck -check-prefix=STAT %s
-; RUN: opt -regions -print-region-style=bb  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=BBIT %s
-; RUN: opt -regions -print-region-style=rn  -analyze -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' -stats 2>&1 | FileCheck -check-prefix=STAT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=bb < %s 2>&1 | FileCheck -check-prefix=BBIT %s
 ; RUN: opt -passes='print<regions>' -print-region-style=rn < %s 2>&1 | FileCheck -check-prefix=RNIT %s
 
 define internal fastcc zeroext i8 @handle_compress() nounwind {
 entry:

llvm/test/Analysis/RegionInfo/unreachable_bb.ll

-; RUN: opt -regions -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt < %s -passes='print<regions>' 2>&1 | FileCheck %s
 
 ; We should not crash if there are some bbs that are not reachable.
 define void @f() {
 entry:
   br label %for.pre
 
 notintree:                                        ; No predecessors!

llvm/test/Analysis/ScalarEvolution/2007-07-15-NegativeStride.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 ; PR1533
 
 @array = weak global [101 x i32] zeroinitializer, align 32    ; <[100 x i32]*> [#uses=1]
 
 ; CHECK: Loop %bb: backedge-taken count is 100
 
 define void @loop(i32 %x) {

llvm/test/Analysis/ScalarEvolution/2007-08-06-Unsigned.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 ; PR1597
 
 ; CHECK: Loop %bb: backedge-taken count is (-1 + (-1 * %x) + %y)
 
 define i32 @f(i32 %x, i32 %y) {
 entry:
         %tmp63 = icmp ult i32 %x, %y            ; <i1> [#uses=1]

llvm/test/Analysis/ScalarEvolution/2007-09-27-LargeStepping.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 ; PR1706
 
 ; CHECK: backedge-taken count is 13
 
 define i32 @f() {
 entry:
   br label %bb5

llvm/test/Analysis/ScalarEvolution/2007-11-18-OrInstruction.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 ; PR1810
 
 define void @fun() {
 entry:
         br label %header
 header:
         %i = phi i32 [ 1, %entry ], [ %i.next, %body ]

llvm/test/Analysis/ScalarEvolution/2008-02-11-ReversedCondition.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 ; CHECK: Loop %header: backedge-taken count is (0 smax %n)
 
 define void @foo(i32 %n) {
 entry:
   br label %header
 header:

llvm/test/Analysis/ScalarEvolution/2008-02-12-SMAXTripCount.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 ; PR2002
 
 ; CHECK: Loop %loop: backedge-taken count is (100 + (-100 smax %n))
 define void @foo(i8 %n) {
 entry:
   br label %loop
 loop:

llvm/test/Analysis/ScalarEvolution/2008-02-15-UMax.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 ; PR2003
 
 ; CHECK: umax
 
 define i32 @foo(i32 %n) {
 entry:
         br label %header

llvm/test/Analysis/ScalarEvolution/2008-05-25-NegativeStepToZero.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 ; PR2364
 
 ; CHECK: backedge-taken count is 61
 
 define i32 @func_6() nounwind  {
 entry:
   br label %bb5

llvm/test/Analysis/ScalarEvolution/2008-06-12-BinomialInt64.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>/dev/null
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>/dev/null
 ; PR2433
 
 define i32 @main1(i32 %argc, i8** %argv) nounwind  {
 entry:
   br i1 false, label %bb10, label %bb23
 
 bb10:   ; preds = %bb10, %entry

llvm/test/Analysis/ScalarEvolution/2008-07-12-UnneededSelect1.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
 ; PR2261
 
 ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'foo'
 ; CHECK-NOT: smax
 
 @lut = common global [256 x i8] zeroinitializer, align 32    ; <[256 x i8]*> [#uses=1]
 

llvm/test/Analysis/ScalarEvolution/2008-07-12-UnneededSelect2.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
 ; PR2070
 
 ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'a'
 ; CHECK-NOT: smax
 
 define i32 @a(i32 %x) nounwind  {
 entry:

llvm/test/Analysis/ScalarEvolution/2008-07-19-InfiniteLoop.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 ; PR2088
 
 ; CHECK: Unpredictable
 
 define void @fun() {
 entry:
         br label %loop
 loop:
         %i = phi i8 [ 0, %entry ], [ %i.next, %loop ]
         %i.next = add i8 %i, 4
         %cond = icmp ne i8 %i.next, 6
         br i1 %cond, label %loop, label %exit
 exit:
         ret void
 }

llvm/test/Analysis/ScalarEvolution/2008-07-19-WrappingIV.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 ; PR2088
 
 ; CHECK: backedge-taken count is 113
 
 define void @fun() {
 entry:
         br label %loop
 loop:
         %i = phi i8 [ 0, %entry ], [ %i.next, %loop ]
         %i.next = add i8 %i, 18
         %cond = icmp ne i8 %i.next, 4
         br i1 %cond, label %loop, label %exit
 exit:
         ret void
 }

llvm/test/Analysis/ScalarEvolution/2008-07-29-SGTTripCount.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 ; PR2607
 
 define i32 @_Z1aj(i32 %j) nounwind  {
 entry:
   icmp sgt i32 0, %j    ; <i1>:0 [#uses=1]
   br i1 %0, label %bb.preheader, label %return
 

llvm/test/Analysis/ScalarEvolution/2008-07-29-SMinExpr.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 ; PR2607
 
 define i32 @b(i32 %x, i32 %y) nounwind {
 entry:
   %cmp2 = icmp slt i32 %y, %x
   %cond3 = select i1 %cmp2, i32 %y, i32 %x
   %cmp54 = icmp slt i32 %cond3, -2147483632

llvm/test/Analysis/ScalarEvolution/2008-08-04-IVOverflow.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 ; PR2621
 
 define i32 @a() nounwind  {
 entry:
   br label %bb1
 
 bb:

llvm/test/Analysis/ScalarEvolution/2008-08-04-LongAddRec.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 ; PR2621
 
 define i32 @a() nounwind  {
 entry:
   br label %bb1
 
 bb:   ; preds = %bb1

llvm/test/Analysis/ScalarEvolution/2008-11-18-LessThanOrEqual.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
 
 ; CHECK: Loop %bb: backedge-taken count is (7 + (-1 * %argc))
 
 define i32 @main(i32 %argc, i8** %argv) nounwind {
 entry:
   %0 = icmp ugt i32 %argc, 7    ; <i1> [#uses=1]
   br i1 %0, label %bb2, label %bb.nph

llvm/test/Analysis/ScalarEvolution/2008-11-18-Stride1.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK: Loop %bb: backedge-taken count is ((-5 + %x) /u 3)
 ; CHECK: Loop %bb: max backedge-taken count is 1431655764
 
 
 ; ScalarEvolution can't compute a trip count because it doesn't know if
 ; dividing by the stride will have a remainder. This could theoretically

llvm/test/Analysis/ScalarEvolution/2008-11-18-Stride2.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
 
 ; CHECK: Loop %bb: backedge-taken count is (((-3 + (-1 * (1 umin (-3 + (-1 * %x) + (1000 umax (3 + %x)))))<nuw><nsw> + (-1 * %x) + (1000 umax (3 + %x))) /u 3) + (1 umin (-3 + (-1 * %x) + (1000 umax (3 + %x)))))
 ; CHECK: Loop %bb: max backedge-taken count is 334
 
 
 ; This is a tricky testcase for unsigned wrap detection which ScalarEvolution
 ; doesn't yet know how to do.

llvm/test/Analysis/ScalarEvolution/2008-12-08-FiniteSGE.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK: backedge-taken count is 255
 
 define i32 @foo(i32 %x, i32 %y, i32* %lam, i32* %alp) nounwind {
 bb1.thread:
   br label %bb1
 

llvm/test/Analysis/ScalarEvolution/2008-12-11-SMaxOverflow.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK: @f
 ; CHECK: Loop %bb16.preheader: backedge-taken count is (-1 + %c.idx.val)
 
 define i32 @f(i32 %c.idx.val) {
 
 bb2:

llvm/test/Analysis/ScalarEvolution/2008-12-14-StrideAndSigned.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 |  FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 |  FileCheck %s
 ; XFAIL: *
 
 ; CHECK: (((-1 * %i0) + (100005 smax %i0)) /u 5)
 
 define i32 @foo0(i32 %i0) nounwind {
 entry:
   br label %bb1

llvm/test/Analysis/ScalarEvolution/2008-12-15-DontUseSDiv.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
 
 ; CHECK: /u 5
 
 define i8 @foo0(i8 %i0) nounwind {
 entry:
   br label %bb1
 

llvm/test/Analysis/ScalarEvolution/2009-01-02-SignedNegativeStride.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 ; PR3275
 
 ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'func_15'
 ; CHECK-NOT: /u -1
 
 @g_16 = external global i16   ; <i16*> [#uses=3]
 @.str = external constant [4 x i8]    ; <[4 x i8]*> [#uses=0]

llvm/test/Analysis/ScalarEvolution/2009-04-22-TruncCast.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'test1'
 ; CHECK-NOT: (trunc i{{.*}}ext
 
 define i16 @test1(i8 %x) {
   %A = sext i8 %x to i32
   %B = trunc i32 %A to i16

llvm/test/Analysis/ScalarEvolution/2009-05-09-PointerEdgeCount.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 ; PR3171
 
 ; CHECK: count is 2
 
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
   %struct.Foo = type { i32 }

llvm/test/Analysis/ScalarEvolution/2010-09-03-RequiredTransitive.ll

-; RUN: opt -indvars -scalar-evolution -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt "-passes=loop(indvars),print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
 ; This test checks if the SCEV analysis is printed out at all.
 ; It failed once as the RequiredTransitive option was not implemented
 ; correctly.
 
 ; CHECK: Classifying expressions for: @main
 
 define i32 @main() nounwind {

llvm/test/Analysis/ScalarEvolution/2011-04-26-FoldAddRec.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -iv-users
 ; RUN: opt < %s -disable-output -iv-users
 ; RUN: opt < %s -passes='print<iv-users>'
 ; PR9633: Tests that SCEV handles the mul.i2 recurrence being folded to
 ; constant zero.
 
 define signext i8 @func_14(i8 signext %p_18) nounwind readnone ssp {
 entry:
   br label %for.inc

llvm/test/Analysis/ScalarEvolution/2011-10-04-ConstEvolve.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; Exercise getConstantEvolvingPHIOperands on an interesting loop.
 ; This should complete in milliseconds, not minutes.
 
 ; Just check that it actually ran trip count analysis.
 ; CHECK: Determining loop execution counts for: @test
 define void @test() nounwind {

llvm/test/Analysis/ScalarEvolution/SolveQuadraticEquation.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
 
 ; PR1101
 
 @A = weak global [1000 x i32] zeroinitializer, align 32         
 
 define void @test1(i32 %N) {
 entry:

llvm/test/Analysis/ScalarEvolution/ZeroStep.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s  -o - -S | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s  -o - -S 2>&1 | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 ; Test that SCEV is capable of figuring out value of 'IV' that actually does not change.
 ; CHECK: Classifying expressions for: @foo
 ; CHECK: %iv.i = phi i64

llvm/test/Analysis/ScalarEvolution/abs-intrinsic.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 declare i32 @llvm.abs.i32(i32, i1)
 
 define i32 @abs_nonsw(i32 %x) {
 ; CHECK-LABEL: 'abs_nonsw'
 ; CHECK-NEXT:  Classifying expressions for: @abs_nonsw
 ; CHECK-NEXT:    %r = call i32 @llvm.abs.i32(i32 %x, i1 false)

llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; Reduced from test-suite/MultiSource/Benchmarks/MiBench/office-ispell/correct.c
 ; getelementptr, obviously, takes pointer as it's base, and returns a pointer.
 ; SCEV operands are sorted in hope that it increases folding potential,
 ; and at the same time SCEVAddExpr's type is the type of the last(!) operand.
 ; Which means, in some exceedingly rare cases, pointer operand may happen to
 ; end up not being the last operand, and as a result SCEV for GEP will suddenly

llvm/test/Analysis/ScalarEvolution/add-like-or.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 define i8 @or-of-constant-with-no-common-bits-set(i8 %x, i8 %y) {
 ; CHECK-LABEL: 'or-of-constant-with-no-common-bits-set'
 ; CHECK-NEXT:  Classifying expressions for: @or-of-constant-with-no-common-bits-set
 ; CHECK-NEXT:    %t0 = shl i8 %x, 2
 ; CHECK-NEXT:    --> (4 * %x) U: [0,-3) S: [-128,125)
 ; CHECK-NEXT:    %r = or i8 %t0, 3
 ; CHECK-NEXT:    --> (3 + (4 * %x))<nuw><nsw> U: [3,0) S: [-125,-128)
 ; CHECK-NEXT:  Determining loop execution counts for: @or-of-constant-with-no-common-bits-set
 ;
   %t0 = shl i8 %x, 2
   %r = or i8 %t0, 3
   ret i8 %r
 }

llvm/test/Analysis/ScalarEvolution/and-xor.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: @test1
 ; CHECK: -->  (zext
 ; CHECK: -->  (zext
 ; CHECK-NOT: -->  (zext
 
 define i32 @test1(i32 %x) {

llvm/test/Analysis/ScalarEvolution/ashr.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s --data-layout="e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s --data-layout="e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
-; RUN: opt < %s --data-layout="e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s --data-layout="e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; In general, we can't deal with ashr.
 define i32 @t0(i32 %x, i32 %y) {
 ; CHECK-LABEL: 't0'
 ; CHECK-NEXT:  Classifying expressions for: @t0
 ; CHECK-NEXT:    %i0 = ashr i32 %x, %y
 ; CHECK-NEXT:    --> %i0 U: full-set S: full-set

llvm/test/Analysis/ScalarEvolution/avoid-smax-0.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 ; CHECK: Loop %bb3: backedge-taken count is (-1 + %n)
 
 ; We don't want to use a max in the trip count expression in
 ; this testcase.
 
 define void @foo(i32 %n, i32* %p, i32* %q) nounwind {

llvm/test/Analysis/ScalarEvolution/avoid-smax-1.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -S | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -S 2>&1 | FileCheck %s
 
 ; Indvars should be able to find the trip count for the bb6 loop
 ; without using a maximum calculation (icmp, select) because it should
 ; be able to prove that the comparison is guarded by an appropriate
 ; conditional branch. Unfortunately, indvars is not yet able to find
 ; the comparison for the other two loops in this testcase.
 ;

llvm/test/Analysis/ScalarEvolution/binomial-explision.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
 
 ; Check that we don't have unreasonably huge SCEVs and in particular only a
 ; reasonable amount of AddRecs in the notation of %tmp19. If we "simplify" SCEVs
 ; too aggressively, we may end up with huge nested expressions.
 define void @test(i32 %x, i64 %y, i1 %cond) {

llvm/test/Analysis/ScalarEvolution/constant_condition.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define i32 @branch_true(i32 %x, i32 %y) {
 ; CHECK-LABEL: Classifying expressions for: @branch_true
  entry:
   br i1 true, label %add, label %merge
 
  add:

llvm/test/Analysis/ScalarEvolution/different-loops-recs.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; This test set ensures that we can correctly operate with recurrencies from
 ; different loops.
 
 ; Check that we can evaluate a sum of phis from two different loops in any
 ; order.
 

llvm/test/Analysis/ScalarEvolution/div-overflow.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 ; CHECK: -->  ((-128 * %a) /u -128)
 
 ; Don't let ScalarEvolution fold this div away.
 
 define i8 @foo(i8 %a) {
         %t0 = shl i8 %a, 7
         %t1 = lshr i8 %t0, 7
         ret i8 %t1
 }

llvm/test/Analysis/ScalarEvolution/do-loop.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 ; PR1614
 
 ; CHECK: smax
 
 define i32 @f(i32 %x, i32 %y) {
 entry:
   br label %bb

llvm/test/Analysis/ScalarEvolution/exact-exit-count-more-precise.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" %s 2>&1 | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @test_and(i16 %in) {
 ; CHECK-LABEL: 'test_and'
 ; CHECK-NEXT:  Classifying expressions for: @test_and
 ; CHECK-NEXT:    %_tmp25.i = phi i16 [ %in, %bb2 ], [ %_tmp6.i, %bb1.i ]

llvm/test/Analysis/ScalarEvolution/exact_iter_count.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 ; One side exit dominating the latch, exact backedge taken count is known.
 define void @test_01() {
 
 ; CHECK-LABEL: Determining loop execution counts for: @test_01
 ; CHECK-NEXT:  Loop %loop: <multiple exits> backedge-taken count is 50
 

llvm/test/Analysis/ScalarEvolution/exhaustive-trip-counts.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @f_0() {
 ; CHECK-LABEL: Printing analysis 'Scalar Evolution Analysis' for function 'f_0':
 ; CHECK: Loop %for.body: backedge-taken count is 5

llvm/test/Analysis/ScalarEvolution/exit-count-select.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" %s 2>&1 | FileCheck %s
 
 
 ; exact-not-taken cannot be umin(n, m) because it is possible for (n, m) to be (0, poison)
 ; https://alive2.llvm.org/ce/z/NsP9ue
 define void @logical_and(i32 %n, i32 %m) {
 ; CHECK-LABEL: 'logical_and'
 ; CHECK-NEXT:  Classifying expressions for: @logical_and

llvm/test/Analysis/ScalarEvolution/exponential-behavior.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'f':
 
 ; CHECK: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
 ; CHECK: Loop %loop: max backedge-taken count is 0
 ; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
 

llvm/test/Analysis/ScalarEvolution/extract-highbits-sameconstmask.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; The obvious case.
 define i32 @div(i32 %val) nounwind {
 ; CHECK-LABEL: 'div'
 ; CHECK-NEXT:  Classifying expressions for: @div
 ; CHECK-NEXT:    %tmp1 = udiv i32 %val, 16
 ; CHECK-NEXT:    --> (%val /u 16) U: [0,268435456) S: [0,268435456)

llvm/test/Analysis/ScalarEvolution/extract-highbits-variablemask.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; These testcases aren't *identical* but they have the same/similar meaning.
 
 ; The obvious case.
 define i32 @div(i32 %val, i32 %num) nounwind {
 ; CHECK-LABEL: 'div'
 ; CHECK-NEXT:  Classifying expressions for: @div

llvm/test/Analysis/ScalarEvolution/extract-lowbits-sameconstmask.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; The obvious case.
 define i32 @mul(i32 %val) nounwind {
 ; CHECK-LABEL: 'mul'
 ; CHECK-NEXT:  Classifying expressions for: @mul
 ; CHECK-NEXT:    %tmp1 = mul i32 %val, 16
 ; CHECK-NEXT:    -->  (16 * %val) U: [0,-15) S: [-2147483648,2147483633)

llvm/test/Analysis/ScalarEvolution/extract-lowbits-variablemask.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; These testcases aren't *identical* but they have the same/similar meaning.
 
 ; The obvious case.
 define i32 @mul(i32 %val, i32 %num) nounwind {
 ; CHECK-LABEL: 'mul'
 ; CHECK-NEXT:  Classifying expressions for: @mul

llvm/test/Analysis/ScalarEvolution/flags-from-poison-dbg.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; Make sure poison value tracking works in the presence of @llvm.dbg
 ; intrinsics.  Unfortunately, I was not able to reduce this file
 ; further while still keeping the debug info well formed.
 
 define void @foo(i32 %n, i32* %arr) !dbg !7 {
 ; CHECK-LABEL: Classifying expressions for: @foo

llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll

-; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; Positive and negative tests for inferring flags like nsw from
 ; reasoning about how a poison value from overflow would trigger
 ; undefined behavior.
 
 define void @foo() {
   ret void

llvm/test/Analysis/ScalarEvolution/flattened-0.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 define void @foo([7 x i8]* %a) {
 ; CHECK-LABEL: @foo
 entry:
   br label %bb
 
 bb:

llvm/test/Analysis/ScalarEvolution/fold.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S < %s 2>&1 | FileCheck %s
 
 define i16 @test1(i8 %x) {
   %A = zext i8 %x to i12
   %B = sext i12 %A to i16
 ; CHECK: zext i8 %x to i16
   ret i16 %B
 }

llvm/test/Analysis/ScalarEvolution/how-far-to-zero.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; PR13228
 define void @f() nounwind uwtable readnone {
 entry:
   br label %for.cond
 
 for.cond:                                         ; preds = %for.cond, %entry

llvm/test/Analysis/ScalarEvolution/huge_expression_limit.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-huge-expr-threshold=1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-huge-expr-threshold=1 2>&1 | FileCheck %s
 
 define void @test(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f) {
 ; CHECK-LABEL: 'test'
 ; CHECK-NEXT:  Classifying expressions for: @test
 ; CHECK-NEXT:    %add1 = add i32 %a, %b
 ; CHECK-NEXT:    --> (%a + %b) U: full-set S: full-set
 ; CHECK-NEXT:    %add2 = add i32 %add1, %c

llvm/test/Analysis/ScalarEvolution/implied-via-division.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 declare void @llvm.experimental.guard(i1, ...)
 
 define void @test_1(i32 %n) nounwind {
 ; Prove that (n > 1) ===> (n / 2 > 0).
 ; CHECK:         Determining loop execution counts for: @test_1
 ; CHECK:         Loop %header: backedge-taken count is (-1 + %n.div.2)<nsw>

llvm/test/Analysis/ScalarEvolution/incorrect-exit-count.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -scalar-evolution < %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt -passes='print<scalar-evolution>' < %s -disable-output 2>&1 | FileCheck %s
 
 @b = dso_local global i32 5, align 4
 @__const.f.g = private unnamed_addr constant [1 x [4 x i16]] [[4 x i16] [i16 1, i16 0, i16 0, i16 0]], align 2
 @a = common dso_local global i32 0, align 4
 @c = common dso_local global i32 0, align 4
 @d = common dso_local global i32 0, align 4
 @e = common dso_local global i32 0, align 4

llvm/test/Analysis/ScalarEvolution/incorrect-nsw.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>,print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @bad.nsw() {
 ; CHECK-LABEL: Classifying expressions for: @bad.nsw
 ; CHECK-LABEL: Classifying expressions for: @bad.nsw
  entry: 
   br label %loop
 

llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @f0(i1 %c) {
 ; CHECK-LABEL: 'f0'
 ; CHECK-NEXT:  Classifying expressions for: @f0
 ; CHECK-NEXT:    %start = select i1 %c, i32 127, i32 0
 ; CHECK-NEXT:    --> %start U: [0,128) S: [0,128)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -1, i32 1

llvm/test/Analysis/ScalarEvolution/infer-prestart-no-wrap.ll

-; ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @infer.sext.0(i1* %c, i32 %start, i32* %buf) {
 ; CHECK-LABEL: Classifying expressions for: @infer.sext.0
  entry:
   br label %loop
 
  loop:

llvm/test/Analysis/ScalarEvolution/inner-loop-by-latch-cond-unknown.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -iv-users -S | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<iv-users>" -S 2>&1 | FileCheck %s
 
 ; This is a regression test for the commit rL327362.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @test(i64 %a, i64* %p) {

llvm/test/Analysis/ScalarEvolution/limit-depth.ll

-; RUN: opt -scalar-evolution-max-arith-depth=0 -scalar-evolution-max-cast-depth=0 -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -scalar-evolution-max-arith-depth=0 -scalar-evolution-max-cast-depth=0 -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; Check that depth set to 0 prevents getAddExpr and getMulExpr from making
 ; transformations in SCEV. We expect the result to be very straightforward.
 
 define void @test_add(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f) {
 ; CHECK-LABEL: @test_add
 ; CHECK:       %s2 = add i32 %s1, %p3

llvm/test/Analysis/ScalarEvolution/load-with-range-metadata.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define i32 @slt_trip_count_with_range(i32 *%ptr0, i32 *%ptr1) {
 ; CHECK-LABEL: slt_trip_count_with_range
  entry:
   %limit = load i32, i32* %ptr0, !range !0
   br label %loop
 

llvm/test/Analysis/ScalarEvolution/load.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
 target triple = "i386-pc-linux-gnu"
 
 @arr1 = internal unnamed_addr constant [50 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 48, i32 49, i32 50], align 4
 @arr2 = internal unnamed_addr constant [50 x i32] [i32 49, i32 48, i32 47, i32 46, i32 45, i32 44, i32 43, i32 42, i32 41, i32 40, i32 39, i32 38, i32 37, i32 36, i32 35, i32 34, i32 33, i32 32, i32 31, i32 30, i32 29, i32 28, i32 27, i32 26, i32 25, i32 24, i32 23, i32 22, i32 21, i32 20, i32 19, i32 18, i32 17, i32 16, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0], align 4
 

llvm/test/Analysis/ScalarEvolution/lshr-shl-differentconstmask.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; The obvious case.
 define i32 @udiv_biggerLshr(i32 %val) nounwind {
 ; CHECK-LABEL: 'udiv_biggerLshr'
 ; CHECK-NEXT:  Classifying expressions for: @udiv_biggerLshr
 ; CHECK-NEXT:    %tmp1 = udiv i32 %val, 64
 ; CHECK-NEXT:    -->  (%val /u 64) U: [0,67108864) S: [0,67108864)

llvm/test/Analysis/ScalarEvolution/max-addops-inline.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scev-addops-inline-threshold=1 < %s | FileCheck --check-prefix=CHECK1 %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scev-addops-inline-threshold=1 < %s 2>&1 | FileCheck --check-prefix=CHECK1 %s
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scev-addops-inline-threshold=10 < %s | FileCheck --check-prefix=CHECK10 %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scev-addops-inline-threshold=10 < %s 2>&1 | FileCheck --check-prefix=CHECK10 %s
 
 define i32 @foo(i64 %p0, i32 %p1) {
 ; CHECK1: %add2 = add nsw i32 %mul1, %add
 ; CHECK1-NEXT: -->  ((trunc i64 %p0 to i32) * (1 + (trunc i64 %p0 to i32)) * (1 + %p1))
 
 ; CHECK10: %add2 = add nsw i32 %mul1, %add
 ; CHECK10-NEXT: -->  ((trunc i64 %p0 to i32) * (1 + ((trunc i64 %p0 to i32) * (1 + %p1)) + %p1))
 entry:
   %tr = trunc i64 %p0 to i32
   %mul = mul nsw i32 %tr, %p1
   %add = add nsw i32 %mul, %tr
   %mul1 = mul nsw i32 %add, %tr
   %add2 = add nsw i32 %mul1, %add
   ret i32 %add2
 }

llvm/test/Analysis/ScalarEvolution/max-addrec-size.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-add-rec-size=3 < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-add-rec-size=3 < %s 2>&1 | FileCheck %s
 
 ; Show that we are able to avoid creation of huge SCEVs by capping the max
 ; AddRec size.
 define i32 @test_01(i32 %a, i32 %b) {
 
 ; CHECK-LABEL: Classifying expressions for: @test_01
 ; CHECK-NEXT:    %iv = phi i32 [ %a, %entry ], [ %iv.next, %loop ]

llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -scalar-evolution %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt -passes='print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck %s
 
 ; Test case for PR40961. The loop guard limit the max backedge-taken count.
 
 define void @test_guard_less_than_16(i32* nocapture %a, i64 %i) {
 ; CHECK-LABEL: 'test_guard_less_than_16'
 ; CHECK-NEXT:  Classifying expressions for: @test_guard_less_than_16
 ; CHECK-NEXT:    %iv = phi i64 [ %iv.next, %loop ], [ %i, %entry ]

llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-limit-by-wrapping.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0  -scalar-evolution-classify-expressions=0  | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0  -scalar-evolution-classify-expressions=0  2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @max_backedge_taken_count_by_wrapping1_nsw_nuw(i8 %N, i8* %ptr) {
 ; CHECK-LABEL: Determining loop execution counts for: @max_backedge_taken_count_by_wrapping1_nsw_nuw
 ; CHECK-NEXT:  Loop %loop: backedge-taken count is (%N /u 4)

llvm/test/Analysis/ScalarEvolution/max-be-count-not-constant.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Previously in this case the max backedge count would be computed as 1/0, which
 ; is correct but undesirable.  It would also not fold as a constant, tripping
 ; asserts in SCEV.

llvm/test/Analysis/ScalarEvolution/max-expr-cache.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; SCEV would take a long time to compute SCEV expressions for this IR.  If SCEV
 ; finishes in < 1 second then the bug is fixed.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux-gnu"
 

llvm/test/Analysis/ScalarEvolution/max-mulops-inline.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scev-mulops-inline-threshold=1 < %s | FileCheck --check-prefix=CHECK1 %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scev-mulops-inline-threshold=1 < %s 2>&1 | FileCheck --check-prefix=CHECK1 %s
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scev-mulops-inline-threshold=10 < %s | FileCheck --check-prefix=CHECK10 %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scev-mulops-inline-threshold=10 < %s 2>&1 | FileCheck --check-prefix=CHECK10 %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @a = local_unnamed_addr global i32 0, align 4
 @b = local_unnamed_addr global i32 0, align 4
 

llvm/test/Analysis/ScalarEvolution/max-trip-count-address-space.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; ScalarEvolution should be able to understand the loop and eliminate the casts.
 
 target datalayout = "e-p:32:32:32-p1:16:16:16-p2:8:8:8-p4:64:64:64-n16:32:64"
 
 ; CHECK:  {%d,+,4}<%bb>{{ U: [^ ]+ S: [^ ]+}}{{ *}} Exits: (-4 + (4 * (trunc i32 %n to i16)) + %d)
 

llvm/test/Analysis/ScalarEvolution/max-trip-count.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; ScalarEvolution should be able to understand the loop and eliminate the casts.
 
 ; CHECK: {%d,+,4}
 
 define void @foo(i32* nocapture %d, i32 %n) nounwind {
 entry:

llvm/test/Analysis/ScalarEvolution/merge-add-rec-many-inputs.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; Check that isImpliedViaMerge wouldn't crash when trying to prove
 ; SCEVUnknown and AddRec with phi having many inputs
 ; CHECK: @foo
 
 define void @foo(i1 %cond) {
 osr.type.merge79:

llvm/test/Analysis/ScalarEvolution/min-max-exprs.ll

-; RUN: opt -scalar-evolution -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt "-passes=print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
 ;
 ; This checks if the min and max expressions are properly recognized by
 ; ScalarEvolution even though they the ICmpInst and SelectInst have different
 ; types.
 ;
 ;    #define max(a, b) (a > b ? a : b)
 ;    #define min(a, b) (a < b ? a : b)

llvm/test/Analysis/ScalarEvolution/minmax-intrinsics.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 declare i32 @llvm.umax.i32(i32, i32)
 declare i32 @llvm.umin.i32(i32, i32)
 declare i32 @llvm.smax.i32(i32, i32)
 declare i32 @llvm.smin.i32(i32, i32)
 
 define i32 @umax(i32 %x, i32 %y) {

llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 !0 = !{i8 0, i8 127}
 
 define void @f0(i8* %len_addr) {
 ; CHECK-LABEL: 'f0'
 ; CHECK-NEXT:  Classifying expressions for: @f0
 ; CHECK-NEXT:    %len = load i8, i8* %len_addr, align 1, !range !0

llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -S -scalar-evolution-use-expensive-range-sharpening -analyze -scalar-evolution -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -S -scalar-evolution-use-expensive-range-sharpening -passes='print<scalar-evolution>' 2>&1 | FileCheck %s
 
 define i32 @test_01(i32 %start, i32* %p, i32* %q) {
 ; CHECK-LABEL: 'test_01'
 ; CHECK-NEXT:  Classifying expressions for: @test_01
 ; CHECK-NEXT:    %0 = zext i32 %start to i64
 ; CHECK-NEXT:    --> (zext i32 %start to i64) U: [0,4294967296) S: [0,4294967296)
 ; CHECK-NEXT:    %indvars.iv = phi i64 [ %indvars.iv.next, %backedge ], [ %0, %entry ]

llvm/test/Analysis/ScalarEvolution/no-wrap-unknown-becount.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 declare void @llvm.experimental.guard(i1, ...)
 declare void @llvm.assume(i1)
 
 define void @s_0(i32 %n, i1* %cond) {
 ; CHECK-LABEL: Classifying expressions for: @s_0
 entry:

llvm/test/Analysis/ScalarEvolution/non-IV-phi.ll

-; RUN: opt -scalar-evolution -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt "-passes=print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
 
 define void @test1(i8 %t, i32 %len) {
 ; CHECK-LABEL: test1
 ; CHECK: %sphi = phi i32 [ %ext, %entry ], [ %idx.inc.ext, %loop ]
 ; CHECK-NEXT:  -->  (zext i8 {%t,+,1}<%loop> to i32)
 
  entry:

llvm/test/Analysis/ScalarEvolution/nowrap-preinc-limits.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @f(i1* %condition) {
 ; CHECK-LABEL: Classifying expressions for: @f
  entry: 
   br label %loop
 
  loop:

llvm/test/Analysis/ScalarEvolution/nsw-offset-assume.ll

-; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; ScalarEvolution should be able to fold away the sign-extensions
 ; on this loop with a primary induction variable incremented with
 ; a nsw add of 2 (this test is derived from the nsw-offset.ll test, but uses an
 ; assume instead of a preheader conditional branch to guard the loop).
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"

llvm/test/Analysis/ScalarEvolution/nsw-offset.ll

-; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; ScalarEvolution should be able to fold away the sign-extensions
 ; on this loop with a primary induction variable incremented with
 ; a nsw add of 2.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
 

llvm/test/Analysis/ScalarEvolution/nsw.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; The addrecs in this loop are analyzable only by using nsw information.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
 
 ; CHECK: Classifying expressions for: @test1
 define void @test1(double* %p) nounwind {

llvm/test/Analysis/ScalarEvolution/overflow-intrinsics-trip-count.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 declare { i16, i1 } @llvm.sadd.with.overflow.i16(i16, i16) nounwind readnone
 declare { i16, i1 } @llvm.uadd.with.overflow.i16(i16, i16) nounwind readnone
 declare { i16, i1 } @llvm.ssub.with.overflow.i16(i16, i16) nounwind readnone
 declare { i16, i1 } @llvm.usub.with.overflow.i16(i16, i16) nounwind readnone
 declare { i16, i1 } @llvm.smul.with.overflow.i16(i16, i16) nounwind readnone
 declare { i16, i1 } @llvm.umul.with.overflow.i16(i16, i16) nounwind readnone

llvm/test/Analysis/ScalarEvolution/overflow-intrinsics.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @f_sadd_0(i8* %a) {
 ; CHECK-LABEL: Classifying expressions for: @f_sadd_0
 entry:

llvm/test/Analysis/ScalarEvolution/pr22179.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 %struct.anon = type { i8 }
 %struct.S = type { i32 }
 
 @a = common global %struct.anon zeroinitializer, align 1
 @b = common global %struct.S zeroinitializer, align 4
 

llvm/test/Analysis/ScalarEvolution/pr22641.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define i1 @main(i16 %a) {
 ; CHECK-LABEL: Classifying expressions for: @main
 entry:
   br label %body
 
 body:

llvm/test/Analysis/ScalarEvolution/pr24757.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; CHECK: Loop %bb1: backedge-taken count is ((2 * %a.promoted) /u 2)
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 @a = global i8 -127, align 1

llvm/test/Analysis/ScalarEvolution/pr25369.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @hoge1() {
 ; CHECK-LABEL: Classifying expressions for: @hoge1
 bb:

llvm/test/Analysis/ScalarEvolution/pr27315.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 declare i1 @use(i64)
 
 define void @f_0() {
 ; CHECK-LABEL: Classifying expressions for: @f_0
 
 ; CHECK:  %iv = phi i32 [ 0, %entry ], [ %iv.inc.nowrap, %be ]

llvm/test/Analysis/ScalarEvolution/pr34538.ll

-; RUN: opt -scalar-evolution -loop-deletion -simplifycfg -analyze -enable-new-pm=0 < %s | FileCheck %s --check-prefix=CHECK-ANALYSIS-1
 ; RUN: opt "-passes=print<scalar-evolution>,loop(loop-deletion),simplifycfg" -disable-output < %s 2>&1 | FileCheck %s --check-prefix=CHECK-ANALYSIS-1
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s --check-prefix=CHECK-ANALYSIS-2
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s --check-prefix=CHECK-ANALYSIS-2
 
 define i32 @pr34538() local_unnamed_addr #0 {
 ; CHECK-ANALYSIS-1: Loop %do.body: backedge-taken count is 10000
 ; CHECK-ANALYSIS-1: Loop %do.body: max backedge-taken count is 10000
 ; CHECK-ANALYSIS-1: Loop %do.body: Predicated backedge-taken count is 10000
 entry:
   br label %do.body

llvm/test/Analysis/ScalarEvolution/pr40420.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
 ; REQUIRES: asserts
 
 define void @test(i8 %tmp6) {
 
 ; CHECK-LABEL: Classifying expressions for: @test
 
 bb:

llvm/test/Analysis/ScalarEvolution/pr46786.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 source_filename = "input.cpp"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 
 ; Function Attrs: nofree
 define i8* @FSE_decompress_usingDTable(i8* %arg, i32 %arg1, i32 %arg2, i32 %arg3) local_unnamed_addr #0 {
 ; CHECK-LABEL: 'FSE_decompress_usingDTable'

llvm/test/Analysis/ScalarEvolution/pr48225.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; Tests demonstrate the bug reported as PR48225 by Congzhe Cao.
 
 ; When %boolcond = false and %cond = 0:
 ; - %cond.false.on.first.iter is false on 1st iteration;
 ; - %cond.false.on.second.iter is false on 2nd iteration;
 ; - Therefore, their AND is false on first two iterations, and the backedge is taken twice.

llvm/test/Analysis/ScalarEvolution/pr49856.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 define void @test() {
 ; CHECK-LABEL: 'test'
 ; CHECK-NEXT:  Classifying expressions for: @test
 ; CHECK-NEXT:    %tmp = phi i32 [ 2, %bb ], [ %tmp2, %bb3 ]
 ; CHECK-NEXT:    --> %tmp U: [1,-2147483648) S: [0,-2147483648)
 ; CHECK-NEXT:    %tmp2 = add nuw nsw i32 %tmp, 1

llvm/test/Analysis/ScalarEvolution/predicated-trip-count.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 @A = weak global [1000 x i32] zeroinitializer, align 32
 
 ; The resulting predicate is i16 {0,+,1} <nssw>, meanining
 ; that the resulting backedge expression will be valid for:

llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s --data-layout="p:64:64:64:64" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=PTR64_IDX64 %s
 ; RUN: opt < %s --data-layout="p:64:64:64:64" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=PTR64_IDX64 %s
-; RUN: opt < %s --data-layout="p:64:64:64:32" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=PTR64_IDX32 %s
 ; RUN: opt < %s --data-layout="p:64:64:64:32" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=PTR64_IDX32 %s
-; RUN: opt < %s --data-layout="p:16:16:16:16" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=PTR16_IDX16 %s
 ; RUN: opt < %s --data-layout="p:16:16:16:16" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=PTR16_IDX16 %s
-; RUN: opt < %s --data-layout="p:16:16:16:32" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=PTR16_IDX32 %s
 ; RUN: opt < %s --data-layout="p:16:16:16:32" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=PTR16_IDX32 %s
 
 @global = external hidden global [0 x i8]
 
 declare void @use16(i16)
 
 define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) {
 ; PTR64_IDX64-LABEL: 'trunc_ptr_to_i64'

llvm/test/Analysis/ScalarEvolution/ptrtoint.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s --data-layout="e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=ALL,X64 %s
 ; RUN: opt < %s --data-layout="e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=ALL,X64 %s
-; RUN: opt < %s --data-layout="e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=ALL,X32 %s
 ; RUN: opt < %s --data-layout="e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=ALL,X32 %s
 
 ; While we can't treat inttoptr/ptrtoint casts as fully transparent,
 ; for ptrtoint cast, instead of modelling it as fully opaque (unknown),
 ; we can at least model it as zext/trunc/self of an unknown,
 ; iff it it's argument would be modelled as unknown anyways.
 
 declare void @useptr(i8*)

llvm/test/Analysis/ScalarEvolution/range-signedness.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @x(i1* %cond) {
 ; CHECK-LABEL: Classifying expressions for: @x
  entry:
   br label %loop
 
  loop:

llvm/test/Analysis/ScalarEvolution/range_nw_flag.ll

-; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; copied from flags-from-poison.ll
 ; CHECK-LABEL: @test-add-nuw
 ; CHECK: -->  {(1 + %offset)<nuw>,+,1}<nuw><%loop> U: [1,0) S: [1,0)
 define void @test-add-nuw(float* %input, i32 %offset, i32 %numIterations) {
 entry:
   br label %loop

llvm/test/Analysis/ScalarEvolution/ranges.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
- ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
  ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
 
 ; Collection of cases exercising range logic, mostly (but not exclusively)
 ; involving SCEVUnknowns.
 
 declare void @llvm.assume(i1)

llvm/test/Analysis/ScalarEvolution/returned.ll

-; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
 
 define i8* @foo(i32 %no, i8* nocapture %d) nounwind {
 entry:
   %v = call i8* @func1(i8* %d)
   %w = getelementptr i8, i8* %v, i64 5
   ret i8* %w
 }
 
 ; CHECK-LABEL: Classifying expressions for: @foo
 ; CHECK: %w = getelementptr i8, i8* %v, i64 5
 ; CHECK-NEXT: (5 + %d)
 
 declare i8* @func1(i8* returned) nounwind argmemonly
 

llvm/test/Analysis/ScalarEvolution/saturating-intrinsics.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 declare i32 @llvm.uadd.sat.i32(i32, i32)
 declare i32 @llvm.sadd.sat.i32(i32, i32)
 declare i32 @llvm.usub.sat.i32(i32, i32)
 declare i32 @llvm.ssub.sat.i32(i32, i32)
 declare i32 @llvm.ushl.sat.i32(i32, i32)
 declare i32 @llvm.sshl.sat.i32(i32, i32)

llvm/test/Analysis/ScalarEvolution/scalable-vector.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -scalar-evolution -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt "-passes=print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
 
 define void @a(<vscale x 1 x i64> *%p) {
 ; CHECK-LABEL: 'a'
 ; CHECK-NEXT:  Classifying expressions for: @a
 ; CHECK-NEXT:    %1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* null, i32 3
 ; CHECK-NEXT:    --> ((3 * sizeof(<vscale x 4 x i32>)) + null) U: [0,-15) S: [-9223372036854775808,9223372036854775793)
 ; CHECK-NEXT:    %2 = getelementptr <vscale x 1 x i64>, <vscale x 1 x i64>* %p, i32 1
 ; CHECK-NEXT:    --> (sizeof(<vscale x 1 x i64>) + %p) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @a
 ;
   getelementptr <vscale x 4 x i32>, <vscale x 4 x i32> *null, i32 3
   getelementptr <vscale x 1 x i64>, <vscale x 1 x i64> *%p, i32 1
   ret void
 }

llvm/test/Analysis/ScalarEvolution/scev-dispositions.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @single_loop(i32* %buf, i32 %start) {
 ; CHECK-LABEL: Classifying expressions for: @single_loop
  entry:
   %val = add i32 %start, 400
   br label %loop
 

llvm/test/Analysis/ScalarEvolution/scev-prestart-nowrap.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; An example run where SCEV(%postinc)->getStart() may overflow:
 ;
 ; %start = INT_SMAX
 ; %low.limit = INT_SMIN
 ; %high.limit = < not used >
 ;

llvm/test/Analysis/ScalarEvolution/sdiv.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
 ; CHECK-LABEL: '_Z4loopi'
 ; CHECK-NEXT:  Classifying expressions for: @_Z4loopi

llvm/test/Analysis/ScalarEvolution/sext-inreg.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 target triple = "i386-apple-darwin9.6"
 
 define i64 @foo(i64* nocapture %x, i64 %n) nounwind {
 ; CHECK-LABEL: Classifying expressions for: @foo
 entry:

llvm/test/Analysis/ScalarEvolution/sext-iv-0.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 ; Convert (sext {-128,+,1}) to {sext(-128),+,sext(1)}, since the
 ; trip count is within range where this is safe.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
 target triple = "x86_64-unknown-linux-gnu"
 

llvm/test/Analysis/ScalarEvolution/sext-iv-1.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 ; CHECK: -->  (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
 ; CHECK: -->  (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
 ; CHECK: -->  (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
 ; CHECK: -->  (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
 ; CHECK: -->  (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
 ; CHECK-NOT: -->  (sext

llvm/test/Analysis/ScalarEvolution/sext-iv-2.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK: %tmp3 = sext i8 %tmp2 to i32
 ; CHECK: -->  (sext i8 {0,+,1}<%bb1> to i32){{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: -1
 ; CHECK: %tmp4 = mul i32 %tmp3, %i.02
 ; CHECK: -->  ((sext i8 {0,+,1}<%bb1> to i32) * {0,+,1}<%bb>){{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: {0,+,-1}<%bb>
 
 ; These sexts are not foldable.

llvm/test/Analysis/ScalarEvolution/sext-mul.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK: %tmp9 = shl i64 %tmp8, 33
 ; CHECK-NEXT: --> {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64)))
 ; CHECK: %tmp10 = ashr exact i64 %tmp9, 32
 ; CHECK-NEXT: --> {{.*}} Exits: (sext i32 (-2 + (2 * %arg2)) to i64)
 ; CHECK: %tmp11 = getelementptr inbounds i32, i32* %arg, i64 %tmp10
 ; CHECK-NEXT: --> {{.*}} Exits: ((4 * (sext i32 (-2 + (2 * %arg2)) to i64))<nsw> + %arg)

llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @f(i1 %c) {
 ; CHECK-LABEL: 'f'
 ; CHECK-NEXT:  Classifying expressions for: @f
 ; CHECK-NEXT:    %start = select i1 %c, i32 100, i32 0
 ; CHECK-NEXT:    --> %start U: [0,101) S: [0,101)
 ; CHECK-NEXT:    %step = select i1 %c, i32 -1, i32 1

llvm/test/Analysis/ScalarEvolution/sext-zero.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK:  %tmp9 = shl i64 %tmp8, 33
 ; CHECK-NEXT:  -->  {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64)))
 ; CHECK-NEXT:  %tmp10 = ashr exact i64 %tmp9, 0
 ; CHECK-NEXT:  -->  {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64)))
 
 define void @foo(i32* nocapture %arg, i32 %arg1, i32 %arg2) {

llvm/test/Analysis/ScalarEvolution/shift-op.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @test0(i32 %init) {
 ; CHECK-LABEL: Classifying expressions for: @test0
 ; CHECK: Loop %loop: max backedge-taken count is 32
  entry:
   br label %loop
 

llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @test_lshr() {
 ; CHECK-LABEL: 'test_lshr'
 ; CHECK-NEXT:  Classifying expressions for: @test_lshr
 ; CHECK-NEXT:    %iv.lshr = phi i64 [ 1023, %entry ], [ %iv.lshr.next, %loop ]
 ; CHECK-NEXT:    --> %iv.lshr U: [0,1024) S: [0,1024) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
 ; CHECK-NEXT:    %iv.lshr.next = lshr i64 %iv.lshr, 1

llvm/test/Analysis/ScalarEvolution/shl-lshr-differentconstmask.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; The obvious case.
 define i32 @mul_biggerShl(i32 %val) nounwind {
 ; CHECK-LABEL: 'mul_biggerShl'
 ; CHECK-NEXT:  Classifying expressions for: @mul_biggerShl
 ; CHECK-NEXT:    %tmp1 = mul i32 %val, 64
 ; CHECK-NEXT:    -->  (64 * %val) U: [0,-63) S: [-2147483648,2147483585)

llvm/test/Analysis/ScalarEvolution/sle.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; ScalarEvolution should be able to use nsw information to prove that
 ; this loop has a finite trip count.
 
 ; CHECK: @le
 ; CHECK: Loop %for.body: backedge-taken count is %n
 ; CHECK: Loop %for.body: max backedge-taken count is 9223372036854775807

llvm/test/Analysis/ScalarEvolution/smax-br-phi-idioms.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define i32 @f0(i32 %x, i32 %y) {
 ; CHECK-LABEL: Classifying expressions for: @f0
  entry:
   %c = icmp sgt i32 %y, 0
   br i1 %c, label %add, label %merge
 

llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; Tests for smin & smax folds.
 
 ; Test case from PR1614.
 define i32 @test_PR1614(i32 %a, i32 %b, i32 %c) {
 ; CHECK-LABEL: 'test_PR1614'
 ; CHECK: -->  (%a smax %b)

llvm/test/Analysis/ScalarEvolution/solve-quadratic-i1.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-LABEL: Printing analysis 'Scalar Evolution Analysis' for function 'f0':
 ; CHECK-NEXT: Classifying expressions for: @f0
 ; CHECK-NEXT:   %v0 = phi i16 [ 2, %b0 ], [ %v2, %b1 ]
 ; CHECK-NEXT:   -->  {2,+,1}<nuw><nsw><%b1> U: [2,4) S: [2,4)         Exits: 3                LoopDispositions: { %b1: Computable }

llvm/test/Analysis/ScalarEvolution/solve-quadratic-overflow.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S < %s 2>&1 | FileCheck %s
 
 ; The exit value from this loop was originally calculated as 0.
 ; The actual exit condition is 256*256 == 0 (in i16).
 
 ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'f0':
 ; CHECK-NEXT: Classifying expressions for: @f0
 ; CHECK-NEXT:   %v1 = phi i16 [ 0, %b0 ], [ %v2, %b1 ]

llvm/test/Analysis/ScalarEvolution/solve-quadratic.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S -debug-only=scalar-evolution,apint < %s 2>&1 | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S -debug-only=scalar-evolution,apint < %s 2>&1 2>&1 | FileCheck %s
 ; REQUIRES: asserts
 
 ; Use the following template to get a chrec {L,+,M,+,N}.
 ;
 ; define signext i32 @func() {
 ; entry:
 ;   br label %loop

llvm/test/Analysis/ScalarEvolution/srem.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
 ; CHECK-LABEL: '_Z4loopi'
 ; CHECK-NEXT:  Classifying expressions for: @_Z4loopi

llvm/test/Analysis/ScalarEvolution/strip-injective-zext.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; The initial SCEV for the backedge count is
 ;   (zext i2 {(trunc i32 (1 + %a1) to i2),+,1}<%b2> to i32).
 ; In howFarToZero, this was further converted to an add-rec, the complexity
 ; of which defeated the calculation of the backedge taken count.
 ; Since such zero-extensions preserve the values being extended, strip
 ; them in howFarToZero to simplify the input SCEV.

llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @unsimplified_and1(i32 %n) {
 ; CHECK-LABEL: 'unsimplified_and1'
 ; CHECK-NEXT:  Determining loop execution counts for: @unsimplified_and1

llvm/test/Analysis/ScalarEvolution/trip-count-andor.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @unsimplified_and1(i32 %n) {
 ; CHECK-LABEL: 'unsimplified_and1'
 ; CHECK-NEXT:  Determining loop execution counts for: @unsimplified_and1

llvm/test/Analysis/ScalarEvolution/trip-count-implied-addrec.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>"  -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 
 ; A collection of tests that show we can use facts about an exit test to
 ; infer tighter bounds on an IV, and thus refine an IV into an addrec. The
 ; basic tactic being used is proving NW from exit structure and then
 ; implying NUW/NSW.  Once NSW/NUW is inferred, we can derive addrecs from
 ; the zext/sext cases that we couldn't at initial SCEV construction.
 

llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>"  -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 
 ; A collection of tests which exercise SCEV's ability to compute trip counts
 ; for negative steps.
 
 ; Unsigned Comparisons
 ; --------------------
 

llvm/test/Analysis/ScalarEvolution/trip-count-pow2.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 define void @test1(i32 %n) {
 entry:
   %s = mul i32 %n, 96
   br label %loop
 loop:
   %i = phi i32 [ 0, %entry ], [ %i.next, %loop ]

llvm/test/Analysis/ScalarEvolution/trip-count-switch.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 declare void @foo()
 
 define void @test1() nounwind {
 entry:
   br label %for.cond
 

llvm/test/Analysis/ScalarEvolution/trip-count-unknown-stride.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; ScalarEvolution should be able to compute trip count of the loop by proving
 ; that this is not an infinite loop with side effects.
 
 ; CHECK-LABEL: Determining loop execution counts for: @foo1
 ; CHECK: backedge-taken count is ((-1 + (%n smax %s)) /u %s)
 

llvm/test/Analysis/ScalarEvolution/trip-count.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0  -scalar-evolution-classify-expressions=0  | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0  -scalar-evolution-classify-expressions=0  2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @A = weak global [1000 x i32] zeroinitializer, align 32
 
 define void @PR1101(i32 %N) {

llvm/test/Analysis/ScalarEvolution/trip-count10.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 
 ; Trip counts with trivial exit conditions.
 
 define void @a(i64 %n) nounwind {
 ; CHECK-LABEL: 'a'
 ; CHECK-NEXT:  Determining loop execution counts for: @a
 ; CHECK-NEXT:  Loop %loop: Unpredictable backedge-taken count.

llvm/test/Analysis/ScalarEvolution/trip-count11.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @foo.a = internal constant [8 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7], align 16
 @foo.a_as1 = internal addrspace(1) constant [8 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7], align 16
 

llvm/test/Analysis/ScalarEvolution/trip-count12.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK: Determining loop execution counts for: @test
 ; CHECK: Loop %for.body: backedge-taken count is ((-2 + %len) /u 2)
 ; CHECK: Loop %for.body: max backedge-taken count is 1073741823
 
 define zeroext i16 @test(i16* nocapture %p, i32 %len) nounwind readonly {
 entry:

llvm/test/Analysis/ScalarEvolution/trip-count13.ll

-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @u_0(i8 %rhs) {
 ; E.g.: %rhs = 255, %start = 99, backedge taken 156 times
 entry:
   %start = add i8 %rhs, 100
   br label %loop
 

llvm/test/Analysis/ScalarEvolution/trip-count14.ll

-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @s32_max1(i32 %n, i32* %p) {
 entry:
   %add = add i32 %n, 1
   br label %do.body
 
 do.body:

llvm/test/Analysis/ScalarEvolution/trip-count15.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @umin_unsigned_check(i64 %n) {
 ; CHECK-LABEL: 'umin_unsigned_check'
 ; CHECK-NEXT:  Classifying expressions for: @umin_unsigned_check
 ; CHECK-NEXT:    %min.n = select i1 %min.cmp, i64 4096, i64 %n
 ; CHECK-NEXT:    --> (4096 umin %n) U: [0,4097) S: [0,4097)
 ; CHECK-NEXT:    %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]

llvm/test/Analysis/ScalarEvolution/trip-count2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution  -scalar-evolution-classify-expressions=0  | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>"  -scalar-evolution-classify-expressions=0  2>&1 | FileCheck %s
 
 @A = weak global [1000 x i32] zeroinitializer, align 32
 
 define void @PR1101(i32 %N) {
 ; CHECK-LABEL: 'PR1101'
 ; CHECK-NEXT:  Determining loop execution counts for: @PR1101
 ; CHECK-NEXT:  Loop %bb3: backedge-taken count is 4

llvm/test/Analysis/ScalarEvolution/trip-count3.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 -scalar-evolution-classify-expressions=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 
 ; ScalarEvolution can't compute a trip count because it doesn't know if
 ; dividing by the stride will have a remainder. This could theoretically
 ; be teaching it how to use a more elaborate trip count computation.
 
 %struct.FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct.FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] }
 %struct.SHA_INFO = type { [5 x i32], i32, i32, [16 x i32] }

llvm/test/Analysis/ScalarEvolution/trip-count4.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 
 ; ScalarEvolution should be able to compute a loop exit value for %indvar.i8.
 
 define void @another_count_down_signed(double* %d, i64 %n) nounwind {
 ; CHECK-LABEL: 'another_count_down_signed'
 ; CHECK-NEXT:  Determining loop execution counts for: @another_count_down_signed
 ; CHECK-NEXT:  Loop %loop: backedge-taken count is (-11 + %n)

llvm/test/Analysis/ScalarEvolution/trip-count5.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; ScalarEvolution should be able to compute a maximum trip count
 ; value sufficient to fold away both sext casts.
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
 
 define float @t(float* %pTmp1, float* %peakWeight, float* %nrgReducePeakrate, i32 %bim) nounwind {

llvm/test/Analysis/ScalarEvolution/trip-count6.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 
 @mode_table = global [4 x i32] zeroinitializer          ; <[4 x i32]*> [#uses=1]
 
 define i8 @f() {
 ; CHECK-LABEL: 'f'
 ; CHECK-NEXT:  Determining loop execution counts for: @f
 ; CHECK-NEXT:  Loop %bb: <multiple exits> Unpredictable backedge-taken count.

llvm/test/Analysis/ScalarEvolution/trip-count7.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
 
   %struct.complex = type { float, float }
   %struct.element = type { i32, i32 }
   %struct.node = type { %struct.node*, %struct.node*, i32 }
 @seed = external global i64   ; <i64*> [#uses=0]

llvm/test/Analysis/ScalarEvolution/trip-count8.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
 ; PR4599
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
 
 define i32 @foo(i32 %ecx) nounwind {
 ; CHECK-LABEL: 'foo'
 ; CHECK-NEXT:  Determining loop execution counts for: @foo

llvm/test/Analysis/ScalarEvolution/trip-count9.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S -scalar-evolution-classify-expressions=0 < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S -scalar-evolution-classify-expressions=0 < %s 2>&1 | FileCheck %s
 
 ; Every combination of
 ;  - starting at 0, 1, or %x
 ;  - steping by 1 or 2
 ;  - stopping at %n or %n*2
 ;  - using nsw, or not
 

llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -scalar-evolution %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt -passes='print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck %s
 
 ; Tests for PR47904.
 
 define void @test_trip_multiple_4(i32 %num) {
 ; CHECK-LABEL: @test_trip_multiple_4
 ; CHECK:       Loop %for.body: backedge-taken count is (-1 + %num)
 ; CHECK-NEXT:  Loop %for.body: max backedge-taken count is -2

llvm/test/Analysis/ScalarEvolution/tripmultiple_calculation.ll

-; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s 2>&1 | FileCheck %s
 ; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 2>&1 | FileCheck %s
 
 ; umin is represented using -1 * umax in scalar evolution. -1 is considered as the
 ; constant of the multiply expression (-1 * ((-1 + (-1 * %a)) umax (-1 + (-1 * %b)))).
 ; Returns the greatest power of 2 divisor by evaluating the minimal trailing zeros
 ; for the trip count expression.
 ;
 ; int foo(uint32_t a, uint32_t b, uint32_t *c) {

llvm/test/Analysis/ScalarEvolution/trivial-phis.ll

-; RUN: opt -analyze -scalar-evolution %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt -passes='print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL @test1
 ; CHECK       %add.lcssa.wide = phi i64 [ %indvars.iv.next, %do.body ]
 ; CHECK-NEXT  -->  %add.lcssa.wide U: [1,2147483648) S: [1,2147483648)
 
 define i64 @test1(i32 signext %n, float* %A) {
 entry:

llvm/test/Analysis/ScalarEvolution/trunc-simplify.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; Check that we convert
 ;   trunc(C * a) -> trunc(C) * trunc(a)
 ; if C is a constant.
 ; CHECK-LABEL: @trunc_of_mul
 define i8 @trunc_of_mul(i32 %a) {
   %b = mul i32 %a, 100

llvm/test/Analysis/ScalarEvolution/truncate.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes='print<scalar-evolution>' -S 2>&1 | FileCheck %s
 ; Regression test for assert ScalarEvolution::getTruncateExpr.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @snork(i8* %arg, i8 %arg1, i64 %arg2) {

llvm/test/Analysis/ScalarEvolution/umin-umax-folds.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 define void @umin_sext_x_zext_x(i32 %len) {
 ; CHECK-LABEL: 'umin_sext_x_zext_x'
 ; CHECK-NEXT:  Classifying expressions for: @umin_sext_x_zext_x
 ; CHECK-NEXT:    %len.zext = zext i32 %len to i64
 ; CHECK-NEXT:    --> (zext i32 %len to i64) U: [0,4294967296) S: [0,4294967296)
 ; CHECK-NEXT:    %len.sext = sext i32 %len to i64

llvm/test/Analysis/ScalarEvolution/undefined.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; ScalarEvolution shouldn't attempt to interpret expressions which have
 ; undefined results.
 
 define void @foo(i64 %x) {
 
   %a = udiv i64 %x, 0

llvm/test/Analysis/ScalarEvolution/unknown_phis.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 define void @merge_values_with_ranges(i32 *%a_len_ptr, i32 *%b_len_ptr, i1 %unknown_cond) {
 
 ; CHECK-LABEL: Classifying expressions for: @merge_values_with_ranges
 ; CHECK:       %len = phi i32 [ %len_a, %if.true ], [ %len_b, %if.false ]
 ; CHECK-NEXT:  -->  %len U: [0,2147483647) S: [0,2147483647)
 

llvm/test/Analysis/ScalarEvolution/unreachable-code.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK: %t = add i64 %t, 1
 ; CHECK: -->  undef
 
 define void @foo() {
 entry:
   ret void
 
 dead:
   %t = add i64 %t, 1
   ret void
 }

llvm/test/Analysis/ScalarEvolution/unsimplified-loop.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; This loop has no preheader, multiple backedges, etc., but ScalarEvolution
 ; should still be able to analyze it.
 
 ; CHECK: %i = phi i64 [ 5, %entry ], [ 5, %alt ], [ %i.next, %loop.a ], [ %i.next, %loop.b ]
 ; CHECK-NEXT: -->  {5,+,1}<%loop>
 

llvm/test/Analysis/ScalarEvolution/urem-0.ll

-; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
 
 define i8 @foo(i8 %a) {
 ; CHECK-LABEL: @foo
         %t0 = urem i8 %a, 27
 ; CHECK: %t0 = urem i8 %a, 27
 ; CHECK-NEXT: -->  ((-27 * (%a /u 27)) + %a)
         ret i8 %t0

llvm/test/Analysis/ScalarEvolution/widenable-condition.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
 
 ; The semanics of this example are a bit subtle.  The loop is required
 ; execute some number of times up to 1999.  The compiler is free to reduce
 ; the number of said iterations to zero (or any value in between) if desired,
 ; but if it does so, the return value and the last value stored to G must
 ; agree.  For SCEV, this translates as widenable conditions preventing exact
 ; exit counts from being computed, but not restricting max exit counts.

llvm/test/Analysis/ScalarEvolution/zext-divrem.ll

-; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S < %s | FileCheck %s
 ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S < %s 2>&1 | FileCheck %s
 
 define i64 @test1(i32 %a, i32 %b) {
 ; CHECK-LABEL: @test1
   %div = udiv i32 %a, %b
   %zext = zext i32 %div to i64
 ; CHECK: %zext
 ; CHECK-NEXT: -->  ((zext i32 %a to i64) /u (zext i32 %b to i64))

llvm/test/Analysis/ScalarEvolution/zext-mul.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; Check that we convert
 ;   zext((a * b)<nuw>)
 ; to
 ;   (zext(a) * zext(b))<nuw>
 
 declare i32 @get_int();

llvm/test/Analysis/ScalarEvolution/zext-wrap.ll

-; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 ; PR4569
 
 define i16 @main() nounwind {
 entry:
         br label %bb.i
 
 bb.i:           ; preds = %bb1.i, %bb.nph

llvm/test/Analysis/StackSafetyAnalysis/ipa-alias.ll

 ; REQUIRES: aarch64-registered-target
 ; REQUIRES: shell
 
 ; Test IPA over a single combined file
 ; RUN: llvm-as %s -o %t0.bc
 ; RUN: llvm-as %S/Inputs/ipa-alias.ll -o %t1.bc
 ; RUN: llvm-link %t0.bc %t1.bc -o %t.combined.bc
 
-; RUN: opt -S -analyze -stack-safety-local %t.combined.bc -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,LOCAL
 ; RUN: opt -S -passes="print<stack-safety-local>" -disable-output %t.combined.bc 2>&1 | FileCheck %s --check-prefixes=CHECK,LOCAL
 
-; RUN: opt -S -analyze -stack-safety %t.combined.bc -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,GLOBAL,NOLTO
 ; RUN: opt -S -passes="print-stack-safety" -disable-output %t.combined.bc 2>&1 | FileCheck %s --check-prefixes=CHECK,GLOBAL,NOLTO
 
 ; Do an end-to-test using the new LTO API
 ; RUN: opt -module-summary %s -o %t.summ0.bc
 ; RUN: opt -module-summary %S/Inputs/ipa-alias.ll -o %t.summ1.bc
 
 ; RUN: echo > %t.res.txt \
 ; RUN:  -r %t.summ0.bc,AliasCall,px \

llvm/test/Analysis/StackSafetyAnalysis/ipa.ll

 ; REQUIRES: aarch64-registered-target
 ; REQUIRES: shell
 
 ; RUN: llvm-as %s -o %t0.bc
 ; RUN: llvm-as %S/Inputs/ipa.ll -o %t1.bc
 ; RUN: llvm-link -disable-lazy-loading %t0.bc %t1.bc -o %t.combined.bc
 
-; RUN: opt -S -analyze -stack-safety-local %t.combined.bc -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,LOCAL
 ; RUN: opt -S -passes="print<stack-safety-local>" -disable-output %t.combined.bc 2>&1 | FileCheck %s --check-prefixes=CHECK,LOCAL
 
-; RUN: opt -S -analyze -stack-safety %t.combined.bc -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,GLOBAL,NOLTO
 ; RUN: opt -S -passes="print-stack-safety" -disable-output %t.combined.bc 2>&1 | FileCheck %s --check-prefixes=CHECK,GLOBAL,NOLTO
 
 ; Do an end-to-test using the new LTO API
 ; TODO: Hideous llvm-lto2 invocation, add a --default-symbol-resolution to llvm-lto2?
 ; RUN: opt -module-summary %s -o %t.summ0.bc
 ; RUN: opt -module-summary %S/Inputs/ipa.ll -o %t.summ1.bc
 
 ; RUN: llvm-dis %t.summ0.bc -o - > %t.ids.txt

llvm/test/Analysis/StackSafetyAnalysis/local.ll

-; RUN: opt -S -analyze -stack-safety-local < %s -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,LOCAL
 ; RUN: opt -S -passes="print<stack-safety-local>" -disable-output < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,LOCAL
-; RUN: opt -S -analyze -stack-safety < %s -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,GLOBAL
 ; RUN: opt -S -passes="print-stack-safety" -disable-output < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,GLOBAL
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @sink = global i8* null, align 8
 
 declare void @llvm.memset.p0i8.i32(i8* %dest, i8 %val, i32 %len, i1 %isvolatile)

llvm/test/Analysis/StackSafetyAnalysis/memintrin.ll

-; RUN: opt -S -analyze -stack-safety-local -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -S -passes="print<stack-safety-local>" -disable-output < %s 2>&1 | FileCheck %s
-; RUN: opt -S -analyze -stack-safety < %s -enable-new-pm=0 | FileCheck %s
 ; RUN: opt -S -passes="print-stack-safety" -disable-output < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @llvm.memset.p0i8.i64(i8* %dest, i8 %val, i64 %len, i1 %isvolatile)
 declare void @llvm.memset.p0i8.i32(i8* %dest, i8 %val, i32 %len, i1 %isvolatile)
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 %len, i1 %isvolatile)

llvm/test/Analysis/ValueTracking/deref-abstract-gc.ll

-; RUN: opt -print-memderefs -analyze -S < %s -enable-new-pm=0 -use-dereferenceable-at-point-semantics=1 | FileCheck %s --check-prefixes=CHECK
 ; RUN: opt -passes=print-memderefs -S < %s -disable-output  -use-dereferenceable-at-point-semantics=1 2>&1 | FileCheck %s --check-prefixes=CHECK
 
 target datalayout = "e-i32:32:64"
 
 ; For the abstract machine model (before RS4GC), gc managed objects
 ; conceptually live forever.  But there may be non-managed objects which are
 ; freed.
 ; CHECK-LABEL: 'abstract_model'

llvm/test/Analysis/ValueTracking/memory-dereferenceable.ll

-; RUN: opt -print-memderefs -analyze -S < %s -enable-new-pm=0 -use-dereferenceable-at-point-semantics=0 | FileCheck %s --check-prefixes=CHECK,GLOBAL
 ; RUN: opt -passes=print-memderefs -S < %s -disable-output  -use-dereferenceable-at-point-semantics=0 2>&1 | FileCheck %s --check-prefixes=CHECK,GLOBAL
-; RUN: opt -print-memderefs -analyze -S < %s -enable-new-pm=0 -use-dereferenceable-at-point-semantics=1 | FileCheck %s --check-prefixes=CHECK,POINT
 ; RUN: opt -passes=print-memderefs -S < %s -disable-output  -use-dereferenceable-at-point-semantics=1 2>&1 | FileCheck %s --check-prefixes=CHECK,POINT
 
 
 ; Uses the print-deref (+ analyze to print) pass to run
 ; isDereferenceablePointer() on many load instruction operands
 
 target datalayout = "e-i32:32:64"