[MSSA][NewPM] Handle tests with -print-memoryssa

[aeubanks]

Summary

-print-memoryssa in legacy PM is print<memoryssa> in NPM.
Pin tests with -print-memoryssa to legacy PM.
Add corresponding tests for NPM where missing.
This fixes "unknown pass name 'print-memoryssa'".

Some tests still fail in Analysis/MemorySSA due to other passes that
haven't been ported.

pr43427.ll and pr43438.ll required adding -aa-pipeline=basic-aa,
-loop-simplify (since it doesn't run on legacy PM by default), and
decrementing some of the MemoryPhi numbers.

[aeubanks]

Update some failing tests

llvm/test/Analysis/MemorySSA/assume.ll

-; RUN: opt -basic-aa -memoryssa -analyze < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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/basicaa-memcpy.ll

-; RUN: opt -disable-output -basic-aa -print-memoryssa %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -basic-aa -enable-new-pm=0 -print-memoryssa %s 2>&1 | FileCheck %s
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 
 define void @source_clobber(i8* %a, i8* %b) {
 ; CHECK-LABEL: @source_clobber(
 ; CHECK-NEXT:  ; 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 128, i1 false)
 ; CHECK-NEXT:  ; MemoryUse(liveOnEntry)
 ; CHECK-NEXT:    [[X:%.*]] = load i8, i8* %b
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 128, i1 false)
   %x = load i8, i8* %b
   ret void
 }

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

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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/debugvalue2.ll

-; RUN: opt -disable-basic-aa -print-memoryssa -disable-output %s 2>&1 | FileCheck %s
+; RUN: opt -disable-basic-aa -enable-new-pm=0 -print-memoryssa -disable-output %s 2>&1 | FileCheck %s
 
 ; Note that the test crashes the MemorySSA verification when doing loop-rotate,
 ; if debuginfo is modelled in MemorySSA, due to the fact that MemorySSA is not
 ; updated when adding/removing debuginfo intrinsics.
 
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-LABEL: @overflow_iter_var

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

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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/invariant-groups.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
+; 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
 ;
 ; Currently, MemorySSA doesn't support invariant groups. So, we should ignore
 ; launder.invariant.group intrinsics entirely. We'll need to pay attention to
 ; them when/if we decide to support invariant groups.
 
 @g = external global i32
 
 define i32 @foo(i32* %a) {

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

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
+; 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 a number of things:
 ; First, the lifetime markers should not clobber any uses of Q or P.
 ; Second, the loads of P are MemoryUse(LiveOnEntry) due to the placement of the markers vs the loads.
 
 define i8 @test(i8* %P, i8* %Q) {
 entry:
 ; CHECK:  1 = MemoryDef(liveOnEntry)

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

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
+; 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/loop-rotate-disablebasicaa.ll

-; RUN: opt -disable-basic-aa -print-memoryssa -disable-output %s 2>&1 | FileCheck %s
+; RUN: opt -disable-basic-aa -enable-new-pm=0 -print-memoryssa -disable-output %s 2>&1 | FileCheck %s
+; RUN: opt -passes='print<memoryssa>' -disable-output %s 2>&1 | FileCheck %s
 
 ; Note: if @foo is modelled as a MemoryDef, this test will assert with -loop-rotate, due to MemorySSA not
 ; being preserved when moving instructions that may not read from or write to memory.
 
 ; CHECK-LABEL: @main
 ; CHECK-NOT: MemoryDef
 define void @main() {
 entry:

llvm/test/Analysis/MemorySSA/loop_rotate_remove_trivial_phis.ll

-; RUN: opt -loop-rotate -print-memoryssa -disable-output -enable-mssa-loop-dependency -verify-memoryssa %s 2>&1 |  FileCheck %s
+; RUN: opt -loop-rotate -enable-new-pm=0 -print-memoryssa -disable-output -enable-mssa-loop-dependency -verify-memoryssa %s 2>&1 |  FileCheck %s
+; RUN: opt -passes='loop-mssa(loop-rotate),print<memoryssa>' -disable-output -verify-memoryssa %s 2>&1 |  FileCheck %s
 ; REQUIRES: asserts
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-grtev4-linux-gnu"
 
 declare double @sqrt(double)
 
 ; CHECK-LABEL: @f

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

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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/optimize-use.ll

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,NOLIMIT
-; RUN: opt -memssa-check-limit=0 -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,LIMIT
+; 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 -analyze < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,NOLIMIT
-; RUN: opt -memssa-check-limit=0 -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,LIMIT
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 -S | FileCheck %s
+; 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/pr41640.ll

-; RUN: opt -disable-output -licm -print-memoryssa -enable-mssa-loop-dependency=true < %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -licm -enable-new-pm=0 -print-memoryssa -enable-mssa-loop-dependency=true < %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -passes='loop-mssa(licm),print<memoryssa>' < %s 2>&1 | FileCheck %s
 target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64"
 target triple = "s390x-ibm-linux"
 
 @g_248 = external dso_local local_unnamed_addr global i32, align 4
 @g_976 = external dso_local global i64, align 8
 @g_1087 = external dso_local global i32**, align 8
 
 ; CHECK-LABEL: @f1()

llvm/test/Analysis/MemorySSA/pr43317.ll

-; RUN: opt -disable-output -licm -print-memoryssa -enable-mssa-loop-dependency=true < %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -licm -enable-new-pm=0 -print-memoryssa -enable-mssa-loop-dependency=true < %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -passes='loop-mssa(licm),print<memoryssa>' < %s 2>&1 | FileCheck %s
 @v_274 = external dso_local global i64, align 1
 @v_295 = external dso_local global i16, align 1
 @v_335 = external dso_local global i32, align 1
 
 ; CHECK-LABEL: @main()
 ; CHECK-NOT: 5 = MemoryPhi(
 ; CHECK-NOT: 6 = MemoryPhi(
 ; CHECK: 4 = MemoryPhi(

llvm/test/Analysis/MemorySSA/pr43427.ll

-; RUN: opt -disable-output -licm -print-memoryssa -enable-mssa-loop-dependency=true < %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -loop-simplify -licm -enable-new-pm=0 -print-memoryssa -enable-mssa-loop-dependency=true < %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -aa-pipeline=basic-aa -passes='loop-mssa(licm),print<memoryssa>' < %s 2>&1 | FileCheck %s
 
 ; CHECK-LABEL: @f()
-; CHECK: 8 = MemoryPhi(
 ; CHECK: 7 = MemoryPhi(
-; CHECK: 9 = MemoryPhi(
+; CHECK: 6 = MemoryPhi(
+; CHECK: 8 = MemoryPhi(
 define void @f() {
 entry:
   %e = alloca i16, align 1
   br label %lbl1
 
 lbl1:                                             ; preds = %if.else, %cleanup, %entry
   store i16 undef, i16* %e, align 1
   call void @g()

llvm/test/Analysis/MemorySSA/pr43438.ll

-; RUN: opt -disable-output -licm -print-memoryssa -enable-mssa-loop-dependency=true < %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -loop-simplify -licm -enable-new-pm=0 -print-memoryssa -enable-mssa-loop-dependency=true < %s 2>&1 | FileCheck %s
+; RUN: opt -disable-output -aa-pipeline=basic-aa -passes='loop-mssa(licm),print<memoryssa>' < %s 2>&1 | FileCheck %s
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-LABEL: @main()
 ; CHECK: 5 = MemoryPhi(
 ; CHECK-NOT: 7 = MemoryPhi(
 @v_67 = external dso_local global i32, align 1
 @v_76 = external dso_local global i16, align 1
 @v_86 = external dso_local global i16 *, align 1
if.else568:                                       ; preds = %land.lhs.true87, %cond.end82, %for.end
   br label %if.end569
 
 if.end569:                                        ; preds = %if.else568, %if.then88
   ret void
 }
 
 
 ; CHECK-LABEL: @f()
-; CHECK: 8 = MemoryPhi(
 ; CHECK: 7 = MemoryPhi(
-; CHECK: 11 = MemoryPhi(
+; CHECK: 6 = MemoryPhi(
 ; CHECK: 10 = MemoryPhi(
 ; CHECK: 9 = MemoryPhi(
+; CHECK: 8 = MemoryPhi(
 define void @f() {
 entry:
   %e = alloca i16, align 1
   br label %lbl1
 
 lbl1:                                             ; preds = %if.else, %for.end5, %entry
   store i16 undef, i16* %e, align 1
   %0 = load i16, i16* %e, align 1

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

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -analyze -memssa-check-limit=0 < %s 2>&1 | FileCheck %s
+; 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 -analyze < %s 2>&1 | FileCheck %s
+; 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/update_unroll.ll

-; RUN: opt -enable-mssa-loop-dependency -verify-memoryssa  -loop-rotate -S %s | FileCheck %s
+; RUN: opt -enable-new-pm=0 -enable-mssa-loop-dependency -verify-memoryssa  -loop-rotate -S %s | FileCheck %s
+; RUN: opt -verify-memoryssa -passes='loop-mssa(loop-rotate)' -S %s | FileCheck %s
 ; REQUIRES: asserts
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-grtev4-linux-gnu"
 
 ; Check verification passes after loop rotate, when adding phis in blocks
 ; receiving incoming edges and adding phis in IDF blocks.
 ; CHECK-LABEL: @f

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

-; RUN: opt -basic-aa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
+; 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)