SIL: remove the JointPostDominanceSetComputer helper struct.

eeckstein · eeckstein · commit d33ea9f3509d · 2021-02-02T10:20:35.000+01:00
Instead make `findJointPostDominatingSet` a stand-alone function.
There is no need to keep the temporary SmallVector alive across multiple calls of findJointPostDominatingSet for the purpose of re-using malloc'ed memory. The worklist usually contains way less elements than its small size.
diff --git a/include/swift/SIL/BasicBlockUtils.h b/include/swift/SIL/BasicBlockUtils.h
@@ -90,80 +90,49 @@ class DeadEndBlocks {
   const SILFunction *getFunction() const { return f; }
 };
 
-/// A struct that contains the intermediate state used in computing
-/// joint-dominance sets. Enables a pass to easily reuse the same small data
-/// structures with clearing (noting that clearing our internal state does not
-/// cause us to shrink meaning that once we malloc, we keep the malloced
-/// memory).
-struct JointPostDominanceSetComputer {
-  /// The worklist that drives the algorithm.
-  SmallVector<SILBasicBlock *, 32> worklist;
-
-  /// A subset of our initial blocks that we found as a predecessor of another
-  /// block along our walk.
-  SmallVector<SILBasicBlock *, 8> reachableInputBlocks;
-
-  /// As we process the worklist, any successors that we see that have not been
-  /// visited yet are placed in here. At the end of our worklist, any blocks
-  /// that remain here are "leaking blocks" that together with our initial set
-  /// would provide a jointly-postdominating set of our dominating value.
-  SmallVector<SILBasicBlock *, 32> blocksThatLeakIfNeverVisited;
-
-  DeadEndBlocks &deadEndBlocks;
-
-  JointPostDominanceSetComputer(DeadEndBlocks &deadEndBlocks)
-      : deadEndBlocks(deadEndBlocks) {}
-
-  void clear() {
-    worklist.clear();
-    reachableInputBlocks.clear();
-    blocksThatLeakIfNeverVisited.clear();
-  }
-
-  /// Compute joint-postdominating set for \p dominatingBlock and \p
-  /// dominatedBlockSet found by walking up the CFG from the latter to the
-  /// former.
-  ///
-  /// We pass back the following information via callbacks so our callers can
-  /// use whatever container they need to:
-  ///
-  /// * inputBlocksFoundDuringWalk: Any blocks from the "dominated
-  ///   block set" that was found as a predecessor block during our traversal is
-  ///   passed to this callback. These can occur for two reasons:
-  ///
-  ///   1. We actually had a block in \p dominatedBlockSet that was reachable
-  ///      from another block in said set. This is a valid usage of the API
-  ///      since it could be that the user does not care about such uses and
-  ///      leave this callback empty.
-  ///
-  ///   2. We had a block in \p dominatedBlockSet that is in a sub-loop in the
-  ///      loop-nest relative to \p dominatingBlock causing us to go around a
-  ///      backedge and hit the block during our traversal. In this case, we
-  ///      have already during the traversal passed the exiting blocks of the
-  ///      sub-loop as joint postdominace completion set blocks. This is useful
-  ///      if one is using this API for lifetime extension purposes of lifetime
-  ///      ending uses and one needs to insert compensating copy_value at these
-  ///      locations due to the lack of strong control-equivalence in between
-  ///      the block and \p dominatingBlock.
-  ///
-  ///
-  /// * foundJointPostDomSetCompletionBlocks: The set of blocks not in \p
-  ///   dominatedBlockSet that together with \p dominatedBlockSet
-  ///   jointly-postdominate \p dominatedBlock. This is "completing" the joint
-  ///   post-dominance set.
-  ///
-  /// * inputBlocksInJointPostDomSet: Any of our input blocks that were never
-  ///   found as a predecessor is passed to this callback. This block is in the
-  ///   final minimal joint-postdominance set and is passed to this
-  ///   callback. This is optional and we will avoid doing work if it is not
-  ///   set.
-  void findJointPostDominatingSet(
-      SILBasicBlock *dominatingBlock,
-      ArrayRef<SILBasicBlock *> dominatedBlockSet,
-      function_ref<void(SILBasicBlock *)> inputBlocksFoundDuringWalk,
-      function_ref<void(SILBasicBlock *)> foundJointPostDomSetCompletionBlocks,
-      function_ref<void(SILBasicBlock *)> inputBlocksInJointPostDomSet = {});
-};
+/// Compute joint-postdominating set for \p dominatingBlock and \p
+/// dominatedBlockSet found by walking up the CFG from the latter to the
+/// former.
+///
+/// We pass back the following information via callbacks so our callers can
+/// use whatever container they need to:
+///
+/// * inputBlocksFoundDuringWalk: Any blocks from the "dominated
+///   block set" that was found as a predecessor block during our traversal is
+///   passed to this callback. These can occur for two reasons:
+///
+///   1. We actually had a block in \p dominatedBlockSet that was reachable
+///      from another block in said set. This is a valid usage of the API
+///      since it could be that the user does not care about such uses and
+///      leave this callback empty.
+///
+///   2. We had a block in \p dominatedBlockSet that is in a sub-loop in the
+///      loop-nest relative to \p dominatingBlock causing us to go around a
+///      backedge and hit the block during our traversal. In this case, we
+///      have already during the traversal passed the exiting blocks of the
+///      sub-loop as joint postdominace completion set blocks. This is useful
+///      if one is using this API for lifetime extension purposes of lifetime
+///      ending uses and one needs to insert compensating copy_value at these
+///      locations due to the lack of strong control-equivalence in between
+///      the block and \p dominatingBlock.
+///
+///
+/// * foundJointPostDomSetCompletionBlocks: The set of blocks not in \p
+///   dominatedBlockSet that together with \p dominatedBlockSet
+///   jointly-postdominate \p dominatedBlock. This is "completing" the joint
+///   post-dominance set.
+///
+/// * inputBlocksInJointPostDomSet: Any of our input blocks that were never
+///   found as a predecessor is passed to this callback. This block is in the
+///   final minimal joint-postdominance set and is passed to this
+///   callback. This is optional and we will avoid doing work if it is not
+///   set.
+void findJointPostDominatingSet(
+    SILBasicBlock *dominatingBlock,
+    ArrayRef<SILBasicBlock *> dominatedBlockSet,
+    function_ref<void(SILBasicBlock *)> inputBlocksFoundDuringWalk,
+    function_ref<void(SILBasicBlock *)> foundJointPostDomSetCompletionBlocks,
+    function_ref<void(SILBasicBlock *)> inputBlocksInJointPostDomSet = {});
 
 } // namespace swift
 
diff --git a/include/swift/SILOptimizer/Utils/InstOptUtils.h b/include/swift/SILOptimizer/Utils/InstOptUtils.h
@@ -695,15 +695,13 @@ SILBasicBlock::iterator replaceSingleUse(Operand *use, SILValue newValue,
 /// and destroy at leaking blocks to adjust ownership and make available for use
 /// at \p inBlock.
 SILValue
-makeCopiedValueAvailable(SILValue value, SILBasicBlock *inBlock,
-                         JointPostDominanceSetComputer *jointPostDomComputer);
+makeCopiedValueAvailable(SILValue value, SILBasicBlock *inBlock);
 
 /// Given a newly created @owned value \p value without any uses, this utility
 /// inserts control equivalent copy and destroy at leaking blocks to adjust
 /// ownership and make \p value available for use at \p inBlock.
 SILValue
-makeNewValueAvailable(SILValue value, SILBasicBlock *inBlock,
-                      JointPostDominanceSetComputer *jointPostDomComputer);
+makeNewValueAvailable(SILValue value, SILBasicBlock *inBlock);
 
 /// Given a forwarding instruction, eliminate it if all of its users are debug
 /// instructions and ownership uses.
diff --git a/include/swift/SILOptimizer/Utils/LoadStoreOptUtils.h b/include/swift/SILOptimizer/Utils/LoadStoreOptUtils.h
@@ -255,8 +255,7 @@ class LSValue : public LSBase {
   ///
   /// In the case where we have a single value this can be materialized by
   /// applying Path to the Base.
-  SILValue materialize(SILInstruction *Inst,
-                       JointPostDominanceSetComputer *jointPostDomComputer) {
+  SILValue materialize(SILInstruction *Inst) {
     if (CoveringValue)
       return SILValue();
     auto Val = Base;
@@ -269,8 +268,7 @@ class LSValue : public LSBase {
     }
     auto Res = Path.getValue().createExtract(Val, &*InsertPt, true);
     if (Val != Base) {
-      Res = makeCopiedValueAvailable(Res, Inst->getParent(),
-                                     jointPostDomComputer);
+      Res = makeCopiedValueAvailable(Res, Inst->getParent());
       Builder.emitEndBorrowOperation(InsertPt->getLoc(), Val);
       // Insert a destroy on the Base
       SILBuilderWithScope(Inst).emitDestroyValueOperation(Inst->getLoc(), Base);
@@ -296,11 +294,9 @@ class LSValue : public LSBase {
   /// location holds. This may involve extracting and aggregating available
   /// values.
   static void reduceInner(LSLocation &B, SILModule *M, LSLocationValueMap &Vals,
-                          SILInstruction *InsertPt,
-                          JointPostDominanceSetComputer *jointPostDomComputer);
+                          SILInstruction *InsertPt);
   static SILValue reduce(LSLocation &B, SILModule *M, LSLocationValueMap &Vals,
-                         SILInstruction *InsertPt,
-                         JointPostDominanceSetComputer *jointPostDomComputer);
+                         SILInstruction *InsertPt);
 };
 
 static inline llvm::hash_code hash_value(const LSValue &V) {
diff --git a/include/swift/SILOptimizer/Utils/OwnershipOptUtils.h b/include/swift/SILOptimizer/Utils/OwnershipOptUtils.h
@@ -37,7 +37,6 @@ struct OwnershipFixupContext {
   Optional<InstModCallbacks> inlineCallbacks;
   InstModCallbacks &callbacks;
   DeadEndBlocks &deBlocks;
-  JointPostDominanceSetComputer &jointPostDomSetComputer;
 
   SmallVector<Operand *, 8> transitiveBorrowedUses;
   SmallVector<std::pair<SILBasicBlock *, unsigned>, 8> recursiveReborrows;
@@ -64,30 +63,16 @@ struct OwnershipFixupContext {
   };
   AddressFixupContext extraAddressFixupInfo;
 
-  OwnershipFixupContext(InstModCallbacks &callbacks, DeadEndBlocks &deBlocks,
-                        JointPostDominanceSetComputer &jointPostDomSetComputer)
-      : callbacks(callbacks), deBlocks(deBlocks),
-        jointPostDomSetComputer(jointPostDomSetComputer) {}
+  OwnershipFixupContext(InstModCallbacks &callbacks, DeadEndBlocks &deBlocks)
+      : callbacks(callbacks), deBlocks(deBlocks) {}
 
   void clear() {
-    jointPostDomSetComputer.clear();
     transitiveBorrowedUses.clear();
     recursiveReborrows.clear();
     extraAddressFixupInfo.allAddressUsesFromOldValue.clear();
     extraAddressFixupInfo.intPtrOp = InteriorPointerOperand();
   }
 
-  /// Gets access to the joint post dominance computer and clears it after \p
-  /// callback.
-  template <typename ResultTy>
-  ResultTy withJointPostDomComputer(
-      function_ref<ResultTy(JointPostDominanceSetComputer &)> callback) {
-    // Make sure we clear the joint post dom computer after callback.
-    SWIFT_DEFER { jointPostDomSetComputer.clear(); };
-    // Then return callback passing in the computer.
-    return callback(jointPostDomSetComputer);
-  }
-
 private:
   /// Helper method called to determine if we discovered we needed interior
   /// pointer fixups while simplifying.
diff --git a/lib/SIL/Utils/BasicBlockUtils.cpp b/lib/SIL/Utils/BasicBlockUtils.cpp
@@ -398,7 +398,7 @@ static bool endsInUnreachable(SILBasicBlock *block) {
   return isa<UnreachableInst>(block->getTerminator());
 }
 
-void JointPostDominanceSetComputer::findJointPostDominatingSet(
+void swift::findJointPostDominatingSet(
     SILBasicBlock *dominatingBlock, ArrayRef<SILBasicBlock *> dominatedBlockSet,
     function_ref<void(SILBasicBlock *)> inputBlocksFoundDuringWalk,
     function_ref<void(SILBasicBlock *)> foundJointPostDomSetCompletionBlocks,
@@ -418,9 +418,8 @@ void JointPostDominanceSetComputer::findJointPostDominatingSet(
     return;
   }
 
-  // At the top of where we for sure are going to use state... make sure we
-  // always clean up any resources that we use!
-  SWIFT_DEFER { clear(); };
+  /// The worklist that drives the algorithm.
+  SmallVector<SILBasicBlock *, 32> worklist;
 
   /// All blocks visited during the backwards walk of the CFG, but not including
   /// the initial blocks in `dominatedBlockSet`.
diff --git a/lib/SILOptimizer/Analysis/SimplifyInstruction.cpp b/lib/SILOptimizer/Analysis/SimplifyInstruction.cpp
@@ -759,8 +759,7 @@ swift::replaceAllSimplifiedUsesAndErase(SILInstruction *i, SILValue result,
   assert(svi != result && "Cannot RAUW a value with itself");
 
   if (svi->getFunction()->hasOwnership()) {
-    JointPostDominanceSetComputer computer(*deadEndBlocks);
-    OwnershipFixupContext ctx{callbacks, *deadEndBlocks, computer};
+    OwnershipFixupContext ctx{callbacks, *deadEndBlocks};
     OwnershipRAUWHelper helper(ctx, svi, result);
     return helper.perform();
   }
@@ -812,8 +811,7 @@ SILBasicBlock::iterator swift::simplifyAndReplaceAllSimplifiedUsesAndErase(
   if (!deadEndBlocks)
     return next;
 
-  JointPostDominanceSetComputer computer(*deadEndBlocks);
-  OwnershipFixupContext ctx{callbacks, *deadEndBlocks, computer};
+  OwnershipFixupContext ctx{callbacks, *deadEndBlocks};
   OwnershipRAUWHelper helper(ctx, svi, result);
 
   // If our RAUW helper is invalid, we do not support RAUWing this case, so
diff --git a/lib/SILOptimizer/SILCombiner/SILCombiner.h b/lib/SILOptimizer/SILCombiner/SILCombiner.h
@@ -93,10 +93,6 @@ class SILCombiner :
   /// edges so it is safe to use this here.
   DeadEndBlocks deBlocks;
 
-  /// A utility struct used by OwnershipFixupContext to map sets of partially
-  /// post-dominating blocks to a full jointly post-dominating set.
-  JointPostDominanceSetComputer jPostDomComputer;
-
   /// External context struct used by \see ownershipRAUWHelper.
   OwnershipFixupContext ownershipFixupContext;
 
@@ -131,8 +127,8 @@ class SILCombiner :
               use->set(newValue);
               Worklist.add(use->getUser());
             }),
-        deBlocks(&B.getFunction()), jPostDomComputer(deBlocks),
-        ownershipFixupContext(instModCallbacks, deBlocks, jPostDomComputer) {}
+        deBlocks(&B.getFunction()),
+        ownershipFixupContext(instModCallbacks, deBlocks) {}
 
   bool runOnFunction(SILFunction &F);
 
@@ -438,17 +434,6 @@ class SILCombiner :
   bool hasOwnership() const {
     return Builder.hasOwnership();
   }
-
-  /// Gets access to the joint post dominance computer and clears it after \p
-  /// callback.
-  template <typename ResultTy>
-  ResultTy withJointPostDomComputer(
-      function_ref<ResultTy(JointPostDominanceSetComputer &)> callback) {
-    // Make sure we clear the joint post dom computer after callback.
-    SWIFT_DEFER { jPostDomComputer.clear(); };
-    // Then return callback passing in the computer.
-    return callback(jPostDomComputer);
-  }
 };
 
 } // end namespace swift
diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp
@@ -1062,10 +1062,8 @@ SILCombiner::visitConvertFunctionInst(ConvertFunctionInst *cfi) {
         continue;
       SmallVector<SILValue, 4> args(pa->getArguments().begin(),
                                     pa->getArguments().end());
-      auto newValue = withJointPostDomComputer<SILValue>([&](auto &j) {
-        return makeCopiedValueAvailable(cfi->getConverted(), pa->getParent(),
-                                        &j);
-      });
+      auto newValue = makeCopiedValueAvailable(cfi->getConverted(),
+                                               pa->getParent());
 
       SILBuilderWithScope localBuilder(std::next(pa->getIterator()), Builder);
       auto *newPA = localBuilder.createPartialApply(
diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp
@@ -1963,12 +1963,11 @@ SILInstruction *SILCombiner::visitCondBranchInst(CondBranchInst *CBI) {
     }
 
     SILValue selectEnumOperand = SEI->getEnumOperand();
-    auto switchEnumOperand = withJointPostDomComputer<SILValue>([&](auto &j) {
-      if (selectEnumOperand.getOwnershipKind() == OwnershipKind::None)
-        return selectEnumOperand;
-      return makeCopiedValueAvailable(selectEnumOperand,
-                                      Builder.getInsertionBB(), &j);
-    });
+    SILValue switchEnumOperand = selectEnumOperand;
+    if (selectEnumOperand.getOwnershipKind() != OwnershipKind::None) {
+      switchEnumOperand = makeCopiedValueAvailable(selectEnumOperand,
+                                                   Builder.getInsertionBB());
+    }
     return Builder.createSwitchEnum(SEI->getLoc(), switchEnumOperand, DefaultBB,
                                     Cases);
   }
diff --git a/lib/SILOptimizer/Transforms/CSE.cpp b/lib/SILOptimizer/Transforms/CSE.cpp
@@ -1397,9 +1397,8 @@ class SILCSE : public SILFunctionTransform {
 
     auto *Fn = getFunction();
     DeadEndBlocks DeadEndBBs(Fn);
-    JointPostDominanceSetComputer Computer(DeadEndBBs);
     InstModCallbacks callbacks;
-    OwnershipFixupContext FixupCtx{callbacks, DeadEndBBs, Computer};
+    OwnershipFixupContext FixupCtx{callbacks, DeadEndBBs};
     CSE C(RunsOnHighLevelSil, SEA, FuncBuilder, DeadEndBBs, FixupCtx);
     bool Changed = false;
 
diff --git a/lib/SILOptimizer/Transforms/RedundantLoadElimination.cpp b/lib/SILOptimizer/Transforms/RedundantLoadElimination.cpp
diff --git a/lib/SILOptimizer/Utils/InstOptUtils.cpp b/lib/SILOptimizer/Utils/InstOptUtils.cpp
diff --git a/lib/SILOptimizer/Utils/LoadStoreOptUtils.cpp b/lib/SILOptimizer/Utils/LoadStoreOptUtils.cpp
diff --git a/lib/SILOptimizer/Utils/OwnershipOptUtils.cpp b/lib/SILOptimizer/Utils/OwnershipOptUtils.cpp
