Fix store_borrow generation in SILGen

This change ensures all store_borrows are ended with an end_borrow, and uses of the store_borrow
destination are all in the enclosing store_borrow scope and via the store_borrow return address.

Fix tests to reflect new store_borrow pattern

Author: meg-gupta

lib/SILGen/ManagedValue.cpp

@@ -200,7 +200,6 @@ ManagedValue ManagedValue::materialize(SILGenFunction &SGF,
   auto temporary = SGF.emitTemporaryAllocation(loc, getType());
   bool hadCleanup = hasCleanup();
 
-  // The temporary memory is +0 if the value was.
   if (hadCleanup) {
     SGF.B.emitStoreValueOperation(loc, forward(SGF), temporary,
                                   StoreOwnershipQualifier::Init);
@@ -218,9 +217,37 @@ ManagedValue ManagedValue::materialize(SILGenFunction &SGF,
     return ManagedValue::forOwnedAddressRValue(
         temporary, SGF.enterDestroyCleanup(temporary));
   }
+  // The temporary memory is +0 if the value was.
   auto object = SGF.emitManagedBeginBorrow(loc, getValue());
-  SGF.emitManagedStoreBorrow(loc, object.getValue(), temporary);
-  return ManagedValue::forBorrowedAddressRValue(temporary);
+  auto borrowedAddr =
+      SGF.emitManagedStoreBorrow(loc, object.getValue(), temporary);
+  return ManagedValue::forBorrowedAddressRValue(borrowedAddr.getValue());
+}
+
+ManagedValue ManagedValue::formallyMaterialize(SILGenFunction &SGF,
+                                               SILLocation loc) const {
+  auto temporary = SGF.emitTemporaryAllocation(loc, getType());
+  bool hadCleanup = hasCleanup();
+  auto &lowering = SGF.getTypeLowering(getType());
+
+  if (hadCleanup) {
+    SGF.B.emitStoreValueOperation(loc, forward(SGF), temporary,
+                                  StoreOwnershipQualifier::Init);
+
+    return ManagedValue::forOwnedAddressRValue(
+        temporary, SGF.enterDestroyCleanup(temporary));
+  }
+  if (lowering.isAddressOnly()) {
+    assert(!SGF.silConv.useLoweredAddresses());
+    auto copy = SGF.B.createCopyValue(loc, getValue());
+    SGF.B.emitStoreValueOperation(loc, copy, temporary,
+                                  StoreOwnershipQualifier::Init);
+    return ManagedValue::forOwnedAddressRValue(
+        temporary, SGF.enterDestroyCleanup(temporary));
+  }
+  auto object = SGF.emitFormalEvaluationManagedBeginBorrow(loc, getValue());
+  return SGF.emitFormalEvaluationManagedStoreBorrow(loc, object.getValue(),
+                                                    temporary);
 }
 
 void ManagedValue::print(raw_ostream &os) const {

lib/SILGen/ManagedValue.h

@@ -320,6 +320,8 @@ class ManagedValue {
   /// exact same level of cleanup it had before.
   ManagedValue materialize(SILGenFunction &SGF, SILLocation loc) const;
 
+  ManagedValue formallyMaterialize(SILGenFunction &SGF, SILLocation loc) const;
+
   /// Disable the cleanup for this value.
   void forwardCleanup(SILGenFunction &SGF) const;
 

lib/SILGen/SILGenApply.cpp

@@ -5722,7 +5722,11 @@ ArgumentSource AccessorBaseArgPreparer::prepareAccessorObjectBaseArg() {
     assert(!selfParam.isIndirectMutating() &&
            "passing unmaterialized r-value as inout argument");
 
-    base = base.materialize(SGF, loc);
+    base = base.formallyMaterialize(SGF, loc);
+    auto shouldTake = IsTake_t(base.hasCleanup());
+    base = SGF.emitFormalAccessLoad(loc, base.forward(SGF),
+                                    SGF.getTypeLowering(baseLoweredType),
+                                    SGFContext(), shouldTake);
   }
 
   return ArgumentSource(loc, RValue(SGF, loc, baseFormalType, base));

lib/SILGen/SILGenBridging.cpp

@@ -154,8 +154,8 @@ emitBridgeNativeToObjectiveC(SILGenFunction &SGF,
   if (witnessConv.isSILIndirect(witnessConv.getParameters()[0])
       && !swiftValue.getType().isAddress()) {
     auto tmp = SGF.emitTemporaryAllocation(loc, swiftValue.getType());
-    SGF.B.createStoreBorrowOrTrivial(loc, swiftValue.borrow(SGF, loc), tmp);
-    swiftValue = ManagedValue::forUnmanaged(tmp);
+    swiftValue = SGF.emitManagedStoreBorrow(
+        loc, swiftValue.borrow(SGF, loc).getValue(), tmp);
   }
 
   // Call the witness.

lib/SILGen/SILGenBuilder.cpp

@@ -721,21 +721,23 @@ createValueMetatype(SILLocation loc, SILType metatype,
   return ManagedValue::forUnmanaged(v);
 }
 
-void SILGenBuilder::createStoreBorrow(SILLocation loc, ManagedValue value,
-                                      SILValue address) {
+ManagedValue SILGenBuilder::createStoreBorrow(SILLocation loc,
+                                              ManagedValue value,
+                                              SILValue address) {
   assert(value.getOwnershipKind() == OwnershipKind::Guaranteed);
-  createStoreBorrow(loc, value.getValue(), address);
+  auto *sbi = createStoreBorrow(loc, value.getValue(), address);
+  return ManagedValue(sbi, CleanupHandle::invalid());
 }
 
-void SILGenBuilder::createStoreBorrowOrTrivial(SILLocation loc,
-                                               ManagedValue value,
-                                               SILValue address) {
+ManagedValue SILGenBuilder::createStoreBorrowOrTrivial(SILLocation loc,
+                                                       ManagedValue value,
+                                                       SILValue address) {
   if (value.getOwnershipKind() == OwnershipKind::None) {
     createStore(loc, value, address, StoreOwnershipQualifier::Trivial);
-    return;
+    return ManagedValue(address, CleanupHandle::invalid());
   }
 
-  createStoreBorrow(loc, value, address);
+  return createStoreBorrow(loc, value, address);
 }
 
 ManagedValue SILGenBuilder::createBridgeObjectToRef(SILLocation loc,

lib/SILGen/SILGenBuilder.h

@@ -190,12 +190,13 @@ class SILGenBuilder : public SILBuilder {
   ManagedValue createFormalAccessLoadBorrow(SILLocation loc, ManagedValue base);
 
   using SILBuilder::createStoreBorrow;
-  void createStoreBorrow(SILLocation loc, ManagedValue value, SILValue address);
+  ManagedValue createStoreBorrow(SILLocation loc, ManagedValue value,
+                                 SILValue address);
 
   /// Create a store_borrow if we have a non-trivial value and a store [trivial]
   /// otherwise.
-  void createStoreBorrowOrTrivial(SILLocation loc, ManagedValue value,
-                                  SILValue address);
+  ManagedValue createStoreBorrowOrTrivial(SILLocation loc, ManagedValue value,
+                                          SILValue address);
 
   /// Prepares a buffer to receive the result of an expression, either using the
   /// 'emit into' initialization buffer if available, or allocating a temporary

lib/SILGen/SILGenExpr.cpp

@@ -129,12 +129,13 @@ ManagedValue SILGenFunction::emitManagedStoreBorrow(
   assert(lowering.getLoweredType().getObjectType() == v->getType());
   if (lowering.isTrivial() || v->getOwnershipKind() == OwnershipKind::None) {
     lowering.emitStore(B, loc, v, addr, StoreOwnershipQualifier::Trivial);
-    return ManagedValue::forUnmanaged(v);
+    return ManagedValue::forTrivialAddressRValue(addr);
   }
   assert((!lowering.isAddressOnly() || !silConv.useLoweredAddresses()) &&
          "cannot retain an unloadable type");
   auto *sbi = B.createStoreBorrow(loc, v, addr);
-  return emitManagedBorrowedRValueWithCleanup(sbi->getSrc(), sbi, lowering);
+  Cleanups.pushCleanup<EndBorrowCleanup>(sbi);
+  return ManagedValue(sbi, CleanupHandle::invalid());
 }
 
 ManagedValue SILGenFunction::emitManagedBeginBorrow(SILLocation loc,
@@ -243,6 +244,18 @@ ManagedValue SILGenFunction::emitFormalEvaluationManagedBeginBorrow(
                                                               lowering);
 }
 
+ManagedValue SILGenFunction::emitFormalEvaluationManagedStoreBorrow(
+    SILLocation loc, SILValue v, SILValue addr) {
+  auto &lowering = getTypeLowering(v->getType());
+  if (lowering.isTrivial() || v->getOwnershipKind() == OwnershipKind::None) {
+    lowering.emitStore(B, loc, v, addr, StoreOwnershipQualifier::Trivial);
+    return ManagedValue::forTrivialAddressRValue(addr);
+  }
+  auto *sbi = B.createStoreBorrow(loc, v, addr);
+  return emitFormalEvaluationManagedBorrowedRValueWithCleanup(loc, v, sbi,
+                                                              lowering);
+}
+
 ManagedValue
 SILGenFunction::emitFormalEvaluationManagedBorrowedRValueWithCleanup(
     SILLocation loc, SILValue original, SILValue borrowed) {
@@ -260,10 +273,6 @@ SILGenFunction::emitFormalEvaluationManagedBorrowedRValueWithCleanup(
   if (lowering.isTrivial())
     return ManagedValue::forUnmanaged(borrowed);
 
-  if (!borrowed->getType().isObject()) {
-    return ManagedValue(borrowed, CleanupHandle::invalid());
-  }
-
   assert(isInFormalEvaluationScope() && "Must be in formal evaluation scope");
   auto &cleanup = Cleanups.pushCleanup<FormalEvaluationEndBorrowCleanup>();
   CleanupHandle handle = Cleanups.getTopCleanup();
@@ -329,10 +338,7 @@ ManagedValue SILGenFunction::emitManagedBorrowedRValueWithCleanup(
       original->getOwnershipKind() == OwnershipKind::None)
     return ManagedValue::forUnmanaged(borrowed);
 
-  if (borrowed->getType().isObject()) {
-    Cleanups.pushCleanup<EndBorrowCleanup>(borrowed);
-  }
-
+  Cleanups.pushCleanup<EndBorrowCleanup>(borrowed);
   return ManagedValue(borrowed, CleanupHandle::invalid());
 }
 

lib/SILGen/SILGenFunction.h

@@ -1544,6 +1544,10 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   emitFormalEvaluationManagedBeginBorrow(SILLocation loc, SILValue v,
                                          const TypeLowering &lowering);
 
+  ManagedValue emitFormalEvaluationManagedStoreBorrow(SILLocation loc,
+                                                      SILValue v,
+                                                      SILValue addr);
+
   ManagedValue emitManagedRValueWithCleanup(SILValue v);
   ManagedValue emitManagedRValueWithCleanup(SILValue v,
                                             const TypeLowering &lowering);

test/SIL/OwnershipVerifier/false_positive_leaks.sil

@@ -26,9 +26,10 @@ sil [ossa] @leak_loop_test : $@convention(thin) (@owned Builtin.NativeObject) ->
 bb0(%0 : @owned $Builtin.NativeObject):
   %1 = alloc_stack $Builtin.NativeObject
   %2 = begin_borrow %0 : $Builtin.NativeObject
-  store_borrow %2 to %1 : $*Builtin.NativeObject
+  %sbi = store_borrow %2 to %1 : $*Builtin.NativeObject
   %3 = function_ref @in_guaranteed_user : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> ()
-  apply %3(%1) : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> ()
+  apply %3(%sbi) : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> ()
+  end_borrow %sbi : $*Builtin.NativeObject
   end_borrow %2 : $Builtin.NativeObject
   dealloc_stack %1 : $*Builtin.NativeObject
   br bb1

test/SIL/OwnershipVerifier/interior_pointer.sil

@@ -119,8 +119,7 @@ bb0(%0 : @owned $Box<T>, %1 : $*Int):
 // CHECK-NEXT: Found outside of lifetime use?!
 // CHECK-NEXT: Value:   %1 = begin_borrow %0 : $Builtin.NativeObject    // users: %4, %3
 // CHECK-NEXT: Consuming User:   end_borrow %1 : $Builtin.NativeObject           // id: %4
-// CHECK-NEXT: Non Consuming User:   %7 = apply %6(%3) : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> ()
-// CHECK-NEXT: Block: bb0
+// CHECK-NEXT: Non Consuming User: end_borrow %3 : $*Builtin.NativeObject
 sil [ossa] @store_borrow_result_used_outside_of_borrow_lifetime : $@convention(thin) (@owned Builtin.NativeObject) -> () {
 bb0(%0 : @owned $Builtin.NativeObject):
   %0a = begin_borrow %0 : $Builtin.NativeObject
@@ -130,6 +129,7 @@ bb0(%0 : @owned $Builtin.NativeObject):
   destroy_value %0 : $Builtin.NativeObject
   %func = function_ref @use_builtinnativeobject_inguaranteed : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> ()
   apply %func(%result) : $@convention(thin) (@in_guaranteed Builtin.NativeObject) -> ()
+  end_borrow %result : $*Builtin.NativeObject
   dealloc_stack %1 : $*Builtin.NativeObject
   %9999 = tuple()
   return %9999 : $()