[SILOptimizer] SILCombine uses shared worklist.

In the previous commit, SILInstructionWorklist was added as a verbatim
extraction (modulo some minor style tweaks) of SILCombineWorklist.
Here, SILCombine is moved over to using that renamed type.

Author: nate-chandler

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -102,7 +102,7 @@ void SILCombiner::addReachableCodeToWorklist(SILBasicBlock *BB) {
 }
 
 static void eraseSingleInstFromFunction(SILInstruction &I,
-                                        SILCombineWorklist &Worklist,
+                                        SILInstructionWorklist &Worklist,
                                         bool AddOperandsToWorklist) {
   LLVM_DEBUG(llvm::dbgs() << "SC: ERASE " << I << '\n');
 
@@ -127,21 +127,13 @@ static void eraseSingleInstFromFunction(SILInstruction &I,
 //                               Implementation
 //===----------------------------------------------------------------------===//
 
-void SILCombineWorklist::add(SILInstruction *I) {
-  if (!WorklistMap.insert(std::make_pair(I, Worklist.size())).second)
-    return;
-
-  LLVM_DEBUG(llvm::dbgs() << "SC: ADD: " << *I << '\n');
-  Worklist.push_back(I);
-}
-
 // Define a CanonicalizeInstruction subclass for use in SILCombine.
 class SILCombineCanonicalize final : CanonicalizeInstruction {
-  SILCombineWorklist &Worklist;
+  SILInstructionWorklist &Worklist;
   bool changed = false;
 
 public:
-  SILCombineCanonicalize(SILCombineWorklist &Worklist)
+  SILCombineCanonicalize(SILInstructionWorklist &Worklist)
       : CanonicalizeInstruction(DEBUG_TYPE), Worklist(Worklist) {}
 
   void notifyNewInstruction(SILInstruction *inst) override {
@@ -270,20 +262,6 @@ bool SILCombiner::doOneIteration(SILFunction &F, unsigned Iteration) {
   return MadeChange;
 }
 
-void SILCombineWorklist::addInitialGroup(ArrayRef<SILInstruction *> List) {
-  assert(Worklist.empty() && "Worklist must be empty to add initial group");
-  Worklist.reserve(List.size()+16);
-  WorklistMap.reserve(List.size());
-  LLVM_DEBUG(llvm::dbgs() << "SC: ADDING: " << List.size()
-                          << " instrs to worklist\n");
-  while (!List.empty()) {
-    SILInstruction *I = List.back();
-    List = List.slice(0, List.size()-1);    
-    WorklistMap.insert(std::make_pair(I, Worklist.size()));
-    Worklist.push_back(I);
-    }
-}
-
 bool SILCombiner::runOnFunction(SILFunction &F) {
   clear();
 

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -23,6 +23,7 @@
 
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILInstructionWorklist.h"
 #include "swift/SIL/SILValue.h"
 #include "swift/SIL/SILVisitor.h"
 #include "swift/SILOptimizer/Analysis/ClassHierarchyAnalysis.h"
@@ -37,84 +38,6 @@ namespace swift {
 
 class AliasAnalysis;
 
-/// This is the worklist management logic for SILCombine.
-class SILCombineWorklist {
-  llvm::SmallVector<SILInstruction *, 256> Worklist;
-  llvm::DenseMap<SILInstruction *, unsigned> WorklistMap;
-
-  void operator=(const SILCombineWorklist &RHS) = delete;
-  SILCombineWorklist(const SILCombineWorklist &Worklist) = delete;
-public:
-  SILCombineWorklist() {}
-
-  /// Returns true if the worklist is empty.
-  bool isEmpty() const { return Worklist.empty(); }
-
-  /// Add the specified instruction to the worklist if it isn't already in it.
-  void add(SILInstruction *I);
-
-  /// If the given ValueBase is a SILInstruction add it to the worklist.
-  void addValue(ValueBase *V) {
-    if (auto *I = V->getDefiningInstruction())
-      add(I);
-  }
-
-  /// Add the given list of instructions in reverse order to the worklist. This
-  /// routine assumes that the worklist is empty and the given list has no
-  /// duplicates.
-  void addInitialGroup(ArrayRef<SILInstruction *> List);
-
-  // If I is in the worklist, remove it.
-  void remove(SILInstruction *I) {
-    auto It = WorklistMap.find(I);
-    if (It == WorklistMap.end())
-      return; // Not in worklist.
-
-    // Don't bother moving everything down, just null out the slot. We will
-    // check before we process any instruction if it is null.
-    Worklist[It->second] = nullptr;
-    WorklistMap.erase(It);
-  }
-
-  /// Remove the top element from the worklist.
-  SILInstruction *removeOne() {
-    SILInstruction *I = Worklist.pop_back_val();
-    WorklistMap.erase(I);
-    return I;
-  }
-
-  /// When an instruction has been simplified, add all of its users to the
-  /// worklist, since additional simplifications of its users may have been
-  /// exposed.
-  void addUsersToWorklist(ValueBase *I) {
-    for (auto UI : I->getUses())
-      add(UI->getUser());
-  }
-
-  void addUsersToWorklist(SILValue value) {
-    for (auto *use : value->getUses())
-      add(use->getUser());
-  }
-
-  /// When an instruction has been simplified, add all of its users to the
-  /// worklist, since additional simplifications of its users may have been
-  /// exposed.
-  void addUsersOfAllResultsToWorklist(SILInstruction *I) {
-    for (auto result : I->getResults()) {
-      addUsersToWorklist(result);
-    }
-  }
-
-  /// Check that the worklist is empty and nuke the backing store for the map if
-  /// it is large.
-  void zap() {
-    assert(WorklistMap.empty() && "Worklist empty, but the map is not?");
-
-    // Do an explicit clear, this shrinks the map if needed.
-    WorklistMap.clear();
-  }
-};
-
 /// This is a class which maintains the state of the combiner and simplifies
 /// many operations such as removing/adding instructions and syncing them with
 /// the worklist.
@@ -134,7 +57,7 @@ class SILCombiner :
   ClassHierarchyAnalysis *CHA;
 
   /// Worklist containing all of the instructions primed for simplification.
-  SILCombineWorklist Worklist;
+  SILInstructionWorklist Worklist;
 
   /// Variable to track if the SILCombiner made any changes.
   bool MadeChange;
@@ -156,7 +79,7 @@ class SILCombiner :
               AliasAnalysis *AA, DominanceAnalysis *DA,
               ProtocolConformanceAnalysis *PCA, ClassHierarchyAnalysis *CHA,
               bool removeCondFails)
-      : AA(AA), DA(DA), PCA(PCA), CHA(CHA), Worklist(), MadeChange(false),
+      : AA(AA), DA(DA), PCA(PCA), CHA(CHA), Worklist("SC"), MadeChange(false),
         RemoveCondFails(removeCondFails), Iteration(0), Builder(B),
         CastOpt(FuncBuilder, nullptr /*SILBuilderContext*/,
                 /* ReplaceValueUsesAction */