Merge pull request #39956 from gottesmm/pr-c8f8cf9d6d3aa0800cc5fae25efd75c625e57d3c

[moveOnly] Add a new experimental move only checker that checks noImplicitCopy variables.

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -690,5 +690,16 @@ NOTE(capturepromotion_variable_defined_here,none,
 ERROR(move_operator_used_on_generic_or_existential_value, none,
       "move() used on a generic or existential value", ())
 
+// noimplicitcopy on generic or existential binding
+ERROR(noimplicitcopy_used_on_generic_or_existential, none,
+      "@_noImplicitCopy can not be used on a generic or existential typed "
+      "binding or a nominal type containing such typed things", ())
+
+// move only checker diagnostics
+ERROR(sil_moveonlychecker_value_consumed_more_than_once, none,
+      "'%0' consumed more than once", (StringRef))
+NOTE(sil_moveonlychecker_consuming_use_here, none,
+     "consuming use", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/SIL/DebugUtils.h

@@ -174,6 +174,18 @@ inline SILInstruction *getSingleNonDebugUser(SILValue V) {
   return I->getUser();
 }
 
+/// If \p value has a single debug user, return the operand associated with that
+/// use. Otherwise, returns nullptr.
+inline Operand *getSingleDebugUse(SILValue value) {
+  auto range = getDebugUses(value);
+  auto ii = range.begin(), ie = range.end();
+  if (ii == ie)
+    return nullptr;
+  if (std::next(ii) != ie)
+    return nullptr;
+  return *ii;
+}
+
 /// Erases the instruction \p I from it's parent block and deletes it, including
 /// all debug instructions which use \p I.
 /// Precondition: The instruction may only have debug instructions as uses.

include/swift/SILOptimizer/PassManager/Passes.def

@@ -416,6 +416,8 @@ PASS(BugReducerTester, "bug-reducer-tester",
      "sil-bug-reducer Tool Testing by Asserting on a Sentinel Function")
 PASS(AssemblyVisionRemarkGenerator, "assembly-vision-remark-generator",
      "Emit assembly vision remarks that provide source level guidance of where runtime calls ended up")
+PASS(MoveOnlyChecker, "sil-move-only-checker",
+     "Pass that enforces move only invariants on raw SIL")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -114,6 +114,13 @@ extern llvm::Statistic NumCopiesGenerated;
 /// Insert a copy on this operand. Trace and update stats.
 void copyLiveUse(Operand *use, InstModCallbacks &instModCallbacks);
 
+/// Diagnose that the given value is a move only type for which \p use causes a
+/// need to copy the move only value.
+///
+/// copy on this operand. Trace and update stats.
+void diagnoseRequiredCopyOfMoveOnly(Operand *use,
+                                    InstModCallbacks &instModCallbacks);
+
 /// 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
@@ -244,6 +251,15 @@ class CanonicalizeOSSALifetime {
   /// If true, then new destroy_value instructions will be poison.
   bool poisonRefsMode;
 
+  /// If true and we are processing a value of move_only type, emit a diagnostic
+  /// when-ever we need to insert a copy_value.
+  std::function<void(Operand *)> moveOnlyCopyValueNotification;
+
+  /// If true and we are processing a value of move_only type, pass back to the
+  /// caller any consuming uses that are going to be used as part of the final
+  /// lifetime boundary in case we need to emit diagnostics.
+  std::function<void(Operand *)> moveOnlyFinalConsumingUse;
+
   NonLocalAccessBlockAnalysis *accessBlockAnalysis;
   // Lazily initialize accessBlocks only when
   // extendLivenessThroughOverlappingAccess is invoked.
@@ -296,10 +312,27 @@ class CanonicalizeOSSALifetime {
   CanonicalOSSAConsumeInfo consumes;
 
 public:
-  CanonicalizeOSSALifetime(bool pruneDebugMode, bool poisonRefsMode,
-                           NonLocalAccessBlockAnalysis *accessBlockAnalysis,
-                           DominanceInfo *domTree, InstructionDeleter &deleter)
+  void maybeNotifyMoveOnlyCopy(Operand *use) {
+    if (!moveOnlyCopyValueNotification)
+      return;
+    moveOnlyCopyValueNotification(use);
+  }
+
+  void maybeNotifyFinalConsumingUse(Operand *use) {
+    if (!moveOnlyFinalConsumingUse)
+      return;
+    moveOnlyFinalConsumingUse(use);
+  }
+
+  CanonicalizeOSSALifetime(
+      bool pruneDebugMode, bool poisonRefsMode,
+      NonLocalAccessBlockAnalysis *accessBlockAnalysis, DominanceInfo *domTree,
+      InstructionDeleter &deleter,
+      std::function<void(Operand *)> moveOnlyCopyValueNotification = nullptr,
+      std::function<void(Operand *)> moveOnlyFinalConsumingUse = nullptr)
       : pruneDebugMode(pruneDebugMode), poisonRefsMode(poisonRefsMode),
+        moveOnlyCopyValueNotification(moveOnlyCopyValueNotification),
+        moveOnlyFinalConsumingUse(moveOnlyFinalConsumingUse),
         accessBlockAnalysis(accessBlockAnalysis), domTree(domTree),
         deleter(deleter) {}
 

lib/SILGen/SILGenDecl.cpp

@@ -18,16 +18,18 @@
 #include "Scope.h"
 #include "SwitchEnumBuilder.h"
 #include "swift/AST/ASTMangler.h"
+#include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
-#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/PropertyWrappers.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/SIL/FormalLinkage.h"
 #include "swift/SIL/PrettyStackTrace.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILDebuggerClient.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILType.h"
 #include "swift/SIL/TypeLowering.h"
 #include "llvm/ADT/SmallString.h"
@@ -36,6 +38,13 @@
 using namespace swift;
 using namespace Lowering;
 
+// Utility for emitting diagnostics.
+template <typename... T, typename... U>
+static void diagnose(ASTContext &Context, SourceLoc loc, Diag<T...> diag,
+                     U &&...args) {
+  Context.Diags.diagnose(loc, diag, std::forward<U>(args)...);
+}
+
 void Initialization::_anchor() {}
 void SILDebuggerClient::anchor() {}
 
@@ -254,10 +263,6 @@ class DestroyLocalVariable : public Cleanup {
 
   void emit(SILGenFunction &SGF, CleanupLocation l,
             ForUnwind_t forUnwind) override {
-    SILValue val = SGF.VarLocs[Var].value;
-    if (SGF.getASTContext().SILOpts.EnableExperimentalLexicalLifetimes &&
-        val->getOwnershipKind() != OwnershipKind::None)
-      SGF.B.createEndBorrow(l, val);
     SGF.destroyLocalVariable(l, Var);
   }
 
@@ -456,7 +461,16 @@ class LetValueInitialization : public Initialization {
       needsTemporaryBuffer =
           lowering.isAddressOnly() && SGF.silConv.useLoweredAddresses();
     }
-   
+
+    // Make sure that we have a non-address only type when binding a
+    // @_noImplicitCopy let.
+    if (SGF.getASTContext().LangOpts.EnableExperimentalMoveOnly &&
+        lowering.isAddressOnly() &&
+        vd->getAttrs().hasAttribute<NoImplicitCopyAttr>()) {
+      auto d = diag::noimplicitcopy_used_on_generic_or_existential;
+      diagnose(SGF.getASTContext(), vd->getLoc(), d);
+    }
+
     if (needsTemporaryBuffer) {
       address = SGF.emitTemporaryAllocation(vd, lowering.getLoweredType());
       if (isUninitialized)
@@ -517,7 +531,7 @@ class LetValueInitialization : public Initialization {
                                             SplitCleanups);
   }
 
-  void bindValue(SILValue value, SILGenFunction &SGF) {
+  void bindValue(SILValue value, SILGenFunction &SGF, bool wasPlusOne) {
     assert(!SGF.VarLocs.count(vd) && "Already emitted this vardecl?");
     // If we're binding an address to this let value, then we can use it as an
     // address later.  This happens when binding an address only parameter to
@@ -527,9 +541,33 @@ class LetValueInitialization : public Initialization {
     SILLocation PrologueLoc(vd);
 
     if (SGF.getASTContext().SILOpts.EnableExperimentalLexicalLifetimes &&
-        value->getOwnershipKind() != OwnershipKind::None)
-      value = SILValue(
-          SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true));
+        value->getOwnershipKind() != OwnershipKind::None) {
+      if (!SGF.getASTContext().LangOpts.EnableExperimentalMoveOnly) {
+        value = SILValue(
+            SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true));
+      } else {
+        // If we have an owned value that had a cleanup, then create a
+        // move_value that acts as a consuming use of the value. The reason why
+        // we want this is even if we are only performing a borrow for our
+        // lexical lifetime, we want to ensure that our defs see this
+        // initialization as consuming this value.
+        if (value->getOwnershipKind() == OwnershipKind::Owned) {
+          assert(wasPlusOne);
+          value = SILValue(SGF.B.createMoveValue(PrologueLoc, value));
+        }
+
+        if (vd->getAttrs().hasAttribute<NoImplicitCopyAttr>()) {
+          value = SILValue(SGF.B.createBeginBorrow(PrologueLoc, value,
+                                                   /*isLexical*/ true));
+          value = SGF.B.createCopyValue(PrologueLoc, value);
+          value = SGF.B.createMoveValue(PrologueLoc, value);
+        } else {
+          value = SILValue(
+              SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true));
+        }
+      }
+    }
+
     SGF.VarLocs[vd] = SILGenFunction::VarLoc::get(value);
 
     // Emit a debug_value[_addr] instruction to record the start of this value's
@@ -540,26 +578,27 @@ class LetValueInitialization : public Initialization {
     SILDebugVariable DbgVar(vd->isLet(), /*ArgNo=*/0);
     SGF.B.emitDebugDescription(PrologueLoc, value, DbgVar);
   }
-  
+
   void copyOrInitValueInto(SILGenFunction &SGF, SILLocation loc,
                            ManagedValue value, bool isInit) override {
     // If this let value has an address, we can handle it just like a single
     // buffer value.
-    if (hasAddress())
+    if (hasAddress()) {
       return SingleBufferInitialization::
         copyOrInitValueIntoSingleBuffer(SGF, loc, value, isInit, address);
-    
+    }
+
     // Otherwise, we bind the value.
     if (isInit) {
       // Disable the rvalue expression cleanup, since the let value
       // initialization has a cleanup that lives for the entire scope of the
       // let declaration.
-      bindValue(value.forward(SGF), SGF);
+      bindValue(value.forward(SGF), SGF, value.isPlusOne(SGF));
     } else {
       // Disable the expression cleanup of the copy, since the let value
       // initialization has a cleanup that lives for the entire scope of the
       // let declaration.
-      bindValue(value.copyUnmanaged(SGF, loc).forward(SGF), SGF);
+      bindValue(value.copyUnmanaged(SGF, loc).forward(SGF), SGF, true);
     }
   }
 
@@ -1715,16 +1754,38 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
   // For 'let' bindings, we emit a release_value or destroy_addr, depending on
   // whether we have an address or not.
   SILValue Val = loc.value;
-  if (!Val->getType().isAddress()) {
-    SILValue valueToBeDestroyed;
-    if (getASTContext().SILOpts.EnableExperimentalLexicalLifetimes &&
-        Val->getOwnershipKind() != OwnershipKind::None) {
-      auto *inst = cast<BeginBorrowInst>(Val.getDefiningInstruction());
-      valueToBeDestroyed = inst->getOperand();
-    } else {
-      valueToBeDestroyed = Val;
-    }
-    B.emitDestroyValueOperation(silLoc, valueToBeDestroyed);
-  } else
+
+  if (Val->getType().isAddress()) {
     B.createDestroyAddr(silLoc, Val);
+    return;
+  }
+
+  if (!getASTContext().SILOpts.EnableExperimentalLexicalLifetimes ||
+      Val->getOwnershipKind() == OwnershipKind::None) {
+    B.emitDestroyValueOperation(silLoc, Val);
+    return;
+  }
+
+  if (auto *bbi = dyn_cast<BeginBorrowInst>(Val.getDefiningInstruction())) {
+    B.createEndBorrow(silLoc, bbi);
+    B.emitDestroyValueOperation(silLoc, bbi->getOperand());
+    return;
+  }
+
+  if (getASTContext().LangOpts.EnableExperimentalMoveOnly) {
+    if (auto *mvi = dyn_cast<MoveValueInst>(Val.getDefiningInstruction())) {
+      if (auto *cvi = dyn_cast<CopyValueInst>(mvi->getOperand())) {
+        if (auto *bbi = dyn_cast<BeginBorrowInst>(cvi->getOperand())) {
+          if (bbi->isLexical()) {
+            B.emitDestroyValueOperation(silLoc, mvi);
+            B.createEndBorrow(silLoc, bbi);
+            B.emitDestroyValueOperation(silLoc, bbi->getOperand());
+            return;
+          }
+        }
+      }
+    }
+  }
+
+  llvm_unreachable("unhandled case");
 }

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -17,6 +17,7 @@ target_sources(swiftSILOptimizer PRIVATE
   IRGenPrepare.cpp
   LowerHopToActor.cpp
   MandatoryInlining.cpp
+  MoveOnlyChecker.cpp
   NestedSemanticFunctionCheck.cpp
   OptimizeHopToExecutor.cpp
   PredictableMemOpt.cpp