[move-only] Integrate BorrowToDestructureTransform into the AddressChecker so we handle load [copy] switch_enum.

Author: gottesmm

lib/SILOptimizer/Mandatory/MoveOnlyAddressChecker.cpp

@@ -156,6 +156,7 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 
+#include "MoveOnlyBorrowToDestructure.h"
 #include "MoveOnlyDiagnostics.h"
 #include "MoveOnlyObjectChecker.h"
 
@@ -866,9 +867,15 @@ struct MoveOnlyChecker {
   /// Information about destroys that we use when inserting destroys.
   ConsumeInfo consumes;
 
+  /// Allocator used by the BorrowToDestructureTransform.
+  borrowtodestructure::IntervalMapAllocator allocator;
+
+  /// PostOrderAnalysis used by the BorrowToDestructureTransform.
+  PostOrderAnalysis *poa;
+
   MoveOnlyChecker(SILFunction *fn, DeadEndBlocks *deBlocks,
-                  DominanceInfo *domTree)
-      : fn(fn), deleter(), canonicalizer(), diagnosticEmitter() {
+                  DominanceInfo *domTree, PostOrderAnalysis *poa)
+      : fn(fn), deleter(), canonicalizer(), diagnosticEmitter(), poa(poa) {
     deleter.setCallbacks(std::move(
         InstModCallbacks().onDelete([&](SILInstruction *instToDelete) {
           if (auto *mvi = dyn_cast<MarkMustCheckInst>(instToDelete))
@@ -1121,6 +1128,31 @@ bool GatherUsesVisitor::visitUse(Operand *op, AccessUseType useTy) {
         li->getOwnershipQualifier() == LoadOwnershipQualifier::Take) {
       SWIFT_DEFER { moveChecker.canonicalizer.clear(); };
 
+      // Before we do anything, run the borrow to destructure transform in case
+      // we have a switch_enum user.
+      unsigned numDiagnostics =
+          moveChecker.diagnosticEmitter.getDiagnosticCount();
+      BorrowToDestructureTransform borrowToDestructure(
+          moveChecker.allocator, markedValue, li, moveChecker.diagnosticEmitter,
+          moveChecker.poa);
+      if (!borrowToDestructure.transform()) {
+        assert(moveChecker.diagnosticEmitter
+                   .didEmitCheckerDoesntUnderstandDiagnostic());
+        LLVM_DEBUG(llvm::dbgs()
+                   << "Failed to perform borrow to destructure transform!\n");
+        emittedEarlyDiagnostic = true;
+        return false;
+      }
+
+      // If we emitted an error diagnostic, do not transform further and instead
+      // mark that we emitted an early diagnostic and return true.
+      if (numDiagnostics !=
+          moveChecker.diagnosticEmitter.getDiagnosticCount()) {
+        LLVM_DEBUG(llvm::dbgs() << "Emitting borrow to destructure error!\n");
+        emittedEarlyDiagnostic = true;
+        return true;
+      }
+
       // Canonicalize the lifetime of the load [take], load [copy].
       moveChecker.changed |= moveChecker.canonicalizer.canonicalize(li);
 
@@ -1558,6 +1590,19 @@ void MoveOnlyChecker::cleanupAfterEmittingDiagnostic() {
           changed = true;
         }
       }
+
+      // Convert any copy_value of move_only type to explicit copy value.
+      if (auto *cvi = dyn_cast<CopyValueInst>(inst)) {
+        if (!cvi->getOperand()->getType().isMoveOnly())
+          continue;
+        SILBuilderWithScope b(cvi);
+        auto *expCopy =
+            b.createExplicitCopyValue(cvi->getLoc(), cvi->getOperand());
+        cvi->replaceAllUsesWith(expCopy);
+        cvi->eraseFromParent();
+        changed = true;
+        continue;
+      }
     }
   }
 }
@@ -1982,8 +2027,10 @@ class MoveOnlyCheckerPass : public SILFunctionTransform {
     auto *dominanceAnalysis = getAnalysis<DominanceAnalysis>();
     DominanceInfo *domTree = dominanceAnalysis->get(fn);
     auto *deAnalysis = getAnalysis<DeadEndBlocksAnalysis>()->get(fn);
+    auto *poa = getAnalysis<PostOrderAnalysis>();
 
-    if (MoveOnlyChecker(getFunction(), deAnalysis, domTree).checkFunction()) {
+    if (MoveOnlyChecker(getFunction(), deAnalysis, domTree, poa)
+            .checkFunction()) {
       invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
     }
 

lib/SILOptimizer/Mandatory/MoveOnlyBorrowToDestructure.h

@@ -59,6 +59,7 @@ class BorrowToDestructureTransform {
 
   IntervalMapAllocator &allocator;
   MarkMustCheckInst *mmci;
+  SILValue rootValue;
   DiagnosticEmitter &diagnosticEmitter;
   PostOrderAnalysis *poa;
   PostOrderFunctionInfo *pofi = nullptr;
@@ -67,11 +68,11 @@ class BorrowToDestructureTransform {
 
 public:
   BorrowToDestructureTransform(IntervalMapAllocator &allocator,
-                               MarkMustCheckInst *mmci,
+                               MarkMustCheckInst *mmci, SILValue rootValue,
                                DiagnosticEmitter &diagnosticEmitter,
                                PostOrderAnalysis *poa)
-      : allocator(allocator), mmci(mmci), diagnosticEmitter(diagnosticEmitter),
-        poa(poa) {}
+      : allocator(allocator), mmci(mmci), rootValue(rootValue),
+        diagnosticEmitter(diagnosticEmitter), poa(poa) {}
 
   bool transform();
 

lib/SILOptimizer/Mandatory/MoveOnlyBorrowToDestructureTransform.cpp

@@ -1523,7 +1523,7 @@ void Implementation::cleanup() {
 ///
 /// Returns false if we found an escape and thus cannot process. It is assumed
 /// that the caller will fail in such a case.
-static bool gatherBorrows(MarkMustCheckInst *mmci,
+static bool gatherBorrows(SILValue rootValue,
                           StackList<BeginBorrowInst *> &borrowWorklist) {
   // If we have a no implicit copy mark_must_check, we do not run the borrow to
   // destructure transform since:
@@ -1534,15 +1534,16 @@ static bool gatherBorrows(MarkMustCheckInst *mmci,
   // 2. If we do not have a move only type, then we know that all fields that we
   //    access directly and would cause a need to destructure must be copyable,
   //    so no transformation/error is needed.
-  if (mmci->getType().isMoveOnlyWrapped()) {
-    LLVM_DEBUG(llvm::dbgs() << "Skipping move only wrapped inst: " << *mmci);
+  if (rootValue->getType().isMoveOnlyWrapped()) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "Skipping move only wrapped inst: " << *rootValue);
     return true;
   }
 
-  LLVM_DEBUG(llvm::dbgs() << "Searching for borrows for inst: " << *mmci);
+  LLVM_DEBUG(llvm::dbgs() << "Searching for borrows for inst: " << *rootValue);
 
-  StackList<Operand *> worklist(mmci->getFunction());
-  for (auto *op : mmci->getUses())
+  StackList<Operand *> worklist(rootValue->getFunction());
+  for (auto *op : rootValue->getUses())
     worklist.push_back(op);
 
   while (!worklist.empty()) {
@@ -1728,8 +1729,10 @@ bool BorrowToDestructureTransform::transform() {
 
   // If we failed to gather borrows due to the transform not understanding part
   // of the SIL, fail and return false.
-  if (!gatherBorrows(mmci, borrowWorklist))
+  if (!gatherBorrows(rootValue, borrowWorklist)) {
+    diagnosticEmitter.emitCheckerDoesntUnderstandDiagnostic(mmci);
     return false;
+  }
 
   // If we do not have any borrows to process, return true early to show we
   // succeeded in processing.
@@ -1742,8 +1745,10 @@ bool BorrowToDestructureTransform::transform() {
   SmallVector<SwitchEnumInst *, 8> switchEnumWorklist;
   for (auto *borrow : borrowWorklist) {
     // Attempt to gather the switch enums and if we fail, return false.
-    if (!gatherSwitchEnum(borrow, switchEnumWorklist))
+    if (!gatherSwitchEnum(borrow, switchEnumWorklist)) {
+      diagnosticEmitter.emitCheckerDoesntUnderstandDiagnostic(mmci);
       return false;
+    }
   }
 
   // Now perform the checking of our switch_enum, working in stack order.
@@ -1863,15 +1868,23 @@ bool BorrowToDestructureTransform::transform() {
     }
   }
 
+  // At this point, we have correct OSSA SIL for our switch_enums. Check if for
+  // any of our switch_enum we emitted a we don't understand diagnostic... in
+  // such a case, exit before we do further work.
+  if (diagnosticEmitter.didEmitCheckerDoesntUnderstandDiagnostic())
+    return false;
+
   // Now that we have handled our switch_enum we need to handle our
   // borrows... begin by gathering uses. Return false if we saw something that
   // we did not understand.
   SmallVector<SILBasicBlock *, 8> discoveredBlocks;
   Implementation impl(*this, discoveredBlocks);
-  impl.init(mmci);
+  impl.init(rootValue);
   for (auto *bbi : borrowWorklist) {
-    if (!impl.gatherUses(bbi))
+    if (!impl.gatherUses(bbi)) {
+      diagnosticEmitter.emitCheckerDoesntUnderstandDiagnostic(mmci);
       return false;
+    }
   }
 
   // Next make sure that any destructure needing instructions are on the

lib/SILOptimizer/Mandatory/MoveOnlyBorrowToDestructureTransformTester.cpp

@@ -55,8 +55,8 @@ static bool runTransform(SILFunction *fn,
     auto *mmci = moveIntroducersToProcess.back();
     moveIntroducersToProcess = moveIntroducersToProcess.drop_back();
 
-    BorrowToDestructureTransform transform(allocator, mmci, diagnosticEmitter,
-                                           poa);
+    BorrowToDestructureTransform transform(allocator, mmci, mmci,
+                                           diagnosticEmitter, poa);
     transform.transform();
     madeChange = true;
   }

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.cpp

@@ -102,6 +102,7 @@ void DiagnosticEmitter::emitCheckerDoesntUnderstandDiagnostic(
              diag::sil_moveonlychecker_not_understand_moveonly);
   }
   registerDiagnosticEmitted(markedValue);
+  emittedCheckerDoesntUnderstandDiagnostic = true;
 }
 
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/Mandatory/MoveOnlyDiagnostics.h

@@ -50,6 +50,8 @@ class DiagnosticEmitter {
   /// diagnosics while running a callee.
   unsigned diagnosticCount = 0;
 
+  bool emittedCheckerDoesntUnderstandDiagnostic = false;
+
 public:
   void init(SILFunction *inputFn, OSSACanonicalizer *inputCanonicalizer) {
     fn = inputFn;
@@ -65,6 +67,9 @@ class DiagnosticEmitter {
   }
 
   unsigned getDiagnosticCount() const { return diagnosticCount; }
+  bool didEmitCheckerDoesntUnderstandDiagnostic() const {
+    return emittedCheckerDoesntUnderstandDiagnostic;
+  }
 
   void emitCheckerDoesntUnderstandDiagnostic(MarkMustCheckInst *markedValue);
   void emitObjectGuaranteedDiagnostic(MarkMustCheckInst *markedValue);

lib/SILOptimizer/Mandatory/MoveOnlyObjectChecker.cpp

@@ -423,8 +423,8 @@ struct MoveOnlyChecker {
 bool MoveOnlyChecker::convertBorrowExtractsToOwnedDestructures(
     MarkMustCheckInst *mmci, DiagnosticEmitter &diagnosticEmitter,
     DominanceInfo *domTree, PostOrderAnalysis *poa) {
-  BorrowToDestructureTransform transform(allocator, mmci, diagnosticEmitter,
-                                         poa);
+  BorrowToDestructureTransform transform(allocator, mmci, mmci,
+                                         diagnosticEmitter, poa);
   if (!transform.transform()) {
     LLVM_DEBUG(llvm::dbgs()
                << "Failed to perform borrow to destructure transform!\n");