SILCombine: some refactoring

NFC

Author: eeckstein

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -161,6 +161,57 @@ class SILCombineCanonicalize final : CanonicalizeInstruction {
   }
 };
 
+SILCombiner::SILCombiner(SILFunctionTransform *trans,
+                         bool removeCondFails, bool enableCopyPropagation) :
+  parentTransform(trans),
+  AA(trans->getPassManager()->getAnalysis<AliasAnalysis>(trans->getFunction())),
+  DA(trans->getPassManager()->getAnalysis<DominanceAnalysis>()),
+  PCA(trans->getPassManager()->getAnalysis<ProtocolConformanceAnalysis>()),
+  CHA(trans->getPassManager()->getAnalysis<ClassHierarchyAnalysis>()),
+  NLABA(trans->getPassManager()->getAnalysis<NonLocalAccessBlockAnalysis>()),
+  Worklist("SC"),
+  deleter(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 /* don't add operands */);
+              })
+              .onNotifyWillBeDeleted(
+                  [&](SILInstruction *instThatWillBeDeleted) {
+                    Worklist.addOperandsToWorklist(
+                      *instThatWillBeDeleted);
+                  })
+              .onCreateNewInst([&](SILInstruction *newlyCreatedInst) {
+                Worklist.add(newlyCreatedInst);
+              })
+              .onSetUseValue([&](Operand *use, SILValue newValue) {
+                use->set(newValue);
+                Worklist.add(use->getUser());
+              })),
+  deadEndBlocks(trans->getFunction()), MadeChange(false),
+  RemoveCondFails(removeCondFails),
+  enableCopyPropagation(enableCopyPropagation), Iteration(0),
+  Builder(*trans->getFunction(), &TrackingList),
+  FuncBuilder(*trans),
+  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); }),
+  deBlocks(trans->getFunction()),
+  ownershipFixupContext(getInstModCallbacks(), deBlocks),
+  swiftPassInvocation(trans->getPassManager(),
+                      trans->getFunction(), this) {}
+
 bool SILCombiner::trySinkOwnedForwardingInst(SingleValueInstruction *svi) {
   if (auto *consumingUse = svi->getSingleConsumingUse()) {
     auto *consumingUser = consumingUse->getUser();
@@ -455,7 +506,7 @@ bool SILCombiner::runOnFunction(SILFunction &F) {
     StackNesting::fixNesting(&F);
   }
 
-  // Cleanup the builder and return whether or not we made any changes.
+  assert(TrackingList.empty() && "TrackingList should be fully processed");
   return Changed;
 }
 
@@ -532,33 +583,18 @@ namespace {
 
 class SILCombine : public SILFunctionTransform {
 
-  llvm::SmallVector<SILInstruction *, 64> TrackingList;
-  
   /// The entry point to the transformation.
   void run() override {
-    auto *AA = PM->getAnalysis<AliasAnalysis>(getFunction());
-    auto *DA = PM->getAnalysis<DominanceAnalysis>();
-    auto *PCA = PM->getAnalysis<ProtocolConformanceAnalysis>();
-    auto *CHA = PM->getAnalysis<ClassHierarchyAnalysis>();
-    auto *NLABA = PM->getAnalysis<NonLocalAccessBlockAnalysis>();
-
     bool enableCopyPropagation =
         getOptions().CopyPropagation == CopyPropagationOption::On;
     if (getOptions().EnableOSSAModules) {
       enableCopyPropagation =
           getOptions().CopyPropagation != CopyPropagationOption::Off;
     }
 
-    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(this, FuncBuilder, B, AA, DA, PCA, CHA, NLABA,
-                         getOptions().RemoveRuntimeAsserts,
+    SILCombiner Combiner(this, getOptions().RemoveRuntimeAsserts,
                          enableCopyPropagation);
     bool Changed = Combiner.runOnFunction(*getFunction());
-    assert(TrackingList.empty() &&
-           "TrackingList should be fully processed by SILCombiner");
 
     if (Changed) {
       // Invalidate everything.

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -96,8 +96,14 @@ class SILCombiner :
   /// The current iteration of the SILCombine.
   unsigned Iteration;
 
+  // The tracking list is used by `Builder` for newly added
+  // instructions, which we will periodically move to our worklist.
+  llvm::SmallVector<SILInstruction *, 64> TrackingList;
+  
   /// Builder used to insert instructions.
-  SILBuilder &Builder;
+  SILBuilder Builder;
+
+  SILOptFunctionBuilder FuncBuilder;
 
   /// Cast optimizer
   CastOptimizer CastOpt;
@@ -114,52 +120,7 @@ class SILCombiner :
 
 public:
   SILCombiner(SILFunctionTransform *parentTransform,
-              SILOptFunctionBuilder &FuncBuilder, SILBuilder &B,
-              AliasAnalysis *AA, DominanceAnalysis *DA,
-              ProtocolConformanceAnalysis *PCA, ClassHierarchyAnalysis *CHA,
-              NonLocalAccessBlockAnalysis *NLABA, bool removeCondFails,
-              bool enableCopyPropagation)
-      : parentTransform(parentTransform), AA(AA), DA(DA), PCA(PCA), CHA(CHA),
-        NLABA(NLABA), Worklist("SC"),
-        deleter(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 /* don't add operands */);
-                    })
-                    .onNotifyWillBeDeleted(
-                        [&](SILInstruction *instThatWillBeDeleted) {
-                          Worklist.addOperandsToWorklist(
-                            *instThatWillBeDeleted);
-                        })
-                    .onCreateNewInst([&](SILInstruction *newlyCreatedInst) {
-                      Worklist.add(newlyCreatedInst);
-                    })
-                    .onSetUseValue([&](Operand *use, SILValue newValue) {
-                      use->set(newValue);
-                      Worklist.add(use->getUser());
-                    })),
-        deadEndBlocks(&B.getFunction()), MadeChange(false),
-        RemoveCondFails(removeCondFails),
-        enableCopyPropagation(enableCopyPropagation), 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); }),
-        deBlocks(&B.getFunction()),
-        ownershipFixupContext(getInstModCallbacks(), deBlocks),
-        swiftPassInvocation(parentTransform->getPassManager(),
-                               parentTransform->getFunction(), this) {}
+              bool removeCondFails, bool enableCopyPropagation);
 
   bool runOnFunction(SILFunction &F);