[NewPM] Pin -lazy-branch-prob and -lazy-block-freq tests to legacy PM

[aeubanks]

Summary

NPM passes just use the normal versions of these analyses instead.
Also pin any tests with -analyze to legacy PM.

[asbirlea]

Thanks for all these!

llvm/test/Analysis/BlockFrequencyInfo/bad_input.ll

-; RUN: opt < %s -analyze -block-freq | FileCheck %s
+; 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 | FileCheck %s
-; RUN: opt < %s -analyze -lazy-block-freq | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
+; 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
+; 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 | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
-; RUN: opt < %s -analyze -lazy-block-freq | FileCheck %s
+; 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 | FileCheck %s
-; RUN: opt < %s -analyze -lazy-branch-prob | FileCheck %s
+; 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 | FileCheck %s
+; 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/fcmp.ll

-; RUN: opt < %s -analyze -branch-prob | FileCheck %s
+; 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 'Branch Probability Analysis' for function 'uno'
+; 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]
 
 define void @uno(float %val1, float %val2) {
   %cond = fcmp uno float %val1, %val2
   br i1 %cond, label %a, label %b
 
 a:
   call void @fa()
   ret void
 
 b:
   call void @fb()
   ret void
 }
 
 ; This function tests the floating point order comparison.
-; CHECK: Printing analysis 'Branch Probability Analysis' for function 'ord'
+; CHECK: Printing analysis {{.*}} for function 'ord'
 ; CHECK:  edge  -> a probability is 0x7ffff800 / 0x80000000 = 100.00% [HOT edge]
 ; CHECK:  edge  -> b probability is 0x00000800 / 0x80000000 = 0.00%
 
 define void @ord(float %val1, float %val2) {
   %cond = fcmp ord float %val1, %val2
   br i1 %cond, label %a, label %b
 
 a:

llvm/test/Analysis/BranchProbabilityInfo/libfunc_call.ll

-; RUN: opt < %s -analyze -branch-prob | FileCheck %s
-; RUN: opt < %s -analyze -lazy-branch-prob | FileCheck %s
+; 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*)

 
 else:
   br label %exit
 ; CHECK: edge else -> exit probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
 
 exit:
   %result = phi i32 [ 0, %then ], [ 1, %else ]
   ret i32 %result
-}
+}
 

llvm/test/Analysis/BranchProbabilityInfo/loop.ll

 ; Test the static branch probability heuristics for no-return functions.
-; RUN: opt < %s -analyze -branch-prob | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
+; 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 | FileCheck %s
-; RUN: opt < %s -analyze -lazy-branch-prob | FileCheck %s
+; 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/zero_heuristics.ll

-; RUN: opt < %s -analyze -branch-prob | FileCheck %s
+; 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:
   %const = bitcast i32 -1 to i32

llvm/test/Transforms/Util/PR37334-break-crit-edges-require-dt.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -loop-sink -break-crit-edges -branch-prob -S | FileCheck %s
-; RUN: opt < %s -loop-sink -break-crit-edges -lazy-block-freq -S | FileCheck %s
-; RUN: opt < %s -loop-sink -break-crit-edges -lazy-branch-prob -S | FileCheck %s
+; RUN: opt < %s -loop-sink -break-crit-edges -lazy-block-freq -S -enable-new-pm=0 | FileCheck %s
+; RUN: opt < %s -loop-sink -break-crit-edges -lazy-branch-prob -S -enable-new-pm=0 | FileCheck %s
 
 ; BreakCriticalEdges tries to update LI and DT if they are present. However,
 ; updating LI actually needs a DT, so we now require DT in
 ; BranchProbabilityInfo/LazyBlockFrequencyInfo/LazyBranchProbabilityInfo so it
 ; is indeed available when LI is.
 
 target triple = "x86_64-unknown-linux-gnu"