COWArrayOpt: handle load_borrow

Author: eeckstein

lib/SILOptimizer/LoopTransforms/ArrayOpt.h

@@ -81,10 +81,10 @@ class StructUseCollector {
 
   UserList AggregateAddressUsers;
   UserList StructAddressUsers;
-  SmallVector<LoadInst*, 16> StructLoads;
+  SmallVector<SingleValueInstruction *, 16> StructLoads;
   UserList StructValueUsers;
   UserOperList ElementAddressUsers;
-  SmallVector<std::pair<LoadInst*, Operand*>, 16> ElementLoads;
+  SmallVector<std::pair<SingleValueInstruction *, Operand*>, 16> ElementLoads;
   UserOperList ElementValueUsers;
   VisitedSet Visited;
 
@@ -126,7 +126,7 @@ class StructUseCollector {
       return false;
     for (SILInstruction *user : StructAddressUsers) {
       // ignore load users
-      if (isa<LoadInst>(user))
+      if (isa<LoadInst>(user) || isa<LoadBorrowInst>(user))
         continue;
       if (user != use1 && user != use2)
         return false;
@@ -162,8 +162,8 @@ class StructUseCollector {
       if (StructVal) {
         // Found a use of an element.
         assert(AccessPathSuffix.empty() && "should have accessed struct");
-        if (auto *LoadI = dyn_cast<LoadInst>(UseInst)) {
-          ElementLoads.push_back(std::make_pair(LoadI, StructVal));
+        if (isa<LoadInst>(UseInst) || isa<LoadBorrowInst>(UseInst)) {
+          ElementLoads.push_back(std::make_pair(cast<SingleValueInstruction>(UseInst), StructVal));
           continue;
         }
 
@@ -185,9 +185,9 @@ class StructUseCollector {
 
       if (AccessPathSuffix.empty()) {
         // Found a use of the struct at the given access path.
-        if (auto *LoadI = dyn_cast<LoadInst>(UseInst)) {
-          StructLoads.push_back(LoadI);
-          StructAddressUsers.push_back(LoadI);
+        if (isa<LoadInst>(UseInst) || isa<LoadBorrowInst>(UseInst)) {
+          StructLoads.push_back(cast<SingleValueInstruction>(UseInst));
+          StructAddressUsers.push_back(UseInst);
           continue;
         }
 

lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp

@@ -55,10 +55,10 @@ bool areArraysEqual(RCIdentityFunctionInfo *RCIA, SILValue A, SILValue B,
     return true;
   // We have stripped off struct_extracts. Remove the load to look at the
   // address we are loading from.
-  if (auto *ALoad = dyn_cast<LoadInst>(A))
-    A = ALoad->getOperand();
-  if (auto *BLoad = dyn_cast<LoadInst>(B))
-    B = BLoad->getOperand();
+  if (isa<LoadInst>(A) || isa<LoadBorrowInst>(A))
+    A = cast<SingleValueInstruction>(A)->getOperand(0);
+  if (isa<LoadInst>(B) || isa<LoadBorrowInst>(B))
+    B = cast<SingleValueInstruction>(B)->getOperand(0);
   // Strip off struct_extract_refs until we hit array address.
   if (ArrayAddress) {
     StructElementAddrInst *SEAI = nullptr;
@@ -463,6 +463,10 @@ bool COWArrayOpt::checkSafeArrayAddressUses(UserList &AddressUsers) {
       return false;
     }
 
+    if (isa<LoadBorrowInst>(UseInst)) {
+      continue;
+    }
+
     if (isa<DeallocStackInst>(UseInst)) {
       // Handle destruction of a local array.
       continue;
@@ -569,6 +573,9 @@ bool COWArrayOpt::checkSafeArrayValueUses(UserList &ArrayValueUsers) {
     if (isa<MarkDependenceInst>(UseInst))
       continue;
 
+    if (isa<EndBorrowInst>(UseInst))
+      continue;
+
     if (UseInst->isDebugInstruction())
       continue;
 

test/SILOptimizer/cowarray_opt_ossa.sil

@@ -164,6 +164,42 @@ bb2:
   return %r : $()
 }
 
+// CHECK-LABEL: sil [ossa] @hoist_ignoring_paired_retain_release_and_hoist2_load_borrow :
+// CHECK: bb0([[ARRAY:%[0-9]+]]
+// CHECK:   [[MM:%[0-9]+]] = function_ref @array_make_mutable
+// CHECK:   apply [[MM]]([[ARRAY]]
+// CHECK:   [[EM:%[0-9]+]] = function_ref @array_end_mutation
+// CHECK:   apply [[EM]]([[ARRAY]]
+// CHECK: bb1:
+// CHECK:   load_borrow
+// CHECK:   end_borrow
+// CHECK:   apply [[MM]]([[ARRAY]]
+// CHECK:   apply [[EM]]([[ARRAY]]
+// CHECK:  cond_br {{.*}}, bb2
+// CHECK: } // end sil function 'hoist_ignoring_paired_retain_release_and_hoist2_load_borrow'
+sil [ossa] @hoist_ignoring_paired_retain_release_and_hoist2_load_borrow : $@convention(thin) (@inout MyArray<MyStruct>, @inout Builtin.Int1) -> () {
+bb0(%0 : $*MyArray<MyStruct>, %1 : $*Builtin.Int1):
+  %2 = load [copy] %0 : $*MyArray<MyStruct>
+  br bb1
+
+bb1:
+  %b = load_borrow %0
+  %3 = load [trivial] %1 : $*Builtin.Int1
+  end_borrow %b
+  %5 = function_ref @array_make_mutable : $@convention(method) (@inout MyArray<MyStruct>) -> ()
+  %6 = apply %5(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
+  %7 = function_ref @array_end_mutation : $@convention(method) (@inout MyArray<MyStruct>) -> ()
+  %8 = apply %7(%0) : $@convention(method) (@inout MyArray<MyStruct>) -> ()
+  cond_br %3, bb1a, bb2
+
+bb1a:
+  br bb1
+
+bb2:
+  destroy_value %2 : $MyArray<MyStruct>
+  %r = tuple()
+  return %r : $()
+}
 // CHECK-LABEL: sil [ossa] @hoist_blocked_by_unpaired_retain_release_1 :
 // CHECK: bb0(
 // CHECK-NOT: apply