[test][NewGVN] Use '-passes=newgvn' instead of 'basic-aa -newgvn'

[bjope]

Summary

This updates NewGVN test cases the were running

"opt -basic-aa -newgvn ..."

to run

"opt -passes=newgvn ..."

instead.

The pipeline will be more similar to what we used to have with
legacy PM by doing it this way. The compatility mode that we've
been using for awhile during transition from legacy PM to new PM,
i.e. using the legacy syntax together with new PM, has resulted in
a pipeline such as

-passes='function(require<basic-aa>),function(newgvn)'

but running the analysis in a separate function pass manager seem
overly complicated for these tests.

Another difference is that we will get the default aa-pipeline instead
of only running basic-aa. That might be a bit questioned (given that
the tests originally specified basic-aa). The output is however
identical for all the test cases modified here regardless of using
basic-aa or the default aa-pipeline.

This is also another small step towards removal of the support for
using the legacy PM syntax in opt.

[fhahn]

LGTM, thanks!

[nikic]

Can you please omit -aa-pipeline entirely where it makes no difference to test output? Especially for basic-aa, it should not be necessary to explicitly specify it.

[bjope]

In D118340#3275411, @nikic wrote:

Can you please omit -aa-pipeline entirely where it makes no difference to test output? Especially for basic-aa, it should not be necessary to explicitly specify it.

I was afraid that the reason for having explicitly added -basic-aa in the original test case might have indicated that basic-aa was needed to expose the bug etc.
But ofcourse, since with legacy PM "opt -basic-aa -newgvn" and "opt -newgvn" would give the same result one might question why these tests has been explicitly mentioning -basic-aa from the start.

So in the end I guess this patch really isn't much different from D118341 were I'm handling tests that did not specify -basic-aa. I'll look into omitting -aa-pipeline in these tests as well.

[bjope]

Updated based on the suggestion to drop -aa-pipeline=basic-aa in test cases for which the output would be the same when using the default aa-pipeline (that was the case for all but one file, so that one was left out from this patch).

llvm/test/Transforms/NewGVN/2007-07-25-InfiniteLoop.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
   %struct.INT2 = type { i32, i32 }
 @blkshifts = external global %struct.INT2*    ; <%struct.INT2**> [#uses=2]
 
 define i32 @xcompact() {
 entry:
   store %struct.INT2* null, %struct.INT2** @blkshifts, align 4
   br label %bb
 
 bb:   ; preds = %bb, %entry
   %tmp10 = load %struct.INT2*, %struct.INT2** @blkshifts, align 4    ; <%struct.INT2*> [#uses=0]
 ; CHECK-NOT:  %tmp10
   br label %bb
 }

llvm/test/Transforms/NewGVN/2007-07-26-InterlockingLoops.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 @last = external global [65 x i32*]
 
 define i32 @NextRootMove(i32 %wtm, i32 %x, i32 %y, i32 %z) {
 entry:
         %A = alloca i32*
   %tmp17618 = load i32*, i32** getelementptr ([65 x i32*], [65 x i32*]* @last, i32 0, i32 1), align 4
         store i32* %tmp17618, i32** %A

llvm/test/Transforms/NewGVN/2007-07-31-NoDomInherit-xfail.ll

 ; XFAIL: *
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
   %struct.anon = type { i32 (i32, i32, i32)*, i32, i32, [3 x i32], i8*, i8*, i8* }
 @debug = external constant i32    ; <i32*> [#uses=0]
 @counters = external constant i32   ; <i32*> [#uses=1]
 @trialx = external global [17 x i32]    ; <[17 x i32]*> [#uses=1]
 @dummy1 = external global [7 x i32]    ; <[7 x i32]*> [#uses=0]
 @dummy2 = external global [4 x i32]    ; <[4 x i32]*> [#uses=0]
 @unacceptable = external global i32   ; <i32*> [#uses=0]

llvm/test/Transforms/NewGVN/2007-07-31-RedundantPhi.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 @img_width = external global i16    ; <i16*> [#uses=2]
 
 define i32 @smpUMHEXBipredIntegerPelBlockMotionSearch(i16* %cur_pic, i16 signext  %ref, i32 %list, i32 %pic_pix_x, i32 %pic_pix_y, i32 %blocktype, i16 signext  %pred_mv_x1, i16 signext  %pred_mv_y1, i16 signext  %pred_mv_x2, i16 signext  %pred_mv_y2, i16* %mv_x, i16* %mv_y, i16* %s_mv_x, i16* %s_mv_y, i32 %search_range, i32 %min_mcost, i32 %lambda_factor) {
 cond_next143:   ; preds = %entry
   store i16 0, i16* @img_width, align 2
   br i1 false, label %cond_next449, label %cond_false434
 

llvm/test/Transforms/NewGVN/2008-07-02-Unreachable.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 ; PR2503
 
 @g_3 = external global i8   ; <i8*> [#uses=2]
 
 define i8 @func_1(i32 %x, i32 %y) nounwind  {
 entry:
   %A = alloca i8
     %cmp = icmp eq i32 %x, %y

llvm/test/Transforms/NewGVN/2010-03-31-RedundantPHIs.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 ; CHECK-NOT: load
 ; CHECK-NOT: phi
 
 define i8* @cat(i8* %s1, ...) nounwind {
 entry:
   br i1 undef, label %bb, label %bb3
 

llvm/test/Transforms/NewGVN/2010-11-13-Simplify.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 declare i32 @foo(i32) readnone
 
 define i1 @bar() {
 ; CHECK-LABEL: @bar(
   %a = call i32 @foo (i32 0) readnone
   %b = call i32 @foo (i32 0) readnone
   %c = and i32 %a, %b
   %x = call i32 @foo (i32 %a) readnone
   %y = call i32 @foo (i32 %c) readnone
   %z = icmp eq i32 %x, %y
   ret i1 %z
 ; CHECK: ret i1 true
 } 

llvm/test/Transforms/NewGVN/2011-09-07-TypeIdFor.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 %struct.__fundamental_type_info_pseudo = type { %struct.__type_info_pseudo }
 %struct.__type_info_pseudo = type { i8*, i8* }
 
 @_ZTIi = external constant %struct.__fundamental_type_info_pseudo
 @_ZTIb = external constant %struct.__fundamental_type_info_pseudo
 
 declare void @_Z4barv()
 

llvm/test/Transforms/NewGVN/2016-08-30-MaskedScatterGather-xfail-inseltpoison.ll

 ; XFAIL: *
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> )
 declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>)
 
 ; This test ensures that masked scatter and gather operations, which take vectors of pointers,
 ; do not have pointer aliasing ignored when being processed.
 ; No scatter/gather calls should end up eliminated
 ; CHECK: llvm.masked.gather

llvm/test/Transforms/NewGVN/2016-08-30-MaskedScatterGather-xfail.ll

 ; XFAIL: *
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> )
 declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>)
 
 ; This test ensures that masked scatter and gather operations, which take vectors of pointers,
 ; do not have pointer aliasing ignored when being processed.
 ; No scatter/gather calls should end up eliminated
 ; CHECK: llvm.masked.gather

llvm/test/Transforms/NewGVN/MemdepMiscompile.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | 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"
 target triple = "x86_64-apple-macosx10.7.0"
 
 ; rdar://12801584
 ; Value of %shouldExit can be changed by RunInMode.
 ; Make sure we do not replace load %shouldExit in while.cond.backedge
 ; with a phi node where the value from while.body is 0.
 define i32 @test() nounwind ssp {

llvm/test/Transforms/NewGVN/basic-cyclic-opt.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ;; Function Attrs: nounwind ssp uwtable
 ;; We should eliminate the sub, and one of the phi nodes
 define void @vnum_test1(i32* %data) #0 {
 ; CHECK-LABEL: @vnum_test1(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[TMP:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 3

llvm/test/Transforms/NewGVN/basic-undef-test.ll

-; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
+; RUN: opt -passes=newgvn -S < %s | FileCheck %s
 ; ModuleID = 'test3.ll'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 define i32 @main(i32 *%foo)  {
 entry:
 ; CHECK: load i32, i32* %foo, align 4
   %0 = load i32, i32* %foo, align 4
   store i32 5, i32* undef, align 4
 ; CHECK-NOT: load i32, i32* %foo, align 4
   %1 = load i32, i32* %foo, align 4
 ; CHECK: add i32 %0, %0
   %2 = add i32 %0, %1
   ret i32 %2
 }

llvm/test/Transforms/NewGVN/calloc-load-removal.ll

-; RUN: opt -S -basic-aa -newgvn < %s | FileCheck %s
-; RUN: opt -S -basic-aa -newgvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
+; RUN: opt -S -passes=newgvn < %s | FileCheck %s
+; RUN: opt -S -passes=newgvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
 ; Check that loads from calloc are recognized as being zero.
 
 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"
 
 ; Function Attrs: nounwind uwtable
 define i32 @test1() {
   %1 = tail call noalias i8* @calloc(i64 1, i64 4)
   %2 = bitcast i8* %1 to i32*

llvm/test/Transforms/NewGVN/calls-nonlocal-xfail.ll

 ; XFAIL: *
 ;; NewGVN zaps the strlens, but currently takes two iterations to evaluate the conditions, because
 ;; we prune predicateinfo, and the icmps only become equivalent after the strlens are zapped
 ; Two occurrences of strlen should be zapped.
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | 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"
 
 define i32 @test(i32 %g, i8* %P) nounwind  {
 entry:
   %tmp2 = call i32 @strlen( i8* %P ) nounwind readonly     ; <i32> [#uses=1]
   %tmp3 = icmp eq i32 %tmp2, 100    ; <i1> [#uses=1]
   %tmp34 = zext i1 %tmp3 to i8    ; <i8> [#uses=1]

llvm/test/Transforms/NewGVN/calls-readonly.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 ; Should delete the second call to strlen even though the intervening strchr call exists.
 
 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-darwin7"
 
 define i8* @test(i8* %P, i8* %Q, i32 %x, i32 %y) nounwind readonly {
 entry:
   %0 = tail call i32 @strlen(i8* %P)              ; <i32> [#uses=2]

llvm/test/Transforms/NewGVN/completeness.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -enable-phi-of-ops=true -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -enable-phi-of-ops=true -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 define i32 @test1(i32, i8**) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp ne i32 [[TMP0:%.*]], 0
 ; CHECK-NEXT:    br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP5:%.*]]
 ; CHECK:         br label [[TMP6:%.*]]
 ; CHECK:         br label [[TMP6]]

llvm/test/Transforms/NewGVN/cond_br.ll

-; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
+; RUN: opt -passes=newgvn -S < %s | FileCheck %s
 @y = external global i32
 @z = external global i32
 
 ; Function Attrs: nounwind ssp uwtable
 define void @foo(i32 %x) {
 ; CHECK: @foo(i32 %x)
 ; CHECK: %.pre = load i32, i32* @y
 ; CHECK: call void @bar(i32 %.pre)

llvm/test/Transforms/NewGVN/condprop-xfail.ll

 ; XFAIL: *
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 @a = external global i32    ; <i32*> [#uses=7]
 
 ;; NewGVN takes two passes to get this, because we prune predicateinfo
 ; CHECK-LABEL: @test1(
 define i32 @test1() nounwind {
 entry:
   %0 = load i32, i32* @a, align 4

llvm/test/Transforms/NewGVN/condprop.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 
 declare void @foo(i1)
 declare void @bar(i32)
 
 define void @test_and(i32 %x, i32 %y) {
 ; CHECK-LABEL: @test_and(
 ; CHECK-NEXT:    [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0

llvm/test/Transforms/NewGVN/cyclic-phi-handling.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @foo(i32 %arg, i32 %arg1, i32 (i32, i32)* %arg2) {
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    br label %bb3
 ; CHECK:       bb3:
 ; CHECK-NEXT:    [[TMP:%.*]] = phi i32 [ %arg1, %bb ], [ [[TMP:%.*]]4, %bb7 ]

llvm/test/Transforms/NewGVN/deadstore.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 ;; Most of these are borrowed from transforms/DSE/simple.ll
 ;; NewGVN should be able to eliminate any stores of the same value that are actually redundnat.
 
 ;; tmp5 is store of the same value to the same location as the load.
 define void @test12({ i32, i32 }* %x) nounwind  {
 ; CHECK-LABEL: @test12(
 ; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr { i32, i32 }, { i32, i32 }* [[X:%.*]], i32 0, i32 0

llvm/test/Transforms/NewGVN/equivalent-phi.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 @global = common global [1024 x i32] zeroinitializer, align 16
 
 ;; We should be able to prove the equivalence of two of the phis, and then use that to eliminate
 ;; one set of indexing calculations and a load
 
 ; Function Attrs: nounwind ssp uwtable

llvm/test/Transforms/NewGVN/fence-xfail.ll

 ; XFAIL: *
-; RUN: opt -S -basic-aa -newgvn < %s | FileCheck %s
+; RUN: opt -S -passes=newgvn < %s | FileCheck %s
 
 @a = external constant i32
 ; We can value forward across the fence since we can (semantically) 
 ; reorder the following load before the fence.
 define i32 @test(i32* %addr.i) {
 ; CHECK-LABEL: @test
 ; CHECK: store
 ; CHECK: fence

llvm/test/Transforms/NewGVN/funclet.ll

-; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
+; RUN: opt -passes=newgvn -S < %s | FileCheck %s
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc"
 
 %eh.ThrowInfo = type { i32, i8*, i8*, i8* }
 %struct.A = type { i32* }
 
 @"_TI1?AUA@@" = external constant %eh.ThrowInfo
 

llvm/test/Transforms/NewGVN/lifetime-simple.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | 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-darwin7"
 
 define i8 @test(i8* %P) nounwind {
 ; CHECK: lifetime.start
 ; CHECK-NOT: load
 ; CHECK: lifetime.end

llvm/test/Transforms/NewGVN/load-constant-mem.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 ; PR4189
 @G = external constant [4 x i32]
 
 define i32 @test(i8* %p, i32 %i) nounwind {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[P:%.*]] = getelementptr [4 x i32], [4 x i32]* @G, i32 0, i32 [[I:%.*]]
 ; CHECK-NEXT:    store i8 4, i8* [[P:%.*]]

llvm/test/Transforms/NewGVN/loadforward.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 %rec11 = type { i16, i16, i16 }
 
 @str = global %rec11 { i16 1, i16 2, i16 3 }
 
 ;; Test that we forward the first store to the second load
 define i16 @bazinga() {

llvm/test/Transforms/NewGVN/malloc-load-removal.ll

-; RUN: opt -S -basic-aa -newgvn < %s | FileCheck %s
-; RUN: opt -S -basic-aa -newgvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
+; RUN: opt -S -passes=newgvn < %s | FileCheck %s
+; RUN: opt -S -passes=newgvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
 ; PR13694
 
 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.8.0"
 
 declare i8* @malloc(i64) nounwind
 
 define noalias i8* @test1() nounwind uwtable ssp {

llvm/test/Transforms/NewGVN/memory-handling.ll

 ;; This test is really dependent on propagating a lot of memory info around, but in the end, not
 ;; screwing up a single add.
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 %struct.Letter = type { i32, i32, i32, i32 }
 
 @alPhrase = external local_unnamed_addr global [26 x %struct.Letter], align 16
 @aqMainMask = external local_unnamed_addr global [2 x i64], align 16
 @aqMainSign = external local_unnamed_addr global [2 x i64], align 16
 @cchPhraseLength = external local_unnamed_addr global i32, align 4

llvm/test/Transforms/NewGVN/non-local-offset.ll

-; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
+; RUN: opt -passes=newgvn -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 ; GVN should ignore the store to p[1] to see that the load from p[0] is
 ; fully redundant.
 
 ; CHECK-LABEL: @yes(
 ; CHECK: if.then:

llvm/test/Transforms/NewGVN/nonescaping-malloc-xfail.ll

 ; XFAIL: *
 ; REQUIRES: asserts
-; RUN: opt < %s -basic-aa -newgvn -stats -disable-output 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=newgvn -stats -disable-output 2>&1 | FileCheck %s
 ; rdar://7363102
 
 ; CHECK: Number of loads deleted
 
 ; GVN should be able to eliminate load %tmp22.i, because it is redundant with
 ; load %tmp8.i. This requires being able to prove that %tmp7.i doesn't
 ; alias the malloc'd value %tmp.i20.i.i, which it can do since %tmp7.i
 ; is derived from %tmp5.i which is computed from a load, and %tmp.i20.i.i

llvm/test/Transforms/NewGVN/null-aliases-nothing.ll

-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 %t = type { i32 }
 declare void @test1f(i8*)
 
 define void @test1(%t* noalias %stuff ) {
     %p = getelementptr inbounds %t, %t* %stuff, i32 0, i32 0
     %before = load i32, i32* %p
 

llvm/test/Transforms/NewGVN/phi-translate-partial-alias.ll

-; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
+; RUN: opt -passes=newgvn -S < %s | 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-f128:128:128-n8:16:32:64"
 
 ; GVN shouldn't PRE the load around the loop backedge because it's
 ; not actually redundant around the loop backedge, despite appearances
 ; if phi-translation is ignored.
 
 ; CHECK: define void @test0(i8* %begin)

llvm/test/Transforms/NewGVN/pr10820-xfail.ll

 ; XFAIL: *
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 ; NewGVN fails this due to missing load coercion
 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-f128:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
 @g = external global i31
 
 define void @main() nounwind uwtable {

llvm/test/Transforms/NewGVN/pr24397.ll

-; RUN: opt -basic-aa -newgvn -disable-output < %s
+; RUN: opt -passes=newgvn -disable-output < %s
 
 target triple = "x86_64-unknown-linux-gnu"
 
 define i64 @foo(i64** %arrayidx) {
 entry:
   %p = load i64*, i64** %arrayidx, align 8
   %cmpnull = icmp eq i64* %p, null
   br label %BB2

llvm/test/Transforms/NewGVN/pr31472.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 ;; Ensure the invoke does not accidentally get deleted as unused, just because the value is not used.
 
 ; Function Attrs: norecurse ssp uwtable
 define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*){
 ; CHECK-LABEL: @main(

llvm/test/Transforms/NewGVN/pr31483.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 target datalayout = "E-m:e-i64:64-n32:64"
 
 @global = external hidden unnamed_addr constant [11 x i8], align 1
 ;; Ensure we do not believe the indexing increments are unreachable due to incorrect memory
 ;; equivalence detection.  In PR31483, we were deleting those blocks as unreachable
 ; Function Attrs: nounwind
 define signext i32 @ham(i8* %arg, i8* %arg1) #0 {
 ; CHECK-LABEL: @ham(

llvm/test/Transforms/NewGVN/pr31491.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 ;; Test that we do not infinite loop on this testcase, and that we do not try
 ;; to replace the phi node argument with the result of the phi node.
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 define internal i32 @pr31491() {
 ; CHECK-LABEL: @pr31491(
 ; CHECK-NEXT:  bb5:
 ; CHECK-NEXT:    br label %bb7

llvm/test/Transforms/NewGVN/pr31501.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 %struct.foo = type { %struct.wombat.28*, %struct.zot, %struct.wombat.28* }
 %struct.zot = type { i64 }
 %struct.barney = type <{ %struct.wombat.28*, %struct.wibble, %struct.snork, %struct.quux.4, %struct.snork.10, %struct.ham.16*, %struct.wobble.23*, i32, i8, i8, [2 x i8] }>
 %struct.wibble = type { %struct.pluto, %struct.bar }
 %struct.pluto = type { %struct.quux }
 %struct.quux = type { %struct.eggs }

llvm/test/Transforms/NewGVN/pr31573.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @patatino(i8* %blah) {
 ; CHECK-LABEL: @patatino(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[WHILE_COND:%.*]]
 ; CHECK:       while.cond:

llvm/test/Transforms/NewGVN/pr31594.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 define i1 @patatino(i8* %blah, i32 %choice) {
 ; CHECK-LABEL: @patatino(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[WHILE_COND:%.*]]
 ; CHECK:       while.cond:

llvm/test/Transforms/NewGVN/pr31613.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -enable-store-refinement -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -enable-store-refinement -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ;; Both of these tests are tests of phi nodes that end up all equivalent to each other
 ;; Without proper leader ordering, we will end up cycling the leader between all of them and never converge.
 
 define void @foo() {
 ; CHECK-LABEL: @foo(
 ; CHECK-NEXT:  bb:

llvm/test/Transforms/NewGVN/pr31682.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 %struct.foo = type { i32, i32, [2 x [4 x [6 x [6 x i16]]]] }
 
 @global = external global %struct.foo*
 
 define void @bar() {
 ; CHECK-LABEL: @bar(

llvm/test/Transforms/NewGVN/pr33196.ll

-; RUN: opt -S -basic-aa -newgvn %s | FileCheck %s
+; RUN: opt -S -passes=newgvn %s | FileCheck %s
 
 ; CHECK: define i32 @main() {
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:   %tmp = load i32, i32* @d, align 4
 ; CHECK-NEXT:   %tmp1 = load i32, i32* @c, align 4
 ; CHECK-NEXT:   %tobool = icmp eq i32 %tmp1, -1
 ; CHECK-NEXT:   br i1 %tobool, label %if.end, label %if.then
 ; CHECK: if.then:

llvm/test/Transforms/NewGVN/pre-new-inst-xfail.ll

 ; XFAIL: *
-; RUN: opt -basic-aa -newgvn -S %s | FileCheck %s
+; RUN: opt -passes=newgvn -S %s | FileCheck %s
 
 %MyStruct = type { i32, i32 }
 define i8 @foo(i64 %in, i8* %arr) {
   %addr = alloca %MyStruct
   %dead = trunc i64 %in to i32
   br i1 undef, label %next, label %tmp
 
 tmp:

llvm/test/Transforms/NewGVN/predicates.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
+; RUN: opt -passes=newgvn -S < %s | FileCheck %s
 
 ; Function Attrs: noinline norecurse nounwind readonly ssp uwtable
 define i32 @mp_unsgn_cmp(i32 %n, i32* nocapture readonly %in1, i32* nocapture readonly %in2) local_unnamed_addr {
 ; CHECK-LABEL: @mp_unsgn_cmp(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP11:%.*]] = icmp sgt i32 [[N:%.*]], -1
 ; CHECK-NEXT:    br i1 [[CMP11]], label [[FOR_INC_PREHEADER:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       for.inc.preheader:

llvm/test/Transforms/NewGVN/range.ll

-; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
+; RUN: opt -passes=newgvn -S < %s | FileCheck %s
 
 define i32 @test1(i32* %p) {
 ; CHECK-LABEL: @test1(i32* %p)
 ; CHECK: %a = load i32, i32* %p, align 4, !range ![[RANGE0:[0-9]+]]
 ; CHECK: %c = add i32 %a, %a
   %a = load i32, i32* %p, !range !0
   %b = load i32, i32* %p, !range !0
   %c = add i32 %a, %b

llvm/test/Transforms/NewGVN/refine-stores.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 ;; Now that we do store refinement, we have to verify that we add fake uses
 ;; when we skip existing stores.
 ;; We also are testing that various variations that cause stores to move classes
 ;; have the right class movement happen
 ;; All of these tests result in verification failures if it does not.
 
 source_filename = "bugpoint-output-daef094.bc"
 target triple = "x86_64-apple-darwin16.5.0"

llvm/test/Transforms/NewGVN/rle-must-alias-xfail.ll

 ; XFAIL: *
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 ; GVN should eliminate the fully redundant %9 GEP which 
 ; allows DEAD to be removed.  This is PR3198.
 
 ; The %7 and %4 loads combine to make %DEAD unneeded.
 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-darwin7"
 @H = common global [100 x i32] zeroinitializer, align 32    ; <[100 x i32]*> [#uses=3]

llvm/test/Transforms/NewGVN/rle-nonlocal.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
+; RUN: opt < %s -passes=newgvn -S | FileCheck %s
 
 define i32 @main(i32** %p, i32 %x, i32 %y) {
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:  block1:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[BLOCK2:%.*]], label [[BLOCK3:%.*]]
 ; CHECK:       block2:
 ; CHECK-NEXT:    [[A:%.*]] = load i32*, i32** [[P:%.*]]