[test] Use -passes syntax in SROA test cases

[bjope]

Summary

Another step to move away from the legacy PM syntax when specifying
passes in opt.

llvm/test/Transforms/SROA/2009-02-20-InstCombine-SROA.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 ; rdar://6417724
 
 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.6"
 
 %"struct.std::vector<int,std::allocator<int> >" = type { %"struct.std::_Vector_base<int,std::allocator<int> >" }
 %"struct.std::_Vector_base<int,std::allocator<int> >" = type { %"struct.std::_Vector_base<int,std::allocator<int> >::_Vector_impl" }

llvm/test/Transforms/SROA/address-spaces.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-p1:16:16:16-p3:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1)
 declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture readonly, i32, i1)
 declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
 declare void @llvm.memcpy.p1i8.p1i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
 
 

llvm/test/Transforms/SROA/addrspacecast.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
 ; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture writeonly, i8 addrspace(1)* nocapture readonly, i32, i1 immarg) #0
 declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture writeonly, i8* nocapture readonly, i32, i1 immarg) #0
 
 define i64 @alloca_addrspacecast_bitcast(i64 %X) {

llvm/test/Transforms/SROA/alignment.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
-; RUN: opt -debugify -sroa -S < %s | FileCheck %s -check-prefix DEBUGLOC
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
+; RUN: opt -passes='debugify,function(sroa)' -S < %s | FileCheck %s -check-prefix DEBUGLOC
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1)
 
 define void @test1({ i8, i8 }* %a, { i8, i8 }* %b) {
 ; CHECK-LABEL: @test1(
 ; CHECK: %[[gep_a0:.*]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %a, i64 0, i32 0

llvm/test/Transforms/SROA/alloca-address-space.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
 ; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-p1:16:16:16-p2:32:32-p3:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64-A2"
 
 declare void @llvm.memcpy.p2i8.p2i8.i32(i8 addrspace(2)* nocapture, i8 addrspace(2)* nocapture readonly, i32, i1)
 declare void @llvm.memcpy.p1i8.p2i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(2)* nocapture readonly, i32, i1)
 declare void @llvm.memcpy.p2i8.p1i8.i32(i8 addrspace(2)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
 declare void @llvm.memcpy.p1i8.p1i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
 

llvm/test/Transforms/SROA/alloca-struct.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
 ; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.RetValIntChar = type { i32, i8 }
 %struct.RetValTwoInts = type { i32, i32 }
 %struct.RetValOneIntTwoChar = type { i32, i8 }
 

llvm/test/Transforms/SROA/assume.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 source_filename = "tmp.cpp"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.n.2 = type { i8 }
 %struct.bi = type { %class.as }
 %class.as = type { %class.ao }

llvm/test/Transforms/SROA/basictest.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
 ; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
 
 define i32 @test0() {

llvm/test/Transforms/SROA/big-endian.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 define i8 @test1() {
 ; We fully promote these to the i24 load or store size, resulting in just masks
 ; and other operations that instcombine will fold, but no alloca. Note this is
 ; the same as test12 in basictest.ll, but here we assert big-endian byte
 ; ordering.

llvm/test/Transforms/SROA/dbg-addr-diamond.ll

-; RUN: opt -use-dbg-addr -sroa -S < %s | FileCheck %s
+; RUN: opt -use-dbg-addr -passes=sroa -S < %s | FileCheck %s
 
 ; ModuleID = '<stdin>'
 source_filename = "newvars.c"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.24215"
 
 %struct.Pair = type { i32, i32 }
 

llvm/test/Transforms/SROA/dbg-inline.ll

 ; Test that SROA can deal with allocas that have more than one
 ; dbg.declare hanging off of it.
 
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 source_filename = "/tmp/inlinesplit.cpp"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.15.0"
 
 %struct.pair = type { i64, i64 }
 
 ; Function Attrs: noinline optnone ssp uwtable
 define i64 @_Z1g4pair(i64 %p.coerce0, i64 %p.coerce1) #0 !dbg !8 {

llvm/test/Transforms/SROA/dbg-single-piece.ll

-; RUN: opt -sroa %s -S | FileCheck %s
+; RUN: opt -passes=sroa %s -S | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 %foo = type { [8 x i8], [8 x i8] }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
 define void @_ZL18findInsertLocationPN4llvm17MachineBasicBlockENS_9SlotIndexERNS_13LiveIntervalsE() {
 entry:
   %retval = alloca %foo, align 8

llvm/test/Transforms/SROA/fca.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 define { i32, i32 } @test0(i32 %x, i32 %y) {
 ; CHECK-LABEL: @test0(
 ; CHECK-NOT: alloca
 ; CHECK: insertvalue { i32, i32 }
 ; CHECK: insertvalue { i32, i32 }
 ; CHECK: ret { i32, i32 }

llvm/test/Transforms/SROA/ignore-droppable.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -sroa -S -o - < %s | FileCheck %s
-; RUN: opt -passes=sroa -S -o - < %s | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 declare void @llvm.assume(i1)
 declare void @llvm.lifetime.start.p0i8(i64 %size, i8* nocapture %ptr)
 declare void @llvm.lifetime.end.p0i8(i64 %size, i8* nocapture %ptr)
 
 define void @positive_assume_uses(i32* %arg) {
 ; CHECK-LABEL: @positive_assume_uses(
 ; CHECK-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(i32* [[ARG:%.*]]), "ignore"(i32* undef, i64 2) ]

llvm/test/Transforms/SROA/irregular-type.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 %S = type { [4 x i8] }
 
 ; Ensure the load/store of integer types whose size is not equal to the store
 ; size are not split.
 
 define i8 @foo(i23 %0) {
 ; CHECK-LABEL: @foo(

llvm/test/Transforms/SROA/mem-par-metadata-sroa-cast.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 ;
 ; Make sure the llvm.access.group meta-data is preserved
 ; when a load/store is replaced with another load/store by sroa
 ; Ensure this is done for casting too.
 ;
 ; CHECK: entry:
 ; CHECK: load i32, i32* {{.*}}, !llvm.access.group [[DISTINCT:![0-9]*]]
 ; CHECK: load i32, i32* {{.*}}, !llvm.access.group [[DISTINCT]]

llvm/test/Transforms/SROA/mem-par-metadata-sroa.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 ;
 ; Make sure the llvm.access.group meta-data is preserved
 ; when a load/store is replaced with another load/store by sroa
 ;
 ; class Complex {
 ; private:
 ;  float real_;
 ;  float imaginary_;

llvm/test/Transforms/SROA/non-integral-pointers.ll

-; RUN: opt -sroa -S < %s | FileCheck %s
+; RUN: opt -passes=sroa -S < %s | FileCheck %s
 
 ; This test checks that SROA does not introduce ptrtoint and inttoptr
 ; casts from and to non-integral pointers.  The "ni:4" bit in the
 ; datalayout states that pointers of address space 4 are to be
 ; considered "non-integral".
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4"
 target triple = "x86_64-unknown-linux-gnu"

llvm/test/Transforms/SROA/phi-and-select.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 define i32 @test1() {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND:%.*]] = icmp sle i32 0, 1
 ; CHECK-NEXT:    br i1 [[COND]], label [[THEN:%.*]], label [[EXIT:%.*]]
 ; CHECK:       then:

llvm/test/Transforms/SROA/phi-catchswitch.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 %struct.foo = type { i32 }
 declare i32 @__gxx_wasm_personality_v0(...)
 declare void @foo()
 

llvm/test/Transforms/SROA/phi-gep.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -sroa < %s | FileCheck %s
+; RUN: opt -S -passes=sroa < %s | FileCheck %s
 
 %pair = type { i32, i32 }
 
 define i32 @test_sroa_phi_gep(i1 %cond) {
 ; CHECK-LABEL: @test_sroa_phi_gep(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[IF_THEN:%.*]], label [[END:%.*]]
 ; CHECK:       if.then:

llvm/test/Transforms/SROA/phi-with-duplicate-pred.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 @a = external global i16, align 1
 
 declare void @maybe_writes()
 
 define void @f2() {
 ; CHECK-LABEL: @f2(

llvm/test/Transforms/SROA/pointer-offset-size.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64:32"
 
 %struct.test = type { %struct.basic, %struct.basic }
 %struct.basic = type { i16, i8 }
 
 define i16 @test(%struct.test* %ts2.i) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:

llvm/test/Transforms/SROA/ppcf128-no-fold.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
 
 %struct.ld2 = type { [2 x ppc_fp128] }
 declare void @bar(i8*, [2 x i128])
 
 define void @foo(i8* %v) #0 {
 entry:

llvm/test/Transforms/SROA/pr26972.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux"
 
 ; Make sure we properly handle allocas where the allocated
 ; size overflows a uint32_t. This specific constant results in
 ; the size in bits being 32 after truncation to a 32-bit int.
 ; CHECK-LABEL: fn1
 ; CHECK-NEXT: ret void
 define void @fn1() {
   %a = alloca [1073741825 x i32], align 16
   %t0 = bitcast [1073741825 x i32]* %a to i8*
   call void @llvm.lifetime.end.p0i8(i64 4294967300, i8* %t0)
   ret void
 }
 
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)

llvm/test/Transforms/SROA/pr37267.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -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-n32:64-S128"
 target triple = "sparcv9-sun-solaris"
 
 ; PR37267
 ; Check that we don't crash on this test.
 
 define i16 @f1() {
 ; CHECK-LABEL: @f1(

llvm/test/Transforms/SROA/preserve-nonnull.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 ;
 ; Make sure that SROA doesn't lose nonnull metadata
 ; on loads from allocas that get optimized out.
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
 
 ; Check that we do basic propagation of nonnull when rewriting.
 define i8* @propagate_nonnull(i32* %v) {

llvm/test/Transforms/SROA/scalable-vectors.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 ; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 ; This test checks that SROA runs mem2reg on scalable vectors.
 
 define <vscale x 16 x i1> @alloca_nxv16i1(<vscale x 16 x i1> %pg) {
 ; CHECK-LABEL: @alloca_nxv16i1(
 ; CHECK-NEXT:    ret <vscale x 16 x i1> [[PG:%.*]]
 ;

llvm/test/Transforms/SROA/select-gep.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -sroa < %s | FileCheck %s
+; RUN: opt -S -passes=sroa < %s | FileCheck %s
 
 %pair = type { i32, i32 }
 
 define i32 @test_sroa_select_gep(i1 %cond) {
 ; CHECK-LABEL: @test_sroa_select_gep(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[LOAD_SROA_SPECULATED:%.*]] = select i1 [[COND:%.*]], i32 1, i32 2
 ; CHECK-NEXT:    ret i32 [[LOAD_SROA_SPECULATED]]

llvm/test/Transforms/SROA/select-load.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -sroa < %s | FileCheck %s
+; RUN: opt -S -passes=sroa < %s | FileCheck %s
 
 %st.half = type { half }
 
 ; Allow speculateSelectInstLoads to fold load and select
 ; even if there is an intervening bitcast.
 define <2 x i16> @test_load_bitcast_select(i1 %cond1, i1 %cond2) {
 ; CHECK-LABEL: @test_load_bitcast_select(
 ; CHECK-NEXT:  entry:

llvm/test/Transforms/SROA/slice-order-independence.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
 
 ; Check that the chosen type for a split is independent from the order of
 ; slices even in case of types that are skipped because their width is not a
 ; byte width multiple
 define void @skipped_inttype_first({ i16*, i32 }*) {

llvm/test/Transforms/SROA/slice-width.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-f80:128-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind
 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
 
 ; This tests that allocas are not split into slices that are not byte width multiple
 define void @no_split_on_non_byte_width(i32) {

llvm/test/Transforms/SROA/std-clamp.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define float @_Z8stdclampfff(float %x, float %lo, float %hi) {
 ; CHECK-LABEL: @_Z8stdclampfff(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[I4:%.*]] = alloca float, align 4
 ; CHECK-NEXT:    store float [[HI:%.*]], float* [[I4]], align 4

llvm/test/Transforms/SROA/tbaa-struct.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -sroa %s | FileCheck %s
+; RUN: opt -S -passes=sroa %s | FileCheck %s
 
 ; SROA should keep `!tbaa.struct` metadata
 
 %vector = type { float, float }
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* writeonly, i8* readonly, i64, i1 immarg)
 declare <2 x float> @foo(%vector* %0)
 
 define void @bar(%vector* %y2) {

llvm/test/Transforms/SROA/tbaa-struct2.ll

-; RUN: opt -S -sroa %s | FileCheck %s
+; RUN: opt -S -passes=sroa %s | FileCheck %s
 
 ; SROA should correctly offset `!tbaa.struct` metadata
 
 %struct.Wishart = type { double, i32 }
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* writeonly, i8* readonly, i64, i1 immarg)
 declare double @subcall(double %g, i32 %m)
 
 define double @bar(%struct.Wishart* %wishart) {

llvm/test/Transforms/SROA/tbaa-subload.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -sroa %s | FileCheck %s
+; RUN: opt -S -passes=sroa %s | FileCheck %s
 
 ; This should not crash
 
 %class.ar = type { i8 }
 %class.anon = type <{ %class.ar, [7 x i8], { i64, i64 } }>
 
 define void @caller() {
 ; CHECK-LABEL: @caller(

llvm/test/Transforms/SROA/vector-conversion.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 define <4 x i64> @vector_ptrtoint({<2 x i32*>, <2 x i32*>} %x) {
 ; CHECK-LABEL: @vector_ptrtoint
   %a = alloca {<2 x i32*>, <2 x i32*>}
 ; CHECK-NOT: alloca
 
   store {<2 x i32*>, <2 x i32*>} %x, {<2 x i32*>, <2 x i32*>}* %a

llvm/test/Transforms/SROA/vector-lifetime-intrinsic.ll

-; RUN: opt -sroa -S < %s | FileCheck %s
+; RUN: opt -passes=sroa -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:32-i64:32-v32:32-n32-S64"
 
 ; Function Attrs: nounwind
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
 
 ; Function Attrs: nounwind
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0

llvm/test/Transforms/SROA/vector-promotion-different-size.ll

-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 define <4 x i1> @vector_bitcast() {
   ; CHECK-LABEL: @vector_bitcast
   ; CHECK: alloca <3 x i1>
 
     %a = alloca <3 x i1>
     store <3 x i1> <i1 1,i1 0,i1 1>, <3 x i1>* %a

llvm/test/Transforms/SROA/vector-promotion.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -sroa -S | FileCheck %s
+; RUN: opt < %s -passes=sroa -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
 %S1 = type { i64, [42 x float] }
 
 define i32 @test1(<4 x i32> %x, <4 x i32> %y) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_SROA_0_8_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[X:%.*]], i32 2