SILOptimizer: Use BasicBlockData in the StackNesting utility

Author: eeckstein

include/swift/SILOptimizer/Utils/StackNesting.h

@@ -13,11 +13,10 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_STACKNESTING_H
 #define SWIFT_SILOPTIMIZER_UTILS_STACKNESTING_H
 
-#include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILFunction.h"
+#include "swift/SIL/BasicBlockData.h"
 #include "llvm/ADT/SmallBitVector.h"
 
-#include <vector>
-
 namespace swift {
 
 /// A utility to correct the nesting of stack allocating/deallocating
@@ -48,17 +47,25 @@ namespace swift {
 ///
 class StackNesting {
 
-  typedef SmallBitVector BitVector;
+public:
 
-  /// Data stored for each block (actually for each block which is not dead).
-  struct BlockInfo {
+  /// The possible return values of fixNesting().
+  enum class Changes {
+    /// No changes are made.
+    None,
 
-    /// Back-link to the block.
-    SILBasicBlock *Block;
+    /// Only instructions were inserted or deleted.
+    Instructions,
 
-    /// The cached list of successors.
-    llvm::SmallVector<BlockInfo *, 8> Successors;
+    /// Instructions were inserted or deleted and new blocks were inserted.
+    CFG
+  };
+
+private:
+  typedef SmallBitVector BitVector;
 
+  /// Data stored for each block (actually for each block which is not dead).
+  struct BlockInfo {
     /// The list of stack allocating/deallocating instructions in the block.
     llvm::SmallVector<SILInstruction *, 8> StackInsts;
 
@@ -68,7 +75,8 @@ class StackNesting {
     /// The bit-set of alive stack locations at the block exit.
     BitVector AliveStackLocsAtExit;
 
-    BlockInfo(SILBasicBlock *Block) : Block(Block) { }
+    /// Used in the setup function to walk over the CFG.
+    bool visited = false;
   };
 
   /// Data stored for each stack location (= allocation).
@@ -93,46 +101,35 @@ class StackNesting {
   /// number in the bit-sets.
   llvm::SmallVector<StackLoc, 8> StackLocs;
 
-  /// Block data for all (non-dead) blocks.
-  std::vector<BlockInfo> BlockInfos;
+  BasicBlockData<BlockInfo> BlockInfos;
 
-public:
-
-  /// The possible return values of correctStackNesting().
-  enum class Changes {
-    /// No changes are made.
-    None,
-
-    /// Only instructions were inserted or deleted.
-    Instructions,
-
-    /// Instructions were inserted or deleted and new blocks were inserted.
-    CFG
-  };
-
-  StackNesting() { }
+  StackNesting(SILFunction *F) : BlockInfos(F) { }
 
   /// Performs correction of stack nesting by moving stack-deallocation
   /// instructions down the control flow.
   ///
   /// Returns the status of what changes were made.
-  Changes correctStackNesting(SILFunction *F);
+  Changes run();
 
   /// For debug dumping.
   void dump() const;
 
   static void dumpBits(const BitVector &Bits);
 
-private:
   /// Initializes the data structures.
-  void setup(SILFunction *F);
+  void setup();
 
   /// Solves the dataflow problem.
   ///
   /// Returns true if there is a nesting of locations in any way, which can
   /// potentially in the wrong order.
   bool solve();
 
+  bool analyze() {
+    setup();
+    return solve();
+  }
+
   /// Insert deallocation instructions for all locations which are alive before
   /// the InsertionPoint (AliveBefore) but not alive after the InsertionPoint
   /// (AliveAfter).
@@ -161,7 +158,15 @@ class StackNesting {
   /// Modifies the SIL to end up with a correct stack nesting.
   ///
   /// Returns the status of what changes were made.
-  bool adaptDeallocs();
+  Changes adaptDeallocs();
+
+public:
+
+  /// Performs correction of stack nesting by moving stack-deallocation
+  /// instructions down the control flow.
+  ///
+  /// Returns the status of what changes were made.
+  static Changes fixNesting(SILFunction *F);
 };
 
 } // end namespace swift

lib/SILOptimizer/IPO/ClosureSpecializer.cpp

@@ -927,7 +927,7 @@ void ClosureSpecCloner::populateCloned() {
     }
   }
   if (invalidatedStackNesting) {
-    StackNesting().correctStackNesting(Cloned);
+    StackNesting::fixNesting(Cloned);
   }
 }
 
@@ -992,7 +992,7 @@ void SILClosureSpecializerTransform::run() {
     }
 
     if (invalidatedStackNesting) {
-      StackNesting().correctStackNesting(F);
+      StackNesting::fixNesting(F);
     }
   }
 

lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp

@@ -1003,9 +1003,8 @@ class ClosureLifetimeFixup : public SILFunctionTransform {
 
     if (fixupClosureLifetimes(*getFunction(), checkStackNesting, modifiedCFG)) {
       if (checkStackNesting){
-        StackNesting sn;
         modifiedCFG |=
-            sn.correctStackNesting(getFunction()) == StackNesting::Changes::CFG;
+          StackNesting::fixNesting(getFunction()) == StackNesting::Changes::CFG;
       }
       if (modifiedCFG)
         invalidateAnalysis(SILAnalysis::InvalidationKind::FunctionBody);

lib/SILOptimizer/Mandatory/MandatoryCombine.cpp

@@ -180,7 +180,7 @@ class MandatoryCombiner final
     }
 
     if (invalidatedStackNesting) {
-      StackNesting().correctStackNesting(&function);
+      StackNesting::fixNesting(&function);
     }
 
     return changed;

lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -1000,7 +1000,7 @@ runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder, SILFunction *F,
   }
 
   if (invalidatedStackNesting) {
-    StackNesting().correctStackNesting(F);
+    StackNesting::fixNesting(F);
     changedFunctions.insert(F);
   }
 

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -322,7 +322,7 @@ bool SILCombiner::runOnFunction(SILFunction &F) {
   }
 
   if (invalidatedStackNesting) {
-    StackNesting().correctStackNesting(&F);
+    StackNesting::fixNesting(&F);
   }
 
   // Cleanup the builder and return whether or not we made any changes.

lib/SILOptimizer/Transforms/AllocBoxToStack.cpp

@@ -1095,8 +1095,7 @@ class AllocBoxToStack : public SILFunctionTransform {
       auto Count = rewritePromotedBoxes(pass);
       NumStackPromoted += Count;
       if (Count) {
-        StackNesting SN;
-        if (SN.correctStackNesting(getFunction()) == StackNesting::Changes::CFG)
+        if (StackNesting::fixNesting(getFunction()) == StackNesting::Changes::CFG)
           pass.CFGChanged = true;
       }
 

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -987,7 +987,7 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller) {
   mergeBasicBlocks(Caller);
 
   if (invalidatedStackNesting) {
-    StackNesting().correctStackNesting(Caller);
+    StackNesting::fixNesting(Caller);
   }
 
   // If we were asked to verify our caller after inlining all callees we could

lib/SILOptimizer/Transforms/StackPromotion.cpp

@@ -73,8 +73,7 @@ void StackPromotion::run() {
     return;
 
   // Make sure that all stack allocating instructions are nested correctly.
-  StackNesting SN;
-  if (SN.correctStackNesting(F) == StackNesting::Changes::CFG) {
+  if (StackNesting::fixNesting(F) == StackNesting::Changes::CFG) {
     invalidateAnalysis(SILAnalysis::InvalidationKind::BranchesAndInstructions);
   } else {
     invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);