[WIP][Test][NewPM] Migrating llvm/test/Transforms/{GVNHoist,GVNSink} to use `opt -passes=foo`

[xgupta]

Summary

Now that the new PM has been the default for the optimization
pipeline for a while, it would be better to start doing is cleaning up lit
tests that use opt.

[xgupta]

I mark this revision as WIP because the automatic script is not yet complete. Out of 34 tests of llvm/test/Transforms/GVNHoist only 29 are passing and out of 9 tests of only 7 are passing. And it seems few passes are rename b/w New and legacy PM, for example, verify-memoryssa is now changed to verify<memoryssa> in NewPM. And also -earlycse-debug-hash is not exist in NewPM as I can see from opt --print-passes.

I will look into more after a couple of days and fix the remaining issues and Also test & update the script for other lit tests that use opt tool.

[xgupta]

Not motivated to complete it now :)

llvm/test/Transforms/GVNHoist/hoist-call.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | FileCheck %s
 
 ; Check that the call and fcmp are hoisted.
 ; CHECK-LABEL: define void @fun(
 ; CHECK: call float
 ; CHECK: fcmp oeq
 ; CHECK-NOT: call float
 ; CHECK-NOT: fcmp oeq
 

llvm/test/Transforms/GVNHoist/hoist-convergent.ll

-; RUN: opt -gvn-hoist -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist' -S < %s | FileCheck %s
 
 ; Check that convergent calls are not hoisted.
 ;
 ; CHECK-LABEL: @no_convergent_func_hoisting(
 ; CHECK: if.then:
 ; CHECK: call float @convergent_func(
 
 ; CHECK: if.else:

llvm/test/Transforms/GVNHoist/hoist-md.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | 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 @test1(i1 %b, i32* %x) {
 entry:
   br i1 %b, label %if.then, label %if.else
 
 if.then:                                          ; preds = %entry

llvm/test/Transforms/GVNHoist/hoist-more-than-two-branches.ll

-; RUN: opt -gvn-hoist -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist' -S < %s | FileCheck %s
 
 ; CHECK: store
 ; CHECK-NOT: store
 
 ; Check that an instruction can be hoisted to a basic block
 ; with more than two successors.
 
 @G = external global i32, align 4

llvm/test/Transforms/GVNHoist/hoist-mssa.ll

-; RUN: opt -S -gvn-hoist -newgvn < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist,newgvn' < %s | FileCheck %s
 
 ; Check that store hoisting works: there should be only one store left.
 ; CHECK-LABEL: @getopt
 ; CHECK: store i32
 ; CHECK-NOT: store i32
 
 @optind = external global i32, align 4
 

llvm/test/Transforms/GVNHoist/hoist-newgvn.ll

-; RUN: opt -gvn-hoist -newgvn -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist,newgvn' -S < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @GlobalVar = internal global float 1.000000e+00
 
 ; Check that we hoist load and scalar expressions in dominator.
 ; CHECK-LABEL: @dominatorHoisting
 ; CHECK: load

llvm/test/Transforms/GVNHoist/hoist-pr20242.ll

-; RUN: opt -gvn-hoist -newgvn -gvn-hoist  -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist,newgvn' gvn-hoist,-S < %s | FileCheck %s
 ; Test to demonstrate that newgvn creates opportunities for
 ; more gvn-hoist when sibling branches contain identical expressions.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Check that all "or" expressions are hoisted.
 ; CHECK-LABEL: @encode

llvm/test/Transforms/GVNHoist/hoist-pr22005.ll

-; RUN: opt -gvn-hoist -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist' -S < %s | FileCheck %s
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Check that all "sub" expressions are hoisted.
 ; CHECK-LABEL: @fun
 ; CHECK: sub i64
 ; CHECK-NOT: sub i64
 

llvm/test/Transforms/GVNHoist/hoist-pr28606.ll

-; RUN: opt -gvn-hoist -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist' -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-msvc18.0.0"
 
 %struct.S = type { i8* }
 
 declare void @f(<{ %struct.S }>* inalloca(<{ %struct.S }>))
 

llvm/test/Transforms/GVNHoist/hoist-pr28933.ll

-; RUN: opt -S -gvn-hoist -verify-memoryssa -newgvn < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist,verify-memoryssa -passes='newgvn' < %s | FileCheck %s
 
 ; Check that we end up with one load and one store, in the right order
 ; CHECK-LABEL:  define void @test_it(
 ; CHECK: store
 ; CHECK-NOT: store
 ; CHECK-NOT: load
         
 %rec894.0.1.2.3.12 = type { i16 }

llvm/test/Transforms/GVNHoist/hoist-pr31891.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | FileCheck %s
 
 ; Hoisted inlinable calls need to have accurate scope information, but we're
 ; allowed to erase the line information.
 
 source_filename = "t.c"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.24215"
 

llvm/test/Transforms/GVNHoist/hoist-recursive-geps.ll

-; RUN: opt -gvn-hoist -newgvn -gvn-hoist -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist,newgvn' -passes='gvn-hoist' -S < %s | FileCheck %s
 
 ; Check that recursive GEPs are hoisted. Since hoisting creates
 ; fully redundant instructions, newgvn is run to remove them which then
 ; creates more opportunites for hoisting.
 
 ; CHECK-LABEL: @fun
 ; CHECK: load
 ; CHECK: fdiv

llvm/test/Transforms/GVNHoist/hoist-simplify-phi.ll

-; RUN: opt < %s -gvn-hoist -S | FileCheck %s
+; RUN: opt < %s -passes='gvn-hoist' -S | FileCheck %s
 
 ; This test is meant to make sure that MemorySSAUpdater works correctly
 ; in non-trivial cases.
 
 ; CHECK: if.else218:
 ; CHECK-NEXT: %0 = getelementptr inbounds %s, %s* undef, i32 0, i32 0
 ; CHECK-NEXT: %1 = load i32, i32* %0, align 4
 

llvm/test/Transforms/GVNHoist/hoist-unsafe-pr31729.ll

-; RUN: opt -gvn-hoist -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist' -S < %s | FileCheck %s
 
 ; Check that urem is not hoisted.
 ; CHECK-LABEL: @main
 ; CHECK: urem
 ; CHECK: urem
 ; CHECK: urem
 
 @g_x_s = global i32 -470211272, align 4

llvm/test/Transforms/GVNHoist/hoist-very-busy.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | FileCheck %s
 
 %struct.__jmp_buf_tag = type { [8 x i64], i32 }
 
 ; Check that hoisting only happens when the expression is very busy.
 ; CHECK: store
 ; CHECK: store
 
 @test_exit_buf = global %struct.__jmp_buf_tag zeroinitializer

llvm/test/Transforms/GVNHoist/hoist.ll

-; RUN: opt -gvn-hoist -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist' -S < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @GlobalVar = internal global float 1.000000e+00
 
 ; Check that all scalar expressions are hoisted.
 ;
 ; CHECK-LABEL: @scalarsHoisting

llvm/test/Transforms/GVNHoist/infinite-loop-direct.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | FileCheck %s
 
 ; Checking gvn-hoist in case of infinite loops and irreducible control flow.
 
 ; Check that bitcast is not hoisted beacuse down safety is not guaranteed.
 ; CHECK-LABEL: @bazv1
 ; CHECK: if.then.i:
 ; CHECK: bitcast
 ; CHECK-NEXT: load

llvm/test/Transforms/GVNHoist/infinite-loop-indirect.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | FileCheck %s
 
 ; Checking gvn-hoist in case of indirect branches.
 
 ; Check that the bitcast is not hoisted because it is after an indirect call
 ; CHECK-LABEL: @foo
 ; CHECK-LABEL: l1.preheader:
 ; CHECK-NEXT: bitcast
 ; CHECK-LABEL: l1

llvm/test/Transforms/GVNHoist/int_sideeffect.ll

-; RUN: opt -S < %s -gvn-hoist | FileCheck %s
+; RUN: opt -S < %s -passes='gvn-hoist' | FileCheck %s
 
 declare void @llvm.sideeffect()
 
 ; GVN hoisting across a @llvm.sideeffect.
 
 ; CHECK-LABEL: scalarsHoisting
 ; CHECK: = fsub
 ; CHECK: br i1 %cmp,

llvm/test/Transforms/GVNHoist/ld_hoist1.ll

 ; Test load hoist
-; RUN: opt -gvn-hoist -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist' -S < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc_linux"
 
 ; Function Attrs: nounwind uwtable
 define float* @foo(i32* noalias nocapture readonly %in, float* noalias %out, i32 %size, i32* nocapture readonly %trigger)  {
 entry:
   %cmp11 = icmp eq i32 %size, 0
   br i1 %cmp11, label %for.end, label %for.body.lr.ph

llvm/test/Transforms/GVNHoist/ld_hoist_st_sink.ll

 ; Tests to make sure that loads and stores in a diamond get merged
 ; Loads are hoisted into the header. Stores sunks into the footer.
-; RUN: opt -gvn-hoist -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-hoist' -S < %s | FileCheck %s
 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
 
 %struct.node = type { i64, %struct.node*, %struct.node*, %struct.node*, i64, %struct.arc*, i64, i64, i64 }
 %struct.arc = type { i64, i64, i64 }
 
 define i64 @foo(%struct.node* nocapture readonly %r) nounwind {
 entry:
   %node.0.in16 = getelementptr inbounds %struct.node, %struct.node* %r, i64 0, i32 2

llvm/test/Transforms/GVNHoist/non-trivial-phi.ll

-; RUN: opt -gvn-hoist %s -S -o - | FileCheck %s
+; RUN: opt -passes='gvn-hoist' %s -S -o - | FileCheck %s
 
 ; CHECK: store
 ; CHECK-NOT: store
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 
 define void @f(i8* %p) {
 entry:

llvm/test/Transforms/GVNHoist/pr28626.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | 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 @test1(i1 %a, i1** %d) {
 entry:
   %0 = load i1*, i1** %d, align 8
   br i1 %a, label %if.then, label %if.else
 

 ; CHECK:  %[[load:.*]] = load i1*, i1** %d, align 8
 ; CHECK:  %[[phi:.*]] = phi i1 [ true, {{.*}} ], [ false, {{.*}} ]
 
 ; CHECK: %[[gep0:.*]] = getelementptr inbounds i1, i1* %[[load]], i64 0
 ; CHECK: store i1 %[[phi]], i1* %[[gep0]], align 4
 
 ; Check that store instructions are hoisted.
 ; CHECK-NOT: store
 No newline at end of file

llvm/test/Transforms/GVNHoist/pr29031.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | FileCheck %s
 
 ; Check that the stores are not hoisted: it is invalid to hoist stores if they
 ; are not executed on all paths. In this testcase, there are paths in the loop
 ; that do not execute the stores.
 
 ; CHECK-LABEL: define i32 @main
 ; CHECK: store
 ; CHECK: store

llvm/test/Transforms/GVNHoist/pr29034.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | FileCheck %s
 
 ; Check that the stores are not hoisted: it is invalid to hoist stores if they
 ; are not executed on all paths. In this testcase, there are paths in the loop
 ; that do not execute the stores.
 
 ; CHECK-LABEL: define void @music_task
 ; CHECK: store
 ; CHECK: store

llvm/test/Transforms/GVNHoist/pr30216.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | FileCheck %s
 
 ; Make sure the two stores @B do not get hoisted past the load @B.
 
 ; CHECK-LABEL: define i8* @Foo
 ; CHECK: store
 ; CHECK: store
 ; CHECK: load
 ; CHECK: store

llvm/test/Transforms/GVNHoist/pr30499.ll

-; RUN: opt -S -gvn-hoist < %s
+; RUN: opt -S -passes='gvn-hoist' < %s
 
 define void @_Z3fn2v() #0 {
 entry:
   %a = alloca i8*, align 8
   %b = alloca i32, align 4
   %0 = load i8*, i8** %a, align 8
   store i8 0, i8* %0, align 1
   %1 = load i32, i32* %b, align 4

llvm/test/Transforms/GVNHoist/pr35222-hoist-load.ll

-; RUN: opt -S -gvn-hoist < %s | FileCheck %s
+; RUN: opt -S -passes='gvn-hoist' < %s | FileCheck %s
 ; CHECK-LABEL: build_tree
 ; CHECK: load
 ; CHECK: load
 ; Check that the load is not hoisted because the call can potentially
 ; modify the global
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 

llvm/test/Transforms/GVNHoist/pr36787.ll

-; RUN: opt < %s -gvn-hoist -S | FileCheck %s
+; RUN: opt < %s -passes='gvn-hoist' -S | FileCheck %s
 
 @g = external constant i8*
 
 declare i32 @gxx_personality(...)
 declare void @f0()
 declare void @f1()
 declare void @f2()
 

llvm/test/Transforms/GVNHoist/pr37445.ll

-; RUN: opt < %s -early-cse-memssa -earlycse-debug-hash -gvn-hoist -S | FileCheck %s
+; RUN: opt < %s -passes='early-cse-memssa' -earlycse-debug-hash -passes='gvn-hoist' -S | FileCheck %s
 
 ; Make sure opt won't crash and that this pair of
 ; instructions (load, icmp) is hoisted successfully
 ; from bb45 and bb58 to bb41.
 
 @g_10 = external global i32, align 4
 @g_536 = external global i8*, align 8
 @g_1629 = external global i32**, align 8

llvm/test/Transforms/GVNHoist/pr37808.ll

-; RUN: opt < %s -gvn-hoist -S | FileCheck %s
+; RUN: opt < %s -passes='gvn-hoist' -S | FileCheck %s
 
 define void @func() {
 ; CHECK-LABEL: @func()
 ; CHECK:       bb6:
 ; CHECK:         store i64 0, i64* undef, align 8
 ; CHECK:       bb7:
 ; CHECK-NOT:     store i64 0, i64* undef, align 8
 ; CHECK:       bb8:

llvm/test/Transforms/GVNHoist/pr38807.ll

-; RUN: opt < %s -early-cse-memssa -earlycse-debug-hash -gvn-hoist -S | FileCheck %s
+; RUN: opt < %s -passes='early-cse-memssa' -earlycse-debug-hash -passes='gvn-hoist' -S | FileCheck %s
 
 ; Make sure opt doesn't crash. On top of that, the instructions
 ; of the side blocks should be hoisted to the entry block.
 
 %s = type { i32, i64 }
 %S = type { %s, i32 }
 
 ;CHECK-LABEL: @foo

llvm/test/Transforms/GVNHoist/pr45442.ll

-; RUN: opt < %s -gvn-hoist -S | FileCheck %s
+; RUN: opt < %s -passes='gvn-hoist' -S | FileCheck %s
 
 ; gvn-hoist shouldn't crash in this case.
 ; CHECK-LABEL: @func(i1 %b)
 ; CHECK:       entry:
 ; CHECK-NEXT:  br i1
 ; CHECK:  bb1:
 ; CHECK-NEXT:  ret void
 ; CHECK:  bb2:

llvm/test/Transforms/GVNSink/dither.ll

-; RUN: opt < %s -S -gvn-sink | FileCheck %s
+; RUN: opt < %s -S -passes='gvn-sink' | FileCheck %s
 
 ; Because %tmp17 has flipped operands to its equivalents %tmp14 and %tmp7, we
 ; can't sink the zext as we'd need a shuffling PHI in between.
 ;
 ; Just sinking the zext isn't profitable, so ensure nothing is sunk.
 
 ; CHECK-LABEL: @hoge
 ; CHECK-NOT: bb18.gvnsink.split

llvm/test/Transforms/GVNSink/fpmath.ll

-; RUN: opt -S < %s -gvn-sink | FileCheck %s
+; RUN: opt -S < %s -passes='gvn-sink' | FileCheck %s
 
 ; CHECK-LABEL: sink
 ; CHECK-NOT: fneg
 ; CHECK: = phi
 ; CHECK: fneg
 define float @sink(float %a, float %b, i1 %cmp) {
 entry:
   br i1 %cmp, label %if.then, label %if.else

llvm/test/Transforms/GVNSink/indirect-call.ll

-; RUN: opt < %s -gvn-sink -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -hoist-common-insts=true -simplifycfg-sink-common=false -S | FileCheck %s
+; RUN: opt < %s -passes='gvn-sink,simplifycfg' -passes='simplifycfg-require-and-preserve-domtree=1 -hoist-common-insts=true -passes=simplifycfg-sink-common=false -S | FileCheck %s
 
 declare i8 @ext(i1)
 
 define zeroext i1 @test1(i1 zeroext %flag, i32 %blksA, i32 %blksB, i32 %nblks, i8(i1)* %ext) {
 entry:
   %cmp = icmp uge i32 %blksA, %nblks
   br i1 %flag, label %if.then, label %if.else
 

llvm/test/Transforms/GVNSink/int_sideeffect.ll

-; RUN: opt -S < %s -gvn-sink | FileCheck %s
+; RUN: opt -S < %s -passes='gvn-sink' | FileCheck %s
 
 declare void @llvm.sideeffect()
 
 ; GVN sinking across a @llvm.sideeffect.
 
 ; CHECK-LABEL: scalarsSinking
 ; CHECK-NOT: fmul
 ; CHECK: = phi

llvm/test/Transforms/GVNSink/operand-mismatch.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -gvn-sink -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-sink' -S < %s | FileCheck %s
 
 ; This would assert/crash because the calls have different numbers of operands:
 ; https://bugs.llvm.org/show_bug.cgi?id=42346
 
 %vec = type opaque
 %map = type { i32 }
 
 define void @PR42346() {

llvm/test/Transforms/GVNSink/sink-combine-metadata.ll

-; RUN: opt < %s -gvn-sink -S | FileCheck %s
+; RUN: opt < %s -passes='gvn-sink' -S | FileCheck %s
 
 ; Check that nonnull metadata for non-dominating loads is not propagated.
 ; CHECK-LABEL: @test1(
 ; CHECK-LABEL: if.end:
 ; CHECK:  %[[ptr:.*]] = phi i32**
 ; CHECK: %[[load:.*]] = load i32*, i32** %[[ptr]]
 ; CHECK-NOT: !nonnull
 ; CHECK: ret i32* %[[load]]

llvm/test/Transforms/GVNSink/sink-common-code.ll

-; RUN: opt < %s -gvn-sink -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -hoist-common-insts=true -simplifycfg-sink-common=false -S | FileCheck %s
+; RUN: opt < %s -passes='gvn-sink,simplifycfg' -passes='simplifycfg-require-and-preserve-domtree=1 -hoist-common-insts=true -passes=simplifycfg-sink-common=false -S | FileCheck %s
 
 define zeroext i1 @test1(i1 zeroext %flag, i32 %blksA, i32 %blksB, i32 %nblks) {
 entry:
   br i1 %flag, label %if.then, label %if.else
 
 ; CHECK-LABEL: test1
 ; CHECK: add
 ; CHECK: select

llvm/test/Transforms/GVNSink/struct.ll

-; RUN: opt -gvn-sink -S < %s | FileCheck %s
-; RUN: opt -passes=gvn-sink -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-sink' -S < %s | FileCheck %s
+; RUN: opt -passes='gvn-sink' -S < %s | FileCheck %s
 
 %struct = type {i32, i32}
 %struct2 = type { [ 2 x i32], i32 }
 
 ; Struct indices cannot be variant.
 
 ; CHECK-LABEL: @f() {
 ; CHECK: getelementptr