Merge pull request #7509 from gottesmm/more_borrow_propagation

More borrow stuff

Author: gottesmm

lib/SILGen/Cleanup.h

@@ -32,7 +32,7 @@ namespace Lowering {
 class JumpDest;
 class SILGenFunction;
 class ManagedValue;
-class BorrowedManagedValue;
+class SharedBorrowFormalEvaluation;
 
 /// The valid states that a cleanup can be in.
 enum class CleanupState {
@@ -73,7 +73,7 @@ class LLVM_LIBRARY_VISIBILITY Cleanup {
   bool isActive() const { return state >= CleanupState::Active; }
   bool isDead() const { return state == CleanupState::Dead; }
 
-  virtual void emit(SILGenFunction &gen, CleanupLocation L) = 0;
+  virtual void emit(SILGenFunction &gen, CleanupLocation loc) = 0;
   virtual void dump(SILGenFunction &gen) const = 0;
 };
 
@@ -120,7 +120,7 @@ class LLVM_LIBRARY_VISIBILITY CleanupManager {
   void setCleanupState(Cleanup &cleanup, CleanupState state);
 
   friend class CleanupStateRestorationScope;
-  friend class BorrowedManagedValue;
+  friend class SharedBorrowFormalEvaluation;
 
 public:
   CleanupManager(SILGenFunction &Gen)

lib/SILGen/FormalEvaluation.cpp

@@ -23,6 +23,15 @@ using namespace Lowering;
 
 void FormalEvaluation::_anchor() {}
 
+//===----------------------------------------------------------------------===//
+//                      Shared Borrow Formal Evaluation
+//===----------------------------------------------------------------------===//
+
+void SharedBorrowFormalEvaluation::finish(SILGenFunction &gen) {
+  gen.B.createEndBorrow(CleanupLocation::get(loc), borrowedValue,
+                        originalValue);
+}
+
 //===----------------------------------------------------------------------===//
 //                          Formal Evaluation Scope
 //===----------------------------------------------------------------------===//

lib/SILGen/FormalEvaluation.h

@@ -15,6 +15,7 @@
 
 #include "Cleanup.h"
 #include "swift/Basic/DiverseStack.h"
+#include "swift/SIL/SILValue.h"
 #include "llvm/ADT/Optional.h"
 
 namespace swift {
@@ -59,6 +60,21 @@ class FormalEvaluation {
   virtual void finish(SILGenFunction &gen) = 0;
 };
 
+class SharedBorrowFormalEvaluation : public FormalEvaluation {
+  SILValue originalValue;
+  SILValue borrowedValue;
+
+public:
+  SharedBorrowFormalEvaluation(SILLocation loc, CleanupHandle cleanup,
+                               SILValue originalValue, SILValue borrowedValue)
+      : FormalEvaluation(sizeof(*this), FormalEvaluation::Shared, loc, cleanup),
+        originalValue(originalValue), borrowedValue(borrowedValue) {}
+  void finish(SILGenFunction &gen) override;
+
+  SILValue getBorrowedValue() const { return borrowedValue; }
+  SILValue getOriginalValue() const { return originalValue; }
+};
+
 class FormalEvaluationContext {
   DiverseStack<FormalEvaluation, 128> stack;
 

lib/SILGen/ManagedValue.cpp

@@ -114,68 +114,12 @@ ManagedValue ManagedValue::borrow(SILGenFunction &gen, SILLocation loc) const {
   return gen.emitManagedBeginBorrow(loc, getValue());
 }
 
-void BorrowedManagedValue::cleanupImpl() {
-  if (!gen.B.hasValidInsertionPoint()) {
-    handle.reset();
-    return;
-  }
-
-  // We had a trivial or an address value so there isn't anything to
-  // cleanup. Still be sure to unset borrowedValue though.
-  if (!handle.hasValue()) {
-    borrowedValue = ManagedValue();
-    return;
-  }
-
-  assert(borrowedValue && "already cleaned up this object!?");
-
-  CleanupHandle handleValue = handle.getValue();
-  CleanupLocation cleanupLoc = CleanupLocation::get(loc);
-
-  auto iter = gen.Cleanups.Stack.find(handleValue);
-  assert(iter != gen.Cleanups.Stack.end() &&
-         "can't change end of cleanups stack");
-
-  Cleanup &cleanup = *iter;
-  assert(cleanup.isActive() && "Cleanup emitted out of order?!");
-
-  CleanupState newState =
-      (cleanup.getState() == CleanupState::Active ? CleanupState::Dead
-                                                  : CleanupState::Dormant);
-  cleanup.emit(gen, cleanupLoc);
-  gen.Cleanups.setCleanupState(cleanup, newState);
-
-  borrowedValue = ManagedValue();
-  handle.reset();
-}
-
-BorrowedManagedValue::BorrowedManagedValue(SILGenFunction &gen,
-                                           ManagedValue originalValue,
-                                           SILLocation loc)
-    : gen(gen), borrowedValue(), handle(), loc(loc) {
-  if (!originalValue)
-    return;
-  auto &lowering = gen.F.getTypeLowering(originalValue.getType());
-  assert(lowering.getLoweredType().getObjectType() ==
-         originalValue.getType().getObjectType());
-
-  if (lowering.isTrivial()) {
-    borrowedValue = ManagedValue::forUnmanaged(originalValue.getValue());
-    return;
-  }
-
-  if (originalValue.getOwnershipKind() == ValueOwnershipKind::Guaranteed) {
-    borrowedValue = ManagedValue::forUnmanaged(originalValue.getValue());
-    return;
-  }
-
-  if (originalValue.getType().isAddress()) {
-    borrowedValue = ManagedValue::forUnmanaged(originalValue.getValue());
-    return;
-  }
-
-  SILValue borrowed = gen.B.createBeginBorrow(loc, originalValue.getValue());
-  if (borrowed->getType().isObject())
-    handle = gen.enterEndBorrowCleanup(originalValue.getValue(), borrowed);
-  borrowedValue = ManagedValue(borrowed, CleanupHandle::invalid());
+ManagedValue ManagedValue::formalEvaluationBorrow(SILGenFunction &gen,
+                                                  SILLocation loc) const {
+  assert(getValue() && "cannot borrow an invalid or in-context value");
+  if (isLValue())
+    return *this;
+  if (getType().isAddress())
+    return ManagedValue::forUnmanaged(getValue());
+  return gen.emitFormalEvaluationManagedBeginBorrow(loc, getValue());
 }

lib/SILGen/ManagedValue.h

@@ -257,6 +257,10 @@ class ManagedValue {
   /// will not be forwarded until the borrowed value is fully used.
   ManagedValue borrow(SILGenFunction &gen, SILLocation loc) const;
 
+  /// Return a formally evaluated "borrowed" version of this value.
+  ManagedValue formalEvaluationBorrow(SILGenFunction &gen,
+                                      SILLocation loc) const;
+
   ManagedValue unmanagedBorrow() const {
     return isLValue() ? *this : ManagedValue::forUnmanaged(getValue());
   }
@@ -362,36 +366,6 @@ class ConsumableManagedValue {
   }
 };
 
-/// An RAII object that allows a user to borrow a value without a specific scope
-/// that ensures that the object is cleaned up before other scoped cleanups
-/// occur. The way cleanup is triggered is by calling:
-///
-///   std::move(value).cleanup();
-class BorrowedManagedValue {
-  SILGenFunction &gen;
-  ManagedValue borrowedValue;
-  Optional<CleanupHandle> handle;
-  SILLocation loc;
-
-public:
-  BorrowedManagedValue(SILGenFunction &gen, ManagedValue originalValue,
-                       SILLocation loc);
-  ~BorrowedManagedValue() {
-    assert(!borrowedValue &&
-           "Did not manually cleanup borrowed managed value?!");
-  }
-  BorrowedManagedValue(const BorrowedManagedValue &) = delete;
-  BorrowedManagedValue(BorrowedManagedValue &&) = delete;
-  BorrowedManagedValue &operator=(const BorrowedManagedValue &) = delete;
-  BorrowedManagedValue &operator=(BorrowedManagedValue &&) = delete;
-
-  void cleanup() && { cleanupImpl(); }
-  operator ManagedValue() const { return borrowedValue; }
-
-private:
-  void cleanupImpl();
-};
-
 } // namespace Lowering
 } // namespace swift
 

lib/SILGen/SILGenDecl.cpp

@@ -1210,12 +1210,6 @@ CleanupHandle SILGenFunction::enterDestroyCleanup(SILValue valueOrAddr) {
   return Cleanups.getTopCleanup();
 }
 
-CleanupHandle SILGenFunction::enterEndBorrowCleanup(SILValue original,
-                                                    SILValue borrowed) {
-  Cleanups.pushCleanup<EndBorrowCleanup>(original, borrowed);
-  return Cleanups.getTopCleanup();
-}
-
 namespace {
   /// A cleanup that deinitializes an opaque existential container
   /// before a value has been stored into it, or after its value was taken.

lib/SILGen/SILGenExpr.cpp

@@ -137,6 +137,116 @@ SILGenFunction::emitManagedBeginBorrow(SILLocation loc, SILValue v,
   return emitManagedBorrowedRValueWithCleanup(v, bbi, lowering);
 }
 
+namespace {
+
+struct EndBorrowCleanup : Cleanup {
+  SILValue originalValue;
+  SILValue borrowedValue;
+
+  EndBorrowCleanup(SILValue originalValue, SILValue borrowedValue)
+      : originalValue(originalValue), borrowedValue(borrowedValue) {}
+
+  void emit(SILGenFunction &gen, CleanupLocation l) override {
+    gen.B.createEndBorrow(l, borrowedValue, originalValue);
+  }
+
+  void dump(SILGenFunction &gen) const override {
+#ifndef NDEBUG
+    llvm::errs() << "EndBorrowCleanup "
+                 << "State:" << getState() << "\n"
+                 << "original:" << originalValue << "\n"
+                 << "borrowed:" << borrowedValue << "\n";
+#endif
+  }
+};
+
+struct FormalEvaluationEndBorrowCleanup : Cleanup {
+  FormalEvaluationContext::stable_iterator Depth;
+
+  FormalEvaluationEndBorrowCleanup() : Depth() {}
+
+  void emit(SILGenFunction &gen, CleanupLocation l) override {
+    getEvaluation(gen).finish(gen);
+  }
+
+  void dump(SILGenFunction &gen) const override {
+#ifndef NDEBUG
+    llvm::errs() << "FormalEvaluationEndBorrowCleanup "
+                 << "State:" << getState() << "\n"
+                 << "original:" << getOriginalValue(gen) << "\n"
+                 << "borrowed:" << getBorrowedValue(gen) << "\n";
+#endif
+  }
+
+  SharedBorrowFormalEvaluation &getEvaluation(SILGenFunction &gen) const {
+    auto &evaluation = *gen.FormalEvalContext.find(Depth);
+    assert(evaluation.getKind() == FormalEvaluation::Shared);
+    return static_cast<SharedBorrowFormalEvaluation &>(evaluation);
+  }
+
+  SILValue getOriginalValue(SILGenFunction &gen) const {
+    return getEvaluation(gen).getOriginalValue();
+  }
+
+  SILValue getBorrowedValue(SILGenFunction &gen) const {
+    return getEvaluation(gen).getBorrowedValue();
+  }
+};
+
+} // end anonymous namespace
+
+ManagedValue
+SILGenFunction::emitFormalEvaluationManagedBeginBorrow(SILLocation loc,
+                                                       SILValue v) {
+  if (v.getOwnershipKind() == ValueOwnershipKind::Guaranteed)
+    return ManagedValue::forUnmanaged(v);
+  auto &lowering = F.getTypeLowering(v->getType());
+  return emitFormalEvaluationManagedBeginBorrow(loc, v, lowering);
+}
+
+ManagedValue SILGenFunction::emitFormalEvaluationManagedBeginBorrow(
+    SILLocation loc, SILValue v, const TypeLowering &lowering) {
+  assert(lowering.getLoweredType().getObjectType() ==
+         v->getType().getObjectType());
+  if (lowering.isTrivial())
+    return ManagedValue::forUnmanaged(v);
+  if (v.getOwnershipKind() == ValueOwnershipKind::Guaranteed)
+    return ManagedValue::forUnmanaged(v);
+  auto *bbi = B.createBeginBorrow(loc, v);
+  return emitFormalEvaluationManagedBorrowedRValueWithCleanup(loc, v, bbi,
+                                                              lowering);
+}
+
+ManagedValue
+SILGenFunction::emitFormalEvaluationManagedBorrowedRValueWithCleanup(
+    SILLocation loc, SILValue original, SILValue borrowed) {
+  auto &lowering = F.getTypeLowering(original->getType());
+  return emitFormalEvaluationManagedBorrowedRValueWithCleanup(
+      loc, original, borrowed, lowering);
+}
+
+ManagedValue
+SILGenFunction::emitFormalEvaluationManagedBorrowedRValueWithCleanup(
+    SILLocation loc, SILValue original, SILValue borrowed,
+    const TypeLowering &lowering) {
+  assert(lowering.getLoweredType().getObjectType() ==
+         original->getType().getObjectType());
+  if (lowering.isTrivial())
+    return ManagedValue::forUnmanaged(borrowed);
+
+  if (!borrowed->getType().isObject()) {
+    return ManagedValue(borrowed, CleanupHandle::invalid());
+  }
+
+  assert(InWritebackScope && "Must be in formal evaluation scope");
+  Cleanups.pushCleanup<FormalEvaluationEndBorrowCleanup>();
+  CleanupHandle handle = Cleanups.getTopCleanup();
+  FormalEvalContext.push<SharedBorrowFormalEvaluation>(loc, handle, original,
+                                                       borrowed);
+
+  return ManagedValue(borrowed, CleanupHandle::invalid());
+}
+
 ManagedValue
 SILGenFunction::emitManagedBorrowedRValueWithCleanup(SILValue original,
                                                      SILValue borrowed) {
@@ -153,8 +263,9 @@ ManagedValue SILGenFunction::emitManagedBorrowedRValueWithCleanup(
   if (lowering.isTrivial())
     return ManagedValue::forUnmanaged(borrowed);
 
-  if (borrowed->getType().isObject())
-    enterEndBorrowCleanup(original, borrowed);
+  if (borrowed->getType().isObject()) {
+    Cleanups.pushCleanup<EndBorrowCleanup>(original, borrowed);
+  }
   return ManagedValue(borrowed, CleanupHandle::invalid());
 }
 
@@ -394,7 +505,7 @@ emitRValueForDecl(SILLocation loc, ConcreteDeclRef declRef, Type ncRefType,
                   AccessSemantics semantics, SGFContext C) {
   assert(!ncRefType->is<LValueType>() &&
          "RValueEmitter shouldn't be called on lvalues");
-  
+
   // Any writebacks for this access are tightly scoped.
   FormalEvaluationScope scope(*this);
 
@@ -494,7 +605,8 @@ emitRValueForDecl(SILLocation loc, ConcreteDeclRef declRef, Type ncRefType,
                       refType, emitManagedRValueWithCleanup(Scalar));
       }
 
-      auto Result = ManagedValue::forUnmanaged(Scalar);
+      // This is a let, so we can make guarantees, so begin the borrow scope.
+      ManagedValue Result = emitManagedBeginBorrow(loc, Scalar);
 
       // If the client can't handle a +0 result, retain it to get a +1.
       // This is a 'let', so we can make guarantees.

lib/SILGen/SILGenFunction.h

@@ -1106,6 +1106,18 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   ManagedValue emitManagedBorrowedRValueWithCleanup(
       SILValue original, SILValue borrowedValue, const TypeLowering &lowering);
 
+  ManagedValue emitFormalEvaluationManagedBorrowedRValueWithCleanup(
+      SILLocation loc, SILValue original, SILValue borrowedValue);
+  ManagedValue emitFormalEvaluationManagedBorrowedRValueWithCleanup(
+      SILLocation loc, SILValue original, SILValue borrowedValue,
+      const TypeLowering &lowering);
+
+  ManagedValue emitFormalEvaluationManagedBeginBorrow(SILLocation loc,
+                                                      SILValue v);
+  ManagedValue
+  emitFormalEvaluationManagedBeginBorrow(SILLocation loc, SILValue v,
+                                         const TypeLowering &lowering);
+
   ManagedValue emitManagedRValueWithCleanup(SILValue v);
   ManagedValue emitManagedRValueWithCleanup(SILValue v,
                                             const TypeLowering &lowering);
@@ -1550,11 +1562,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                               CanType concreteFormalType,
                                               ExistentialRepresentation repr);
 
-  /// Enter a cleanup to emit an EndBorrow stating that \p borrowed (the
-  /// borrowed entity) is no longer borrowed from \p original, the original
-  /// value.
-  CleanupHandle enterEndBorrowCleanup(SILValue original, SILValue borrowed);
-
   /// Evaluate an Expr as an lvalue.
   LValue emitLValue(Expr *E, AccessKind accessKind);