[sil-combine] Canonicalize copies using canonicalizeOSSALifetimes when moving newly created instructions into the worklist.

To be more explicit, canonicalizeOSSALifetimes is a utility that
re-canonicalizes all at once a set of defs that the caller found by applying
CanonicalizeOSSALifetime::getCanonicalCopiedDef(copy)). The reason why I am
doing this is that when we RAUW in OSSA, we sometimes insert additional copies
to make the problem easier for a utility to handle. This lets us canonicalize
away any copies before we even leave the pass.

Author: gottesmm

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -21,14 +21,17 @@
 #define DEBUG_TYPE "sil-combine"
 
 #include "SILCombiner.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/DebugUtils.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILVisitor.h"
-#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
+#include "swift/SILOptimizer/Analysis/DominanceAnalysis.h"
+#include "swift/SILOptimizer/Analysis/NonLocalAccessBlockAnalysis.h"
 #include "swift/SILOptimizer/Analysis/SimplifyInstruction.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "swift/SILOptimizer/Utils/CanonicalOSSALifetime.h"
 #include "swift/SILOptimizer/Utils/CanonicalizeInstruction.h"
 #include "swift/SILOptimizer/Utils/DebugOptUtils.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
@@ -299,10 +302,39 @@ bool SILCombiner::doOneIteration(SILFunction &F, unsigned Iteration) {
     }
 
     // Our tracking list has been accumulating instructions created by the
-    // SILBuilder during this iteration. Go through the tracking list and add
-    // its contents to the worklist and then clear said list in preparation for
-    // the next iteration.
+    // SILBuilder during this iteration. In order to finish this round of
+    // SILCombine, go through the tracking list and add its contents to the
+    // worklist and then clear said list in preparation for the next
+    // iteration. We canonicalize any copies that we created in order to
+    // eliminate unnecessary copies introduced by RAUWing when ownership is
+    // enabled.
+    //
+    // NOTE: It is ok if copy propagation results in MadeChanges being set to
+    // true. This is because we only add elements to the tracking list if we
+    // actually made a change to the IR, so MadeChanges should already be true
+    // at this point.
     auto &TrackingList = *Builder.getTrackingList();
+    if (TrackingList.size() && Builder.hasOwnership()) {
+      SmallSetVector<SILValue, 16> defsToCanonicalize;
+      for (auto *trackedInst : TrackingList) {
+        if (auto *cvi = dyn_cast<CopyValueInst>(trackedInst)) {
+          defsToCanonicalize.insert(
+              CanonicalizeOSSALifetime::getCanonicalCopiedDef(cvi));
+        }
+      }
+      if (defsToCanonicalize.size()) {
+        CanonicalizeOSSALifetime canonicalizer(
+            false /*prune debug*/, false /*canonicalize borrows*/,
+            false /*poison refs*/, NLABA, DA, instModCallbacks);
+        auto analysisInvalidation = canonicalizeOSSALifetimes(
+            canonicalizer, defsToCanonicalize.getArrayRef());
+        if (bool(analysisInvalidation)) {
+          NLABA->lockInvalidation();
+          parentTransform->invalidateAnalysis(analysisInvalidation);
+          NLABA->unlockInvalidation();
+        }
+      }
+    }
     for (SILInstruction *I : TrackingList) {
       LLVM_DEBUG(llvm::dbgs() << "SC: add " << *I
                               << " from tracking list to worklist\n");
@@ -359,12 +391,13 @@ class SILCombine : public SILFunctionTransform {
     auto *DA = PM->getAnalysis<DominanceAnalysis>();
     auto *PCA = PM->getAnalysis<ProtocolConformanceAnalysis>();
     auto *CHA = PM->getAnalysis<ClassHierarchyAnalysis>();
+    auto *NLABA = PM->getAnalysis<NonLocalAccessBlockAnalysis>();
 
     SILOptFunctionBuilder FuncBuilder(*this);
     // Create a SILBuilder with a tracking list for newly added
     // instructions, which we will periodically move to our worklist.
     SILBuilder B(*getFunction(), &TrackingList);
-    SILCombiner Combiner(FuncBuilder, B, AA, DA, PCA, CHA,
+    SILCombiner Combiner(this, FuncBuilder, B, AA, DA, PCA, CHA, NLABA,
                          getOptions().RemoveRuntimeAsserts);
     bool Changed = Combiner.runOnFunction(*getFunction());
     assert(TrackingList.empty() &&

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -29,6 +29,7 @@
 #include "swift/SIL/SILValue.h"
 #include "swift/SIL/SILVisitor.h"
 #include "swift/SILOptimizer/Analysis/ClassHierarchyAnalysis.h"
+#include "swift/SILOptimizer/Analysis/NonLocalAccessBlockAnalysis.h"
 #include "swift/SILOptimizer/Analysis/ProtocolConformanceAnalysis.h"
 #include "swift/SILOptimizer/Utils/CastOptimizer.h"
 #include "swift/SILOptimizer/Utils/Existential.h"
@@ -46,6 +47,7 @@ class AliasAnalysis;
 /// the worklist.
 class SILCombiner :
     public SILInstructionVisitor<SILCombiner, SILInstruction *> {
+  SILFunctionTransform *parentTransform;
 
   AliasAnalysis *AA;
 
@@ -59,6 +61,10 @@ class SILCombiner :
   /// conforming class.
   ClassHierarchyAnalysis *CHA;
 
+  /// Non local access block analysis that we use when canonicalize object
+  /// lifetimes in OSSA.
+  NonLocalAccessBlockAnalysis *NLABA;
+
   /// Worklist containing all of the instructions primed for simplification.
   SmallSILInstructionWorklist<256> Worklist;
 
@@ -97,39 +103,47 @@ class SILCombiner :
   OwnershipFixupContext ownershipFixupContext;
 
 public:
-  SILCombiner(SILOptFunctionBuilder &FuncBuilder, SILBuilder &B,
+  SILCombiner(SILFunctionTransform *parentTransform,
+              SILOptFunctionBuilder &FuncBuilder, SILBuilder &B,
               AliasAnalysis *AA, DominanceAnalysis *DA,
               ProtocolConformanceAnalysis *PCA, ClassHierarchyAnalysis *CHA,
-              bool removeCondFails)
-      : AA(AA), DA(DA), PCA(PCA), CHA(CHA), Worklist("SC"),
-        deadEndBlocks(&B.getFunction()), MadeChange(false),
-        RemoveCondFails(removeCondFails), Iteration(0), Builder(B),
-        CastOpt(
-            FuncBuilder, nullptr /*SILBuilderContext*/,
-            /* ReplaceValueUsesAction */
-            [&](SILValue Original, SILValue Replacement) {
-              replaceValueUsesWith(Original, Replacement);
-            },
-            /* ReplaceInstUsesAction */
-            [&](SingleValueInstruction *I, ValueBase *V) {
-              replaceInstUsesWith(*I, V);
-            },
-            /* EraseAction */
-            [&](SILInstruction *I) { eraseInstFromFunction(*I); }),
-        instModCallbacks(),
-        deBlocks(&B.getFunction()),
+              NonLocalAccessBlockAnalysis *NLABA, bool removeCondFails)
+      : parentTransform(parentTransform), AA(AA), DA(DA), PCA(PCA), CHA(CHA),
+        NLABA(NLABA), Worklist("SC"), deadEndBlocks(&B.getFunction()),
+        MadeChange(false), RemoveCondFails(removeCondFails), Iteration(0),
+        Builder(B), CastOpt(
+                        FuncBuilder, nullptr /*SILBuilderContext*/,
+                        /* ReplaceValueUsesAction */
+                        [&](SILValue Original, SILValue Replacement) {
+                          replaceValueUsesWith(Original, Replacement);
+                        },
+                        /* ReplaceInstUsesAction */
+                        [&](SingleValueInstruction *I, ValueBase *V) {
+                          replaceInstUsesWith(*I, V);
+                        },
+                        /* EraseAction */
+                        [&](SILInstruction *I) { eraseInstFromFunction(*I); }),
+        instModCallbacks(), deBlocks(&B.getFunction()),
         ownershipFixupContext(instModCallbacks, deBlocks) {
-    instModCallbacks = InstModCallbacks()
-      .onDelete([&](SILInstruction *instToDelete) {
-              eraseInstFromFunction(*instToDelete);
-      })
-      .onCreateNewInst([&](SILInstruction *newlyCreatedInst) {
-        Worklist.add(newlyCreatedInst);
-      })
-      .onSetUseValue([&](Operand *use, SILValue newValue) {
-        use->set(newValue);
-        Worklist.add(use->getUser());
-      });
+    instModCallbacks =
+        InstModCallbacks()
+            .onDelete([&](SILInstruction *instToDelete) {
+              // We allow for users in SILCombine to perform 2 stage deletion,
+              // so we need to split the erasing of instructions from adding
+              // operands to the worklist.
+              eraseInstFromFunction(
+                  *instToDelete, false /*do not add operands to the worklist*/);
+            })
+            .onNotifyWillBeDeleted([&](SILInstruction *instThatWillBeDeleted) {
+              Worklist.addOperandsToWorklist(*instThatWillBeDeleted);
+            })
+            .onCreateNewInst([&](SILInstruction *newlyCreatedInst) {
+              Worklist.add(newlyCreatedInst);
+            })
+            .onSetUseValue([&](Operand *use, SILValue newValue) {
+              use->set(newValue);
+              Worklist.add(use->getUser());
+            });
   }
 
   bool runOnFunction(SILFunction &F);

test/SILOptimizer/sil_combine_apply_ossa.sil

@@ -518,12 +518,10 @@ sil [ossa] @guaranteed_closure : $@convention(thin) (@guaranteed C) -> ()
 // CHECK: bb0([[ARG:%.*]] : @guaranteed $C):
 // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
 // CHECK: [[F:%.*]] = function_ref @guaranteed_closure
-// CHECK: [[ARG_COPY_2:%.*]] = copy_value [[ARG_COPY]]
 // CHECK: [[C:%.*]] = partial_apply [callee_guaranteed] [[F]]([[ARG_COPY]])
-// CHECK: apply [[F]]([[ARG_COPY_2]])
+// CHECK: apply [[F]]([[ARG]])
 // Don't release the closure context -- it is @callee_guaranteed.
 // CHECK-NOT: destroy_value [[C]] : $@callee_guaranteed () -> ()
-// CHECK: destroy_value [[ARG_COPY_2]]
 // CHECK-NOT: destroy_value [[C]] : $@callee_guaranteed () -> ()
 // CHECK: return [[C]]
 // CHECK: } // end sil function 'test_guaranteed_closure'
@@ -942,18 +940,14 @@ bb3:
 // CHECK-LABEL: sil [ossa] @test_apply_of_partial_apply_owned : $@convention(thin) (@in CC1) -> () {
 // CHECK: bb0([[ARG:%.*]] :
 // CHECK:   [[LOAD_ARG:%.*]] = load [take] [[ARG]]
-// CHECK:   [[LOAD_ARG_COPY:%.*]] = copy_value [[LOAD_ARG]]
-// CHECK:   destroy_value [[LOAD_ARG]]
 // CHECK:   cond_br undef, bb1, bb2
 //
 // CHECK: bb1:
-// CHECK:   destroy_value [[LOAD_ARG_COPY]]
+// CHECK:   destroy_value [[LOAD_ARG]]
 // CHECK:   br bb3
 //
 // CHECK: bb2:
-// CHECK:   [[LOAD_ARG_COPY_COPY:%.*]] = copy_value [[LOAD_ARG_COPY]]
-// CHECK:   apply {{%.*}}([[LOAD_ARG_COPY_COPY]]) : $@convention(method) (@owned CC1) -> ()
-// CHECK:   destroy_value [[LOAD_ARG_COPY]]
+// CHECK:   apply {{%.*}}([[LOAD_ARG]]) : $@convention(method) (@owned CC1) -> ()
 // CHECK:   br bb3
 //
 // CHECK: bb3:
@@ -981,17 +975,15 @@ bb3:
 // CHECK-LABEL: sil [ossa] @test_apply_of_partial_apply_guaranteed : $@convention(thin) (@in CC1) -> () {
 // CHECK: bb0([[ARG:%.*]] :
 // CHECK:   [[LOAD_ARG:%.*]] = load [take] [[ARG]]
-// CHECK:   [[LOAD_ARG_COPY:%.*]] = copy_value [[LOAD_ARG]]
-// CHECK:   destroy_value [[LOAD_ARG]]
 // CHECK:   cond_br undef, bb1, bb2
 //
 // CHECK: bb1:
-// CHECK:   destroy_value [[LOAD_ARG_COPY]]
+// CHECK:   destroy_value [[LOAD_ARG]]
 // CHECK:   br bb3
 //
 // CHECK: bb2:
-// CHECK:   apply {{%.*}}([[LOAD_ARG_COPY]]) : $@convention(method) (@guaranteed CC1) -> ()
-// CHECK:   destroy_value [[LOAD_ARG_COPY]]
+// CHECK:   apply {{%.*}}([[LOAD_ARG]]) : $@convention(method) (@guaranteed CC1) -> ()
+// CHECK:   destroy_value [[LOAD_ARG]]
 // CHECK:   br bb3
 //
 // CHECK: bb3: