destructure conversion

Author: atrick

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -102,6 +102,18 @@
 
 namespace swift {
 
+/// Convert this struct_extract into a copy+destructure. Return the destructured
+/// result or invalid SILValue. The caller must delete the extract and its
+/// now-dead copy use.
+///
+// If a copied-def is a struct-extract, attempt a destructure conversion
+//   %extract = struct_extract %... : $TypeWithSingleOwnershipValue
+//   %copy = copy_value %extract : $OwnershipValue
+// To:
+//   %copy = copy_value %extract : $TypeWithSingleOwnershipValue
+//   (%extracted,...) = destructure %copy : $TypeWithSingleOwnershipValue
+SILValue convertExtractToDestructure(StructExtractInst *extract);
+
 /// Information about consumes on the extended-lifetime boundary. Consuming uses
 /// within the lifetime are not included--they will consume a copy after
 /// rewriting. For borrowed def values, the consumes do not include the end of
@@ -175,6 +187,50 @@ class CanonicalOSSAConsumeInfo {
   SWIFT_ASSERT_ONLY_DECL(void dump() const LLVM_ATTRIBUTE_USED);
 };
 
+// Worklist of pointer-like things that have an invalid default value. Avoid
+// revisiting nodes--suitable for DAGs, but pops finished nodes without
+// preserving them in the vector.
+//
+// The primary API has two methods: intialize() and pop(). Others are provided
+// for flexibility.
+//
+// TODO: make this a better utility.
+template <typename T, unsigned SmallSize> struct PtrWorklist {
+  SmallPtrSet<T, SmallSize> ptrVisited;
+  SmallVector<T, SmallSize> ptrVector;
+
+  PtrWorklist() = default;
+
+  PtrWorklist(const PtrWorklist &) = delete;
+
+  void initialize(T t) {
+    clear();
+    insert(t);
+  }
+
+  template <typename R> void initializeRange(R &&range) {
+    clear();
+    ptrVisited.insert(range.begin(), range.end());
+    ptrVector.append(range.begin(), range.end());
+  }
+
+  T pop() { return empty() ? T() : ptrVector.pop_back_val(); }
+
+  bool empty() const { return ptrVector.empty(); }
+
+  unsigned size() const { return ptrVector.size(); }
+
+  void clear() {
+    ptrVector.clear();
+    ptrVisited.clear();
+  }
+
+  void insert(T t) {
+    if (ptrVisited.insert(t).second)
+      ptrVector.push_back(t);
+  }
+};
+
 /// Canonicalize OSSA lifetimes.
 ///
 /// Allows the allocation of analysis state to be reused across calls to
@@ -221,11 +277,11 @@ class CanonicalizeOSSALifetime {
   /// outisde the pruned liveness at the time it is discovered.
   llvm::SmallPtrSet<DebugValueInst *, 8> debugValues;
 
-  /// Reuse a general worklist for def-use traversal.
-  SmallSetVector<SILValue, 8> defUseWorklist;
+  /// Reuse a general visited set for def-use traversal.
+  PtrWorklist<SILValue, 8> defUseWorklist;
 
   /// Reuse a general worklist for CFG traversal.
-  SmallSetVector<SILBasicBlock *, 8> blockWorklist;
+  PtrWorklist<SILBasicBlock *, 8> blockWorklist;
 
   /// Pruned liveness for the extended live range including copies. For this
   /// purpose, only consuming instructions are considered "lifetime
@@ -298,6 +354,15 @@ class CanonicalizeOSSALifetime {
 
   bool consolidateBorrowScope();
 
+  bool findBorrowScopeUses(llvm::SmallPtrSetImpl<SILInstruction *> &useInsts);
+
+  void filterOuterBorrowUseInsts(
+      llvm::SmallPtrSetImpl<SILInstruction *> &outerUseInsts);
+
+  void rewriteOuterBorrowUsesAndFindConsumes(
+      SILValue incomingValue,
+      llvm::SmallPtrSetImpl<SILInstruction *> &outerUseInsts);
+
   bool computeCanonicalLiveness();
 
   bool endsAccessOverlappingPrunedBoundary(SILInstruction *inst);

lib/SILOptimizer/Transforms/CopyPropagation.cpp

@@ -32,6 +32,9 @@
 #include "swift/SILOptimizer/Utils/CanonicalOSSALifetime.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 
+//!!!
+#include "swift/Basic/Defer.h"
+
 using namespace swift;
 
 //===----------------------------------------------------------------------===//
@@ -72,6 +75,13 @@ void CopyPropagation::run() {
   auto *dominanceAnalysis = getAnalysis<DominanceAnalysis>();
   auto *deBlocksAnalysis = getAnalysis<DeadEndBlocksAnalysis>();
 
+  //!!!
+  if (f->hasName("$ss18_StringBreadcrumbsCyABSScfc")) {
+    llvm::DebugFlag = true;
+    llvm::setCurrentDebugType("copy-propagation");
+  }
+  SWIFT_DEFER { llvm::DebugFlag = false; };
+
   // Debug label for unit testing.
   LLVM_DEBUG(llvm::dbgs() << "*** CopyPropagation: " << f->getName() << "\n");
 
@@ -88,12 +98,49 @@ void CopyPropagation::run() {
             CanonicalizeOSSALifetime::getCanonicalCopiedDef(copy));
     }
   }
+  // Push copy_value instructions above their struct_extract operands by
+  // inserting destructures.
+  //
+  // copiedDefs be be modified, but it never shrinks
+  for (unsigned idx = 0; idx < copiedDefs.size(); ++idx) {
+    SILValue def = copiedDefs[idx];
+    auto *copy = dyn_cast<CopyValueInst>(def);
+    if (!copy)
+      continue;
+
+    auto *extract = dyn_cast<StructExtractInst>(copy->getOperand());
+    if (!extract
+        || SILValue(extract).getOwnershipKind() != OwnershipKind::Guaranteed)
+      continue;
+
+    if (SILValue destructuredResult = convertExtractToDestructure(extract)) {
+      // Remove to-be-deleted instructions from copiedDeds. The extract cannot
+      // be in the copiedDefs set since getCanonicalCopiedDef does not allow a
+      // guaranteed projection to be a canonical def.
+      copiedDefs.remove(copy);
+      --idx; // point back to the current element, which was erased.
+
+      // TODO: unfortunately SetVector has no element replacement.
+      copiedDefs.insert(destructuredResult);
+
+      auto *destructure = cast<DestructureStructInst>(
+          destructuredResult.getDefiningInstruction());
+      auto *newCopy = cast<CopyValueInst>(destructure->getOperand());
+      copiedDefs.insert(
+          CanonicalizeOSSALifetime::getCanonicalCopiedDef(newCopy));
+
+      LLVM_DEBUG(llvm::dbgs() << "Destructure Conversion:\n"
+                              << *extract << "  to " << *destructure);
+      // Delete both the copy and the extract.
+      InstructionDeleter().recursivelyDeleteUsersIfDead(extract);
+    }
+  }
   // Perform copy propgation for each copied value.
   CanonicalizeOSSALifetime canonicalizer(pruneDebug, accessBlockAnalysis,
                                          dominanceAnalysis,
                                          deBlocksAnalysis->get(f));
   // Cleanup dead copies. If getCanonicalCopiedDef returns a copy (because the
-  // copy's source operand is unrecgonized), then the copy is itself treated
+  // copy's source operand is unrecgonized), then thecan copy is itself treated
   // like a def and may be dead after canonicalization.
   llvm::SmallVector<CopyValueInst *, 4> deadCopies;
   for (auto &def : copiedDefs) {