Merge pull request #60467 from meg-gupta/fixstoreborrowsilgen

Fix store_borrow generation and improve its verification

Author: swift-ci

include/swift/SIL/MemAccessUtils.h

@@ -1691,6 +1691,10 @@ Result AccessUseDefChainVisitor<Impl, Result>::visit(SILValue sourceAddr) {
     if (isAccessStorageIdentityCast(svi))
       return asImpl().visitStorageCast(svi, &svi->getAllOperands()[0],
                                        AccessStorageCast::Identity);
+    if (auto *sbi = dyn_cast<StoreBorrowInst>(svi))
+      return asImpl().visitStorageCast(
+          svi, &sbi->getAllOperands()[CopyLikeInstruction::Dest],
+          AccessStorageCast::Identity);
   }
   switch (sourceAddr->getKind()) {
   default:

include/swift/SIL/SILBuilder.h

@@ -774,7 +774,8 @@ class SILBuilder {
   }
 
   void emitEndBorrowOperation(SILLocation loc, SILValue v) {
-    if (!hasOwnership() || v->getOwnershipKind() == OwnershipKind::None)
+    if (!hasOwnership() || (!v->getType().isAddress() &&
+                            v->getOwnershipKind() == OwnershipKind::None))
       return;
     createEndBorrow(loc, v);
   }

include/swift/SIL/SILCloner.h

@@ -1160,12 +1160,10 @@ template <typename ImplClass>
 void SILCloner<ImplClass>::visitStoreBorrowInst(StoreBorrowInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   if (!getBuilder().hasOwnership()) {
-    // TODO: Eliminate store_borrow result so we can use
-    // recordClonedInstruction. It is not "technically" necessary, but it is
-    // better from an invariant perspective.
     getBuilder().createStore(
         getOpLocation(Inst->getLoc()), getOpValue(Inst->getSrc()),
         getOpValue(Inst->getDest()), StoreOwnershipQualifier::Unqualified);
+    mapValue(Inst, getOpValue(Inst->getDest()));
     return;
   }
 

include/swift/SIL/ScopedAddressUtils.h

@@ -0,0 +1,118 @@
+//===--- ScopedAddressUtils.h ---------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_SCOPEDADDRESSUTILS_H
+#define SWIFT_SIL_SCOPEDADDRESSUTILS_H
+
+#include "swift/Basic/Debug.h"
+#include "swift/Basic/LLVM.h"
+#include "swift/SIL/PrunedLiveness.h"
+#include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILValue.h"
+#include "swift/SILOptimizer/Utils/InstModCallbacks.h"
+
+namespace swift {
+
+class ScopedAddressValueKind {
+public:
+  enum Kind : uint8_t {
+    Invalid = 0,
+    StoreBorrow,
+    BeginAccess,
+  };
+
+private:
+  Kind value;
+
+public:
+  static ScopedAddressValueKind get(SILValue value) {
+    switch (value->getKind()) {
+    default:
+      return Kind::Invalid;
+    case ValueKind::StoreBorrowInst:
+      return Kind::StoreBorrow;
+    case ValueKind::BeginAccessInst:
+      return Kind::BeginAccess;
+    }
+  }
+
+  ScopedAddressValueKind(Kind newValue) : value(newValue) {}
+
+  operator Kind() const { return value; }
+
+  void print(llvm::raw_ostream &os) const;
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              ScopedAddressValueKind kind);
+
+struct ScopedAddressValue {
+  SILValue value;
+  ScopedAddressValueKind kind = ScopedAddressValueKind::Invalid;
+
+  ScopedAddressValue() = default;
+
+  explicit ScopedAddressValue(SILValue value) {
+    kind = ScopedAddressValueKind::get(value);
+    if (kind)
+      this->value = value;
+  }
+
+  operator bool() const {
+    return kind != ScopedAddressValueKind::Invalid && value;
+  }
+
+  void print(llvm::raw_ostream &os) const;
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
+
+  // Helpers to allow a ScopedAddressValue to easily be used as a SILValue
+  // programatically.
+  SILValue operator->() { return value; }
+  SILValue operator->() const { return value; }
+  SILValue operator*() { return value; }
+  SILValue operator*() const { return value; }
+
+  /// Returns true if \p op is a scope edning use of the scoped address value.
+  bool isScopeEndingUse(Operand *op) const;
+  /// Pass all scope ending instructions to the visitor.
+  bool visitScopeEndingUses(function_ref<bool(Operand *)> visitor) const;
+  /// Returns false, if liveness cannot be computed due to pointer escape or
+  /// unkown address use. Add this scope's live blocks into the PrunedLiveness
+  /// result.
+  bool computeLiveness(PrunedLiveness &liveness) const;
+
+  /// Create appropriate scope ending instruction at \p insertPt.
+  void createScopeEnd(SILBasicBlock::iterator insertPt, SILLocation loc) const;
+
+  /// Create scope ending instructions at \p liveness boundary.
+  void endScopeAtLivenessBoundary(PrunedLiveness *liveness) const;
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                              const ScopedAddressValue &value);
+
+/// Returns true if there are other store_borrows enclosed within a store_borrow
+/// \p sbi's scope
+bool hasOtherStoreBorrowsInLifetime(StoreBorrowInst *sbi,
+                                    PrunedLiveness *liveness,
+                                    DeadEndBlocks *deadEndBlocks);
+
+/// Extend the store_borrow \p sbi's scope such that it encloses \p newUsers.
+bool extendStoreBorrow(StoreBorrowInst *sbi,
+                       SmallVectorImpl<Operand *> &newUses,
+                       DeadEndBlocks *deadEndBlocks,
+                       InstModCallbacks callbacks = InstModCallbacks());
+} // namespace swift
+
+#endif

include/swift/SILOptimizer/Utils/GenericCloner.h

@@ -41,6 +41,8 @@ class GenericCloner
       RemappedScopeCache;
 
   llvm::SmallVector<AllocStackInst *, 8> AllocStacks;
+  llvm::SmallVector<StoreBorrowInst *, 8> StoreBorrowsToCleanup;
+  llvm::SmallVector<TermInst *, 8> FunctionExits;
   AllocStackInst *ReturnValueAddr = nullptr;
 
 public:
@@ -92,6 +94,11 @@ class GenericCloner
     if (Callback)
       Callback(Orig, Cloned);
 
+    if (auto *termInst = dyn_cast<TermInst>(Cloned)) {
+      if (termInst->isFunctionExiting()) {
+        FunctionExits.push_back(termInst);
+      }
+    }
     SILClonerWithScopes<GenericCloner>::postProcess(Orig, Cloned);
   }
 

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -247,7 +247,7 @@ void emitDestroyOperation(SILBuilder &builder, SILLocation loc,
 /// Returns true, if there are no other users beside those collected in \p
 /// destroys, i.e. if \p inst can be considered as "dead".
 bool collectDestroys(SingleValueInstruction *inst,
-                     SmallVectorImpl<SILInstruction *> &destroys);
+                     SmallVectorImpl<Operand *> &destroys);
 
 /// If Closure is a partial_apply or thin_to_thick_function with only local
 /// ref count users and a set of post-dominating releases:

include/swift/SILOptimizer/Utils/ValueLifetime.h

@@ -138,6 +138,20 @@ class ValueLifetimeAnalysis {
     propagateLiveness();
   }
 
+  ValueLifetimeAnalysis(SILArgument *def, ArrayRef<Operand *> useRange)
+      : defValue(def), inLiveBlocks(def->getFunction()), userSet() {
+    for (auto *use : useRange)
+      userSet.insert(use->getUser());
+    propagateLiveness();
+  }
+
+  ValueLifetimeAnalysis(SILInstruction *def, ArrayRef<Operand *> useRange)
+      : defValue(def), inLiveBlocks(def->getFunction()), userSet() {
+    for (auto *use : useRange)
+      userSet.insert(use->getUser());
+    propagateLiveness();
+  }
+
   /// Compute the LifetimeBoundary--the last users and boundary edges. This
   /// always succeeds.
   ///

lib/SIL/Utils/CMakeLists.txt

@@ -14,6 +14,7 @@ target_sources(swiftSIL PRIVATE
   PrettyStackTrace.cpp
   Projection.cpp
   PrunedLiveness.cpp
+  ScopedAddressUtils.cpp
   SILBridging.cpp
   SILInstructionWorklist.cpp
   SILRemarkStreamer.cpp

lib/SIL/Utils/MemAccessUtils.cpp

@@ -1935,6 +1935,11 @@ bool AccessPathDefUseTraversal::visitUser(DFSEntry dfs) {
       return true;
     }
   }
+  if (auto *sbi = dyn_cast<StoreBorrowInst>(use->getUser())) {
+    if (use->get() == sbi->getDest()) {
+      pushUsers(sbi, dfs);
+    }
+  }
   if (isa<EndBorrowInst>(use->getUser())) {
     return true;
   }

lib/SIL/Utils/OwnershipUtils.cpp

@@ -20,6 +20,7 @@
 #include "swift/SIL/Projection.h"
 #include "swift/SIL/PrunedLiveness.h"
 #include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
 
 using namespace swift;
@@ -917,7 +918,7 @@ swift::findTransitiveUsesForAddress(SILValue projectedAddress,
         isa<EndUnpairedAccessInst>(user) || isa<WitnessMethodInst>(user) ||
         isa<SwitchEnumAddrInst>(user) || isa<CheckedCastAddrBranchInst>(user) ||
         isa<SelectEnumAddrInst>(user) || isa<InjectEnumAddrInst>(user) ||
-        isa<IsUniqueInst>(user)) {
+        isa<IsUniqueInst>(user) || isa<ValueMetatypeInst>(user)) {
       leafUse(op);
       continue;
     }