[sil-combine] Update LoadInst opts for OSSA and expand opts to also support LoadBorrow.

NOTE: The stdlib count/capacity propagation code is tested in an end<->end
fashion in a separate Swift test. Once I flip the switch, that test will run.
The code is pretty simple, so I feel relatively confident with it.

Author: gottesmm

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -220,8 +220,12 @@ class SILCombiner :
   SILInstruction *visitStrongRetainInst(StrongRetainInst *SRI);
   SILInstruction *visitRefToRawPointerInst(RefToRawPointerInst *RRPI);
   SILInstruction *visitUpcastInst(UpcastInst *UCI);
-  SILInstruction *optimizeLoadFromStringLiteral(LoadInst *LI);
+
+  // NOTE: The load optimized in this method is a load [trivial].
+  SILInstruction *optimizeLoadFromStringLiteral(LoadInst *li);
+
   SILInstruction *visitLoadInst(LoadInst *LI);
+  SILInstruction *visitLoadBorrowInst(LoadBorrowInst *LI);
   SILInstruction *visitIndexAddrInst(IndexAddrInst *IA);
   bool optimizeStackAllocatedEnum(AllocStackInst *AS);
   SILInstruction *visitAllocStackInst(AllocStackInst *AS);

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -759,12 +759,13 @@ SILInstruction *SILCombiner::optimizeLoadFromStringLiteral(LoadInst *LI) {
 
 /// Returns true if \p LI loads a zero integer from the empty Array, Dictionary
 /// or Set singleton.
-static bool isZeroLoadFromEmptyCollection(LoadInst *LI) {
+static bool isZeroLoadFromEmptyCollection(SingleValueInstruction *LI) {
+  assert(isa<LoadInst>(LI) || isa<LoadBorrowInst>(LI));
   auto intTy = LI->getType().getAs<BuiltinIntegerType>();
   if (!intTy)
     return false;
-  
-  SILValue addr = LI->getOperand();
+
+  SILValue addr = LI->getOperand(0);
 
   // Find the root object of the load-address.
   for (;;) {
@@ -805,6 +806,8 @@ static bool isZeroLoadFromEmptyCollection(LoadInst *LI) {
       case ValueKind::UpcastInst:
       case ValueKind::RawPointerToRefInst:
       case ValueKind::AddressToPointerInst:
+      case ValueKind::BeginBorrowInst:
+      case ValueKind::CopyValueInst:
       case ValueKind::EndCOWMutationInst:
         addr = cast<SingleValueInstruction>(addr)->getOperand(0);
         break;
@@ -839,15 +842,56 @@ static SingleValueInstruction *getValueFromStaticLet(SILValue v) {
   return nullptr;
 }
 
-SILInstruction *SILCombiner::visitLoadInst(LoadInst *LI) {
-  if (LI->getFunction()->hasOwnership())
+SILInstruction *SILCombiner::visitLoadBorrowInst(LoadBorrowInst *lbi) {
+  // (load (upcast-ptr %x)) -> (upcast-ref (load %x))
+  Builder.setCurrentDebugScope(lbi->getDebugScope());
+  if (auto *ui = dyn_cast<UpcastInst>(lbi->getOperand())) {
+    // We want to RAUW the current load_borrow with the upcast. To do that
+    // safely, we need to insert new end_borrow on the new load_borrow, erase
+    // the end_borrow and then RAUW.
+    SmallVector<EndBorrowInst *, 32> endBorrowInst;
+    for (auto *ebi : lbi->getEndBorrows())
+      endBorrowInst.push_back(ebi);
+    auto newLBI = Builder.createLoadBorrow(lbi->getLoc(), ui->getOperand());
+    for (auto *ebi : endBorrowInst) {
+      SILBuilderWithScope builder(ebi, Builder);
+      builder.emitEndBorrowOperation(ebi->getLoc(), newLBI);
+      eraseInstFromFunction(*ebi);
+    }
+    auto *uci = Builder.createUpcast(lbi->getLoc(), newLBI, lbi->getType());
+    replaceInstUsesWith(*lbi, uci);
+    return eraseInstFromFunction(*lbi);
+  }
+
+  // Constant-propagate the 0 value when loading "count" or "capacity" from the
+  // empty Array, Set or Dictionary storage.
+  // On high-level SIL this optimization is also done by the
+  // ArrayCountPropagation pass, but only for Array. And even for Array it's
+  // sometimes needed to propagate the empty-array count when high-level
+  // semantics function are already inlined.
+  // Note that for non-empty arrays/sets/dictionaries, the count can be
+  // propagated by redundant load elimination.
+  if (isZeroLoadFromEmptyCollection(lbi))
+    return Builder.createIntegerLiteral(lbi->getLoc(), lbi->getType(), 0);
+
+  // If we have a load_borrow that only has non_debug end_borrow uses, delete
+  // it.
+  if (llvm::all_of(getNonDebugUses(lbi), [](Operand *use) {
+        return isa<EndBorrowInst>(use->getUser());
+      })) {
+    eraseInstIncludingUsers(lbi);
     return nullptr;
+  }
+
+  return nullptr;
+}
 
+SILInstruction *SILCombiner::visitLoadInst(LoadInst *LI) {
   // (load (upcast-ptr %x)) -> (upcast-ref (load %x))
   Builder.setCurrentDebugScope(LI->getDebugScope());
   if (auto *UI = dyn_cast<UpcastInst>(LI->getOperand())) {
-    auto NewLI = Builder.createLoad(LI->getLoc(), UI->getOperand(),
-                                    LoadOwnershipQualifier::Unqualified);
+    auto NewLI = Builder.emitLoadValueOperation(LI->getLoc(), UI->getOperand(),
+                                                LI->getOwnershipQualifier());
     return Builder.createUpcast(LI->getLoc(), NewLI, LI->getType());
   }
 
@@ -874,6 +918,17 @@ SILInstruction *SILCombiner::visitLoadInst(LoadInst *LI) {
     return cloner.clone(initVal);
   }
 
+  // If we have a load [copy] whose only non-debug users are destroy_value, just
+  // eliminate it.
+  if (LI->getOwnershipQualifier() == LoadOwnershipQualifier::Copy) {
+    if (llvm::all_of(getNonDebugUses(LI), [](Operand *use) {
+          return isa<DestroyValueInst>(use->getUser());
+        })) {
+      eraseInstIncludingUsers(LI);
+      return nullptr;
+    }
+  }
+
   return nullptr;
 }
 

test/SILOptimizer/sil_combine_misc_opts.sil

@@ -6,8 +6,18 @@ sil_stage canonical
 
 import Builtin
 
+//////////////////
+// Declarations //
+//////////////////
+
 class Klass {}
 
+sil @nativeobject_guaranteed_use : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+
+///////////
+// Tests //
+///////////
+
 // We test both the ossa and non-ossa variants.
 //
 // CHECK-LABEL: sil [ossa] @fix_lifetime_promotion_ossa : $@convention(thin) (@owned Klass) -> () {
@@ -136,3 +146,39 @@ bb0:
   %3 = tuple ()
   return %3 : $()
 }
+
+// We should have a single load [copy] here.
+//
+// CHECK-LABEL: sil [ossa] @remove_loadcopy_with_only_destroy_users : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> () {
+// CHECK: load [copy]
+// CHECK-NOT: load [copy]
+// CHECK: } // end sil function 'remove_loadcopy_with_only_destroy_users'
+sil [ossa] @remove_loadcopy_with_only_destroy_users : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> () {
+bb0(%0 : $*Builtin.NativeObject):
+  %1 = load [copy] %0 : $*Builtin.NativeObject
+  destroy_value %1 : $Builtin.NativeObject
+  %2 = load [copy] %0 : $*Builtin.NativeObject
+  %f = function_ref @nativeobject_guaranteed_use : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  apply %f(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  destroy_value %2 : $Builtin.NativeObject
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// We should have a single load_borrow here.
+//
+// CHECK-LABEL: sil [ossa] @remove_loadborrow_with_only_destroy_users : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> () {
+// CHECK: load_borrow
+// CHECK-NOT: load_borrow
+// CHECK: } // end sil function 'remove_loadborrow_with_only_destroy_users'
+sil [ossa] @remove_loadborrow_with_only_destroy_users : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> () {
+bb0(%0 : $*Builtin.NativeObject):
+  %1 = load_borrow %0 : $*Builtin.NativeObject
+  end_borrow %1 : $Builtin.NativeObject
+  %2 = load_borrow %0 : $*Builtin.NativeObject
+  %f = function_ref @nativeobject_guaranteed_use : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  apply %f(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+  end_borrow %2 : $Builtin.NativeObject
+  %9999 = tuple()
+  return %9999 : $()
+}