Add destroy_value [poison] support to mandatory copy propagation.

Ensure that any object lifetime that will be shortened ends in
destroy_value [poison], indicating that the reference should not be
dereferenced (e.g. by the debugger) beyond this point.

This has no way of knowing whether the object will actually be
deallocated at this point. It conservatively avoids showing garbage to
debuggers.

Part 1/2: rdar://75012368 (-Onone compiler support for early object
deinitialization with sentinel dead references)

Author: atrick

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -93,6 +93,7 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_CANONICALOSSALIFETIME_H
 #define SWIFT_SILOPTIMIZER_UTILS_CANONICALOSSALIFETIME_H
 
+#include "swift/Basic/SmallPtrSetVector.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SILOptimizer/Analysis/DominanceAnalysis.h"
 #include "swift/SILOptimizer/Analysis/NonLocalAccessBlockAnalysis.h"
@@ -123,13 +124,33 @@ class CanonicalOSSAConsumeInfo {
   /// that should be canonicalized separately.
   llvm::SmallDenseMap<SILBasicBlock *, CopyValueInst *, 4> persistentCopies;
 
+  /// The set of non-destroy consumes that need to be poisoned. This is
+  /// determined in two steps. First findOrInsertDestroyInBlock() checks if the
+  /// lifetime shrank within the block. Second rewriteCopies() checks if the
+  /// consume is in remnantLiveOutBlock(). Finally injectPoison() inserts new
+  /// copies and poison destroys for everything in this set.
+  SmallPtrSetVector<SILInstruction *, 4> needsPoisonConsumes;
+
 public:
   bool hasUnclaimedConsumes() const { return !finalBlockConsumes.empty(); }
 
   void clear() {
     finalBlockConsumes.clear();
     debugAfterConsume.clear();
     persistentCopies.clear();
+    needsPoisonConsumes.clear();
+  }
+
+  void recordNeedsPoison(SILInstruction *consume) {
+    needsPoisonConsumes.insert(consume);
+  }
+
+  bool needsPoison(SILInstruction *consume) const {
+    return needsPoisonConsumes.count(consume);
+  }
+
+  ArrayRef<SILInstruction *> getNeedsPoisonConsumes() const {
+    return needsPoisonConsumes.getArrayRef();
   }
 
   bool hasFinalConsumes() const { return !finalBlockConsumes.empty(); }
@@ -158,6 +179,11 @@ class CanonicalOSSAConsumeInfo {
     debugAfterConsume.push_back(dvi);
   }
 
+  void popDebugAfterConsume(DebugValueInst *dvi) {
+    if (!debugAfterConsume.empty() && debugAfterConsume.back() == dvi)
+      debugAfterConsume.pop_back();
+  }
+
   ArrayRef<DebugValueInst *> getDebugInstsAfterConsume() const {
     return debugAfterConsume;
   }
@@ -189,6 +215,9 @@ class CanonicalizeOSSALifetime {
   /// liveness may be pruned during canonicalization.
   bool pruneDebugMode;
 
+  /// If true, then new destroy_value instructions will be poison.
+  bool poisonRefsMode;
+
   NonLocalAccessBlockAnalysis *accessBlockAnalysis;
   // Lazily initialize accessBlocks only when
   // extendLivenessThroughOverlappingAccess is invoked.
@@ -232,16 +261,26 @@ class CanonicalizeOSSALifetime {
   /// ending". end_borrows do not end a liverange that may include owned copies.
   PrunedLiveness liveness;
 
+  /// remnantLiveOutBlocks are part of the original extended lifetime that are
+  /// not in canonical pruned liveness. There is a path from a PrunedLiveness
+  /// boundary to an original destroy that passes through this block.
+  ///
+  /// These blocks would be equivalent to PrunedLiveness::LiveOut if
+  /// PrunedLiveness were recomputed using all original destroys as interesting
+  /// uses, minus blocks already marked PrunedLiveness::LiveOut. (These blocks
+  /// may be in PrunedLiveness::LiveWithin).
+  SmallSetVector<SILBasicBlock *, 8> remnantLiveOutBlocks;
+
   /// Information about consuming instructions discovered in this caonical OSSA
   /// lifetime.
   CanonicalOSSAConsumeInfo consumes;
 
 public:
-  CanonicalizeOSSALifetime(bool pruneDebugMode,
+  CanonicalizeOSSALifetime(bool pruneDebugMode, bool poisonRefsMode,
                            NonLocalAccessBlockAnalysis *accessBlockAnalysis,
                            DominanceAnalysis *dominanceAnalysis,
                            DeadEndBlocks *deBlocks)
-      : pruneDebugMode(pruneDebugMode),
+      : pruneDebugMode(pruneDebugMode), poisonRefsMode(poisonRefsMode),
         accessBlockAnalysis(accessBlockAnalysis),
         dominanceAnalysis(dominanceAnalysis), deBlocks(deBlocks) {}
 
@@ -263,6 +302,7 @@ class CanonicalizeOSSALifetime {
     consumingBlocks.clear();
     debugValues.clear();
     liveness.clear();
+    remnantLiveOutBlocks.clear();
   }
 
   bool hasChanged() const { return changed; }
@@ -309,7 +349,12 @@ class CanonicalizeOSSALifetime {
 
   void findOrInsertDestroys();
 
+  void insertDestroyOnCFGEdge(SILBasicBlock *predBB, SILBasicBlock *succBB,
+                              bool needsPoison);
+
   void rewriteCopies();
+
+  void injectPoison();
 };
 
 } // end namespace swift

lib/SILOptimizer/Transforms/CopyPropagation.cpp

@@ -44,10 +44,13 @@ class CopyPropagation : public SILFunctionTransform {
   bool pruneDebug;
   /// True of all values should be canonicalized.
   bool canonicalizeAll;
+  /// If true, then new destroy_value instructions will be poison.
+  bool poisonRefs;
 
 public:
-  CopyPropagation(bool pruneDebug, bool canonicalizeAll)
-      : pruneDebug(pruneDebug), canonicalizeAll(canonicalizeAll) {}
+  CopyPropagation(bool pruneDebug, bool canonicalizeAll, bool poisonRefs)
+    : pruneDebug(pruneDebug), canonicalizeAll(canonicalizeAll),
+      poisonRefs(poisonRefs) {}
 
   /// The entry point to this function transformation.
   void run() override;
@@ -98,7 +101,8 @@ void CopyPropagation::run() {
     }
   }
   // Perform copy propgation for each copied value.
-  CanonicalizeOSSALifetime canonicalizer(pruneDebug, accessBlockAnalysis,
+  CanonicalizeOSSALifetime canonicalizer(pruneDebug, poisonRefs,
+                                         accessBlockAnalysis,
                                          dominanceAnalysis,
                                          deBlocksAnalysis->get(f));
   // Cleanup dead copies. If getCanonicalCopiedDef returns a copy (because the
@@ -138,9 +142,12 @@ void CopyPropagation::run() {
 }
 
 SILTransform *swift::createMandatoryCopyPropagation() {
-  return new CopyPropagation(/*pruneDebug*/ true, /*canonicalizeAll*/ true);
+  return new CopyPropagation(/*pruneDebug*/ true, /*canonicalizeAll*/ true,
+                             /*poisonRefs*/ true);
 }
 
 SILTransform *swift::createCopyPropagation() {
-  return new CopyPropagation(/*pruneDebug*/ true, /*canonicalizeAll*/ false);
+  return new CopyPropagation(/*pruneDebug*/ true, /*canonicalizeAll*/ false,
+                             /*poisonRefs*/ false);
 }
+