Remove address phis from SIL tests

Author: meg-gupta

test/SILOptimizer/access_enforcement_opts.sil

@@ -1550,46 +1550,6 @@ bb0:
   return %10 : $()
 }
 
-// public func testPhiArgs() {
-// Check that we can merge scopes with Phi args - avoiding a crash we've seen in the past
-//
-// CHECK-LABEL: sil @testPhiArgs : $@convention(thin) () -> () {
-// CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
-// CHECK: cond_br {{.*}}, bb1, bb2
-// CHECK: bb1
-// CHECK: br bb3([[GLOBAL]] : $*X)
-// CHECK: bb2
-// CHECK: br bb3([[GLOBAL]] : $*X)
-// CHECK: bb3([[GLOBALPHI:%.*]] : $*X):
-// CHECK: [[BEGIN:%.*]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBALPHI]] : $*X
-// CHECK-NEXT: load
-// CHECK-NEXT: load
-// CHECK-NEXT: end_access [[BEGIN]] : $*X
-// CHECK-NOT: begin_access
-// CHECK-LABEL: } // end sil function 'testPhiArgs'
-sil @testPhiArgs : $@convention(thin) () -> () {
-bb0:
-  %0 = global_addr @globalX: $*X
-  %cond = integer_literal $Builtin.Int1, 1
-  cond_br %cond, bb1, bb2
-  
-bb1:
-  br bb3(%0 : $*X)
-  
-bb2:
-  br bb3(%0 : $*X)
-  
-bb3(%1 : $*X):
-  %2 = begin_access [read] [dynamic] %1 : $*X
-  %3 = load %2 : $*X
-  end_access %2 : $*X
-  %4 = begin_access [read] [dynamic] %0 : $*X
-  %5 = load %4 : $*X
-  end_access %4 : $*X
-  %10 = tuple ()
-  return %10 : $()
-}
-
 // --- rdar://48239213: Fatal access conflict detected.
 //
 // The read/modify pair of accesses in testReadModifyConflictPair

test/SILOptimizer/access_storage_analysis.sil

@@ -651,41 +651,6 @@ bb3(%result : $Int):
   return %result : $Int
 }
 
-// Make sure identifyFormalAccess returns a valid storage object for an address-phi
-// that feeds ref_element_addr instructions. The ref_element_addr's need to have the
-// same base object and same field id.
-// <rdar://problem/46114512> SIL verification failed: Unknown formal access pattern: storage
-class BaseClass {
-  var f: Float = 0.0
-}
-
-class SubClass : BaseClass {}
-
-// CHECK-LABEL: @testElementAddressPhiAccess
-// CHECK: [read] [no_nested_conflict] Class %{{.*}} = argument of bb0 : $SubClass
-// CHECK: Field: @_hasInitialValue var f: Float
-sil @testElementAddressPhiAccess : $@convention(thin) (@guaranteed SubClass) -> () {
-bb0(%0 : $SubClass):
-  %base = upcast %0 : $SubClass to $BaseClass
-  cond_br undef, bb1, bb2
-
-bb1:
-  %ref1 = ref_element_addr %base : $BaseClass, #BaseClass.f
-  br bb3(%ref1 : $*Float)
-
-bb2:
-  %ref2 = ref_element_addr %base : $BaseClass, #BaseClass.f
-  br bb3(%ref2 : $*Float)
-
-bb3(%phi : $*Float):
-  %access = begin_access [read] [dynamic] [no_nested_conflict] %phi : $*Float
-  %addr = struct_element_addr %access : $*Float, #Float._value
-  %val = load %addr : $*Builtin.FPIEEE32
-  end_access %access : $*Float
-  %v = tuple ()
-  return %v : $()
-}
-
 // Test an inlined global variable addressor after simplify-cfg has
 // cloned the call to the addressor.
 // <rdar://problem/47555992> SIL verification failed: Unknown formal access pattern

test/SILOptimizer/basic-aa.sil

@@ -93,21 +93,6 @@ bb0(%0 : $*Builtin.NativeObject, %1 : $*Builtin.NativeObject):
   return %2 : $()
 }
 
-// Address Arguments may alias if they are arguments to a BB besides the first.
-//
-// FIXME: Once we support looking through PHIs, we will allow for must alias here.
-//
-// CHECK-LABEL: @address_args_may_alias_in_non_first_bb
-// CHECK-NOT: NoAlias
-sil @address_args_may_alias_in_non_first_bb : $@convention(thin) (@inout Builtin.NativeObject) -> () {
-bb0(%0 : $*Builtin.NativeObject):
-  br bb1(%0 : $*Builtin.NativeObject, %0 : $*Builtin.NativeObject)
-
-bb1(%1 : $*Builtin.NativeObject, %2 : $*Builtin.NativeObject):
-  %3 = tuple()
-  return %3 : $()
-}
-
 // Assume that inout arguments alias to preserve memory safety.
 //
 // CHECK-LABEL: @inout_args_may_not_alias

test/SILOptimizer/cowarray_opt.sil

@@ -578,7 +578,7 @@ struct MyInt {
 // CHECK:   [[EM:%[0-9]+]] = function_ref @array_end_mutation
 // CHECK:   apply [[EM]]([[ARRAY]]
 // CHECK: bb1:
-// CHECK: bb2({{.*}}):
+// CHECK: bb2:
 // CHECK:   apply [[MM]]([[ARRAY]]
 // CHECK:   apply [[EM]]([[ARRAY]]
 // CHECK: } // end sil function 'hoist_projections'
@@ -587,10 +587,10 @@ bb0(%0 : $*ContainerContainer, %1 : $*Builtin.Int1):
   br bb1
 
 bb1:
-  %2 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
-  br bb3(%2 : $*Container)
+  br bb3
 
-bb3(%3: $*Container):
+bb3:
+  %3 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
   %4 = struct_element_addr %3 : $*Container, #Container.array
   %5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
   %6 = apply %5(%4) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
@@ -613,7 +613,7 @@ bb2:
 // CHECK:   [[EM:%[0-9]+]] = function_ref @array_end_mutation
 // CHECK:   apply [[EM]]([[ARRAY]]
 // CHECK: bb1:
-// CHECK: bb2({{.*}}):
+// CHECK: bb2:
 // CHECK:   apply [[MM]]([[ARRAY]]
 // CHECK:   apply [[EM]]([[ARRAY]]
 // CHECK: } // end sil function 'hoist_non_unary_projections'
@@ -623,10 +623,10 @@ bb0(%0 : $*ContainerContainer, %1 : $*Builtin.Int1):
   br bb1
 
 bb1:
-  %2 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
-  br bb2(%2 : $*Container)
+  br bb2
 
-bb2(%3: $*Container):
+bb2:
+  %3 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
   %3i = index_addr %3 : $*Container, %i : $Builtin.Int32
   %4 = struct_element_addr %3i : $*Container, #Container.array
   %5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
@@ -649,7 +649,7 @@ bb3:
 // CHECK:   [[EM:%[0-9]+]] = function_ref @array_end_mutation
 // CHECK:   apply [[EM]]([[ARRAY]]
 // CHECK: bb1:
-// CHECK: bb2({{.*}}):
+// CHECK: bb2:
 // CHECK:   apply [[MM]]([[ARRAY]]
 // CHECK:   apply [[EM]]
 // CHECK: } // end sil function 'hoist_projections2'
@@ -658,11 +658,11 @@ bb0(%0 : $*ContainerContainer, %1 : $*Builtin.Int1):
   br bb1
 
 bb1:
-  %2 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
-  %3 = struct_element_addr %2 : $*Container, #Container.array
-  br bb3(%3 : $*MyArray<MyStruct>)
+  br bb3
 
-bb3(%4 : $*MyArray<MyStruct>):
+bb3:
+  %2 = struct_element_addr %0 : $*ContainerContainer, #ContainerContainer.container
+  %4 = struct_element_addr %2 : $*Container, #Container.array
   %5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
   %6 = apply %5(%4) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
   %7 = function_ref @array_end_mutation : $@convention(method) (@inout MyArray<MyStruct>) -> ()

test/SILOptimizer/escape_analysis.sil

@@ -1740,53 +1740,6 @@ bb10(%arg3 : $C):
   return %66 : $()
 }
 
-// Test canEscapeToUsePoint with defer edges between non-reference-type nodes.
-//
-// Unfortunately, the only way I can think of to create defer edges
-// between non-reference nodes is with address-type block arguments.
-// This will be banned soon, so the test will need to be disabled, but
-// this is still an important corner case in the EscapeAnalysis
-// logic. To keep the test working, and be able to test many more
-// important corner cases, we should introduce testing modes that
-// introduce spurious but predictable defer edges and node merges.
-//
-// Here, canEscapeTo is called on %bbarg (%5) whose node is not
-// marked escaping. But it does have a defer edge to the local address
-// (%0) which does cause the address to escape via the call site.
-//
-// CHECK-LABEL: CG of testDeferPointer
-// CHECK-NEXT:   Val %0 Esc: , Succ: (%0.1)
-// CHECK-NEXT:   Con [ref] %0.1 Esc: G, Succ:
-// CHECK-NEXT:   Val %1 Esc: , Succ: (%0.1)
-// CHECK-NEXT:   Val %5 Esc: , Succ: %0, %1
-// CHECK-LABEL: End
-// CHECK: MayEscape: %5 = argument of bb3 : $*Builtin.Int32
-// CHECK-NEXT:  to   %{{.*}} = apply %{{.*}}(%0) : $@convention(thin) (@inout Builtin.Int32) -> ()
-sil @takeAdr : $@convention(thin) (@inout Builtin.Int32) -> ()
-
-sil hidden @testDeferPointer : $@convention(thin) () -> () {
-bb0:
-  %iadr1 = alloc_stack $Builtin.Int32
-  %iadr2 = alloc_stack $Builtin.Int32
-  cond_br undef, bb1, bb2
-
-bb1:
-  br bb3(%iadr1: $*Builtin.Int32)
-
-bb2:
-  br bb3(%iadr2: $*Builtin.Int32)
-
-bb3(%bbarg: $*Builtin.Int32):
-  %val = integer_literal $Builtin.Int32, 1
-  store %val to %bbarg : $*Builtin.Int32
-  %ftake = function_ref @takeAdr : $@convention(thin) (@inout Builtin.Int32) -> ()
-  %call = apply %ftake(%iadr1) : $@convention(thin) (@inout Builtin.Int32) -> ()
-  dealloc_stack %iadr2 : $*Builtin.Int32
-  dealloc_stack %iadr1 : $*Builtin.Int32
-  %z = tuple ()
-  return %z : $()
-}
-
 // Test interior node (self) cycles.
 
 class IntWrapper {

test/SILOptimizer/licm.sil

@@ -312,14 +312,14 @@ bb0:
   %5 = function_ref @use_value : $@convention(thin) (Builtin.Int32) -> ()
   %unknown_value_fn = function_ref @get_unknown_value2 : $@convention(thin) () -> Builtin.Int32
   store %1 to %0 : $*Builtin.Int32
-  br bb1(%0 : $*Builtin.Int32)
+  br bb1
 
-bb1(%phi1 : $*Builtin.Int32):
+bb1:
   br bb2
 
 bb2:
   apply %3(%0) : $@convention(thin) (@inout Builtin.Int32) -> ()
-  %4 = load %phi1 : $*Builtin.Int32
+  %4 = load %0 : $*Builtin.Int32
   %6 = apply %unknown_value_fn() : $@convention(thin) () -> Builtin.Int32
   %33 = builtin "cmp_eq_Int32"(%4 : $Builtin.Int32, %6 : $Builtin.Int32) : $Builtin.Int1
   cond_br %33, bb2, bb3

test/SILOptimizer/looprotate.sil

@@ -55,9 +55,9 @@ bb0(%0 : $Int32, %25: $Bar):
   %2 = integer_literal $Builtin.Int32, 0
   %30 = alloc_box $<τ_0_0> { var τ_0_0 } <Bool>
   %30a = project_box %30 : $<τ_0_0> { var τ_0_0 } <Bool>, 0
-  br bb1(%1 : $Builtin.Int32, %2 : $Builtin.Int32, %25: $Bar, %30 : $<τ_0_0> { var τ_0_0 } <Bool>, %30a : $*Bool)
+  br bb1(%1 : $Builtin.Int32, %2 : $Builtin.Int32, %25: $Bar, %30 : $<τ_0_0> { var τ_0_0 } <Bool>)
 
-bb1(%4 : $Builtin.Int32, %5 : $Builtin.Int32, %26: $Bar, %31 : $<τ_0_0> { var τ_0_0 } <Bool>, %32 : $*Bool):
+bb1(%4 : $Builtin.Int32, %5 : $Builtin.Int32, %26: $Bar, %31 : $<τ_0_0> { var τ_0_0 } <Bool>):
   %24 = class_method %26 : $Bar, #Bar.foo : (Bar) -> () -> (), $@convention(method) (@guaranteed Bar) -> () // user: %6
   %27 = apply %24(%25) : $@convention(method) (@guaranteed Bar) -> ()
   %6 = struct $Int32 (%5 : $Builtin.Int32)
@@ -75,7 +75,7 @@ bb2:
   %19 = integer_literal $Builtin.Int1, -1
   %20 = builtin "sadd_with_overflow_Word"(%4 : $Builtin.Int32, %17 : $Builtin.Int32, %19 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %21 = tuple_extract %20 : $(Builtin.Int32, Builtin.Int1), 0
-  br bb1(%21 : $Builtin.Int32, %14 : $Builtin.Int32, %26: $Bar, %31 : $<τ_0_0> { var τ_0_0 } <Bool>, %32 : $*Bool)
+  br bb1(%21 : $Builtin.Int32, %14 : $Builtin.Int32, %26: $Bar, %31 : $<τ_0_0> { var τ_0_0 } <Bool>)
 
 bb3:
   %23 = struct $Int32 (%4 : $Builtin.Int32)
@@ -105,9 +105,9 @@ bb0(%0 : $Int32, %25: $Bar):
   %2 = integer_literal $Builtin.Int32, 0
   %30 = alloc_box $<τ_0_0> { var τ_0_0 } <Bool>
   %30a = project_box %30 : $<τ_0_0> { var τ_0_0 } <Bool>, 0
-  br bb1(%1 : $Builtin.Int32, %2 : $Builtin.Int32, %25: $Bar, %30 : $<τ_0_0> { var τ_0_0 } <Bool>, %30a : $*Bool)
+  br bb1(%1 : $Builtin.Int32, %2 : $Builtin.Int32, %25: $Bar, %30 : $<τ_0_0> { var τ_0_0 } <Bool>)
 
-bb1(%4 : $Builtin.Int32, %5 : $Builtin.Int32, %26: $Bar, %31 : $<τ_0_0> { var τ_0_0 } <Bool>, %32 : $*Bool):
+bb1(%4 : $Builtin.Int32, %5 : $Builtin.Int32, %26: $Bar, %31 : $<τ_0_0> { var τ_0_0 } <Bool>):
   %24 = class_method %26 : $Bar, #Bar.foo : (Bar) -> () -> (), $@convention(method) (@guaranteed Bar) -> () // user: %6
   %27 = apply %24(%25) : $@convention(method) (@guaranteed Bar) -> ()
   %28 = apply %24(%25) : $@convention(method) (@guaranteed Bar) -> ()
@@ -149,7 +149,7 @@ bb2:
   %19 = integer_literal $Builtin.Int1, -1
   %20 = builtin "sadd_with_overflow_Word"(%4 : $Builtin.Int32, %17 : $Builtin.Int32, %19 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %21 = tuple_extract %20 : $(Builtin.Int32, Builtin.Int1), 0
-  br bb1(%21 : $Builtin.Int32, %14 : $Builtin.Int32, %26: $Bar, %31 : $<τ_0_0> { var τ_0_0 } <Bool>, %32 : $*Bool)
+  br bb1(%21 : $Builtin.Int32, %14 : $Builtin.Int32, %26: $Bar, %31 : $<τ_0_0> { var τ_0_0 } <Bool>)
 
 bb3:
   %23 = struct $Int32 (%4 : $Builtin.Int32)
@@ -205,9 +205,9 @@ bb0(%0 : $Int32, %25: $*P):
   %30 = alloc_box $<τ_0_0> { var τ_0_0 } <Bool>
   %30a = project_box %30 : $<τ_0_0> { var τ_0_0 } <Bool>, 0
   %40 = open_existential_addr immutable_access %25 : $*P to $*@opened("C22498FA-CABF-11E5-B9A9-685B35C48C83", P) Self
-  br bb1(%1 : $Builtin.Int32, %2 : $Builtin.Int32, %25: $*P, %30 : $<τ_0_0> { var τ_0_0 } <Bool>, %30a : $*Bool)
+  br bb1(%1 : $Builtin.Int32, %2 : $Builtin.Int32, %30 : $<τ_0_0> { var τ_0_0 } <Bool>)
 
-bb1(%4 : $Builtin.Int32, %5 : $Builtin.Int32, %26: $*P, %31 : $<τ_0_0> { var τ_0_0 } <Bool>, %32 : $*Bool):
+bb1(%4 : $Builtin.Int32, %5 : $Builtin.Int32, %31 : $<τ_0_0> { var τ_0_0 } <Bool>):
   %111 = witness_method $@opened("C22498FA-CABF-11E5-B9A9-685B35C48C83", P) Self, #P.boo, %40 : $*@opened("C22498FA-CABF-11E5-B9A9-685B35C48C83", P) Self : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int64
   %122 = apply %111<@opened("C22498FA-CABF-11E5-B9A9-685B35C48C83", P) Self>(%40) : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int64
   %6 = struct $Int32 (%5 : $Builtin.Int32)
@@ -225,7 +225,7 @@ bb2:
   %19 = integer_literal $Builtin.Int1, -1
   %20 = builtin "sadd_with_overflow_Word"(%4 : $Builtin.Int32, %17 : $Builtin.Int32, %19 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %21 = tuple_extract %20 : $(Builtin.Int32, Builtin.Int1), 0
-  br bb1(%21 : $Builtin.Int32, %14 : $Builtin.Int32, %26: $*P, %31 : $<τ_0_0> { var τ_0_0 } <Bool>, %32 : $*Bool)
+  br bb1(%21 : $Builtin.Int32, %14 : $Builtin.Int32, %31 : $<τ_0_0> { var τ_0_0 } <Bool>)
 
 bb3:
   %23 = struct $Int32 (%4 : $Builtin.Int32)

test/SILOptimizer/looprotate_ossa.sil

@@ -476,28 +476,24 @@ bb2:
 //
 // CHECK-LABEL: sil [ossa] @addressPhiFixUp : $@convention(thin) (Builtin.RawPointer) -> Builtin.RawPointer {
 // CHECK: bb1:
-// CHECK:   [[NEXT:%.*]] = address_to_pointer {{%.*}} : $*UInt8 to $Builtin.RawPointer
 // CHECK:   cond_br {{%.*}}, bb3, bb2
 //
 // CHECK: bb2:
-// CHECK-NEXT: br bb7(%0 : $Builtin.RawPointer)
+// CHECK-NEXT: br bb7
 //
 // CHECK: bb3:
-// CHECK-NEXT: br bb4([[NEXT]] : $Builtin.RawPointer)
+// CHECK-NEXT: br bb4
 //
 // CHECK: bb4([[ARG:%.*]] :
 // CHECK:  [[CAST_BACK:%.*]] = pointer_to_address [[ARG]] : $Builtin.RawPointer to [strict] $*UInt8
 // CHECK:  [[GEP:%.*]] = index_addr [[CAST_BACK]] :
-// CHECK:  [[CAST_ROUND_TRIP_START:%.*]] = address_to_pointer [[GEP]]
-// CHECK:  [[CAST_ROUND_TRIP_END:%.*]] = pointer_to_address [[CAST_ROUND_TRIP_START]] : $Builtin.RawPointer to [strict] $*UInt8
-// CHECK:  [[BACK_TO_RAWPOINTER:%.*]] = address_to_pointer [[CAST_ROUND_TRIP_END]]
 // CHECK:  cond_br {{%.*}}, bb6, bb5
 //
 // CHECK: bb5:
-// CHECK-NEXT: br bb7([[CAST_ROUND_TRIP_START]] :
+// CHECK-NEXT: br bb7
 //
 // CHECK: bb6:
-// CHECK-NEXT: br bb4([[BACK_TO_RAWPOINTER]] :
+// CHECK-NEXT: br bb4
 //
 // CHECK: bb7([[RESULT:%.*]] :
 // CHECK-NEXT: return [[RESULT]]

test/SILOptimizer/redundant_load_elim.sil

@@ -1201,29 +1201,6 @@ bb0(%0 : $Builtin.RawPointer):
 
 sil @overwrite_int : $@convention(thin) (@inout Int, Int) -> ()
 
-// CHECK-LABEL: sil @test_address_block_args
-// CHECK: bb2({{.*}}):
-// CHECK: apply
-// CHECK: [[L:%.*]] = load
-// CHECK: return [[L]]
-sil @test_address_block_args : $@convention(thin) (Int) -> Int {
-bb0(%0 : $Int):
-  %4 = alloc_stack $Int
-  store %0 to %4 : $*Int
-  cond_br undef, bb1(%4 : $*Int), bb2(%4 : $*Int)
-
-bb1(%a1 : $*Int):
-  br bb2(%a1 : $*Int)
-
-bb2(%a : $*Int):
-  %l1 = load %a : $*Int
-  %60 = function_ref @overwrite_int : $@convention(thin) (@inout Int, Int) -> ()
-  %61 = apply %60(%4, %l1) : $@convention(thin) (@inout Int, Int) -> ()
-  %r = load %a : $*Int
-  dealloc_stack %4 : $*Int
-  return %r : $Int
-} 
-
 // Make sure that the store is forwarded to the load, ie. the load is
 // eliminated. That's correct as the stored value can't be changed by the
 // callee as it's passed with @in_guaranteed.