[LoopAccessAnalysis][NewPM] Fix tests to work under NPM

[aeubanks]

Summary

Pin RUN lines with -analyze to legacy PM, add corresponding NPM RUN lines.

[fhahn]

This is in line with similar patches for other passes. LGTM, thanks!

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

-; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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 | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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 | FileCheck %s
+; 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));
 ;       src += 8;
 ;       op += 8;
 ;       len -= 8;
 ;     }
 ;   }
 ; Boundaries calculations before this patch:
 ; (Low: %src High: (24 + %src))
 ; and the actual distance between two pointers was 31,  (%op - %src = 31)
 ; IsConflict = (24 > 31) = false -> execution is directed to the vectorized loop.
 ; The loop was vectorized to 4, 32 byte memory access ( <4 x i64> ),
 ; store a value at *%op touched memory under *%src.
 
-;CHECK: Printing analysis 'Loop Access Analysis' for function 'fastCopy'
+;CHECK: function 'fastCopy':
 ;CHECK: (Low: %op High: (32 + %op))
 ;CHECK: (Low: %src High: (32 + %src))
 
 define void @fastCopy(i8* nocapture readonly %src, i8* nocapture %op) {
 entry:
   br label %while.body.preheader
 
 while.body.preheader:                             ; preds = %entry

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

-; RUN: opt -basic-aa -loop-accesses -analyze < %s | FileCheck %s
+; 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 -S < %s | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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 %s  | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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-with-unknown-bounds.ll

-; RUN: opt -loop-accesses -analyze < %s | FileCheck %s
+; 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: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 < %s | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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/safe-no-checks.ll

-; RUN: opt -basic-aa -loop-accesses -analyze < %s | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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 | FileCheck -check-prefix=OLDPM %s
+; 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
 
 ; 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];

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

-; RUN: opt < %s -loop-accesses -analyze  | FileCheck %s
+; 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 | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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/underlying-objects-1.ll

-; RUN: opt -basic-aa -loop-accesses -analyze < %s | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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 < %s | FileCheck %s
+; 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 < %s | FileCheck %s -check-prefix=LAA
+; 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
 ; RUN: opt -loop-versioning -S < %s | FileCheck %s -check-prefix=LV
 
 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++) {