[ownership] Make OwnershipFixupContext a dump context struct and instead put its RAUW functionality on OwnershipRAUWHelper.

The reason why I am doing this is that I am building up more utilities based on
passing around this struct of context that do not want it for RAUWing
purposes. So it makes sense on a helper (OwnershipRAUWHelper) that composes with
its state.

Just a refactor, should be NFC.

Author: gottesmm

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -19,6 +19,7 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_OWNERSHIPOPTUTILS_H
 #define SWIFT_SILOPTIMIZER_UTILS_OWNERSHIPOPTUTILS_H
 
+#include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
@@ -28,6 +29,9 @@ namespace swift {
 // Defined in BasicBlockUtils.h
 struct JointPostDominanceSetComputer;
 
+/// A struct that contains context shared in between different operation +
+/// "ownership fixup" utilities. Please do not put actual methods on this, it is
+/// meant to be composed with.
 struct OwnershipFixupContext {
   Optional<InstModCallbacks> inlineCallbacks;
   InstModCallbacks &callbacks;
@@ -44,6 +48,20 @@ struct OwnershipFixupContext {
       : inlineCallbacks(InstModCallbacks()), callbacks(*inlineCallbacks),
         deBlocks(deBlocks), jointPostDomSetComputer(inputJPDComputer) {}
 
+  void clear() {
+    jointPostDomSetComputer.clear();
+  }
+};
+
+/// A utility composed ontop of OwnershipFixupContext that knows how to RAUW a
+/// value or a single value instruction with a new value and then fixup
+/// ownership invariants afterwards.
+class OwnershipRAUWHelper {
+  OwnershipFixupContext &ctx;
+
+public:
+  OwnershipRAUWHelper(OwnershipFixupContext &ctx) : ctx(ctx) {}
+
   SILBasicBlock::iterator
   replaceAllUsesAndErase(SingleValueInstruction *oldValue, SILValue newValue);
 

lib/SILOptimizer/Analysis/SimplifyInstruction.cpp

@@ -755,7 +755,8 @@ swift::replaceAllSimplifiedUsesAndErase(SILInstruction *i, SILValue result,
   if (svi->getFunction()->hasOwnership()) {
     JointPostDominanceSetComputer computer(*deadEndBlocks);
     OwnershipFixupContext ctx{callbacks, *deadEndBlocks, computer};
-    return ctx.replaceAllUsesAndErase(svi, result);
+    OwnershipRAUWHelper helper(ctx);
+    return helper.replaceAllUsesAndErase(svi, result);
   }
   return replaceAllUsesAndErase(svi, result, callbacks);
 }
@@ -790,7 +791,7 @@ static SILValue simplifyInstruction(SILInstruction *i) {
   // this code is not updated at this point in time.
   auto *svi = cast<SingleValueInstruction>(i);
   if (svi->getFunction()->hasOwnership())
-    if (!OwnershipFixupContext::canFixUpOwnershipForRAUW(svi, result))
+    if (!OwnershipRAUWHelper::canFixUpOwnershipForRAUW(svi, result))
       return SILValue();
 
   return result;
@@ -813,7 +814,8 @@ SILBasicBlock::iterator swift::simplifyAndReplaceAllSimplifiedUsesAndErase(
   if (svi->getFunction()->hasOwnership()) {
     JointPostDominanceSetComputer computer(*deadEndBlocks);
     OwnershipFixupContext ctx{callbacks, *deadEndBlocks, computer};
-    return ctx.replaceAllUsesAndErase(svi, result);
+    OwnershipRAUWHelper helper(ctx);
+    return helper.replaceAllUsesAndErase(svi, result);
   }
   return replaceAllUsesAndErase(svi, result, callbacks);
 }

lib/SILOptimizer/Transforms/CSE.cpp

@@ -583,17 +583,17 @@ class CSE {
 
   DeadEndBlocks &DeadEndBBs;
 
-  OwnershipFixupContext &FixupCtx;
+  OwnershipRAUWHelper &RAUWHelper;
 
   /// The set of calls to lazy property getters which can be replace by a direct
   /// load of the property value.
   llvm::SmallVector<ApplyInst *, 8> lazyPropertyGetters;
 
   CSE(bool RunsOnHighLevelSil, SideEffectAnalysis *SEA,
       SILOptFunctionBuilder &FuncBuilder, DeadEndBlocks &DeadEndBBs,
-      OwnershipFixupContext &FixupCtx)
+      OwnershipRAUWHelper &RAUWHelper)
       : SEA(SEA), FuncBuilder(FuncBuilder), DeadEndBBs(DeadEndBBs),
-        FixupCtx(FixupCtx), RunsOnHighLevelSil(RunsOnHighLevelSil) {}
+        RAUWHelper(RAUWHelper), RunsOnHighLevelSil(RunsOnHighLevelSil) {}
 
   bool processFunction(SILFunction &F, DominanceInfo *DT);
 
@@ -1017,12 +1017,12 @@ bool CSE::processNode(DominanceInfoNode *Node) {
         // extend it here as well
         if (!isa<SingleValueInstruction>(Inst))
           continue;
-        if (!OwnershipFixupContext::canFixUpOwnershipForRAUW(
+        if (!OwnershipRAUWHelper::canFixUpOwnershipForRAUW(
                 cast<SingleValueInstruction>(Inst),
                 cast<SingleValueInstruction>(AvailInst)))
           continue;
         // Replace SingleValueInstruction using OSSA RAUW here
-        nextI = FixupCtx.replaceAllUsesAndErase(
+        nextI = RAUWHelper.replaceAllUsesAndErase(
             cast<SingleValueInstruction>(Inst),
             cast<SingleValueInstruction>(AvailInst));
         Changed = true;
@@ -1399,7 +1399,8 @@ class SILCSE : public SILFunctionTransform {
     JointPostDominanceSetComputer Computer(DeadEndBBs);
     InstModCallbacks callbacks;
     OwnershipFixupContext FixupCtx{callbacks, DeadEndBBs, Computer};
-    CSE C(RunsOnHighLevelSil, SEA, FuncBuilder, DeadEndBBs, FixupCtx);
+    OwnershipRAUWHelper RAUWHelper(FixupCtx);
+    CSE C(RunsOnHighLevelSil, SEA, FuncBuilder, DeadEndBBs, RAUWHelper);
     bool Changed = false;
 
     // Perform the traditional CSE.

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -644,7 +644,7 @@ SILBasicBlock::iterator OwnershipRAUWUtility::handleGuaranteed() {
 SILBasicBlock::iterator OwnershipRAUWUtility::perform() {
   assert(oldValue->getFunction()->hasOwnership());
   assert(
-      OwnershipFixupContext::canFixUpOwnershipForRAUW(oldValue, newValue) &&
+      OwnershipRAUWHelper::canFixUpOwnershipForRAUW(oldValue, newValue) &&
       "Should have checked if can perform this operation before calling it?!");
   // If our new value is just none, we can pass anything to do it so just RAUW
   // and return.
@@ -689,7 +689,7 @@ SILBasicBlock::iterator OwnershipRAUWUtility::perform() {
 
 // All callers of our RAUW routines must ensure that their values return true
 // from this.
-bool OwnershipFixupContext::canFixUpOwnershipForRAUW(SILValue oldValue,
+bool OwnershipRAUWHelper::canFixUpOwnershipForRAUW(SILValue oldValue,
                                                      SILValue newValue) {
   auto newOwnershipKind = newValue.getOwnershipKind();
 
@@ -741,8 +741,8 @@ bool OwnershipFixupContext::canFixUpOwnershipForRAUW(SILValue oldValue,
 }
 
 SILBasicBlock::iterator
-OwnershipFixupContext::replaceAllUsesAndErase(SingleValueInstruction *oldValue,
+OwnershipRAUWHelper::replaceAllUsesAndErase(SingleValueInstruction *oldValue,
                                               SILValue newValue) {
-  OwnershipRAUWUtility utility{oldValue, newValue, *this};
+  OwnershipRAUWUtility utility{oldValue, newValue, ctx};
   return utility.perform();
 }