Add an OptimizedMandatoryCombine pass variant.

It's against the principles of pass design to check the driver mode
within the pass. A pass always needs to do the same thing regardless
of where it runs in the pass pipeline. It also needs to be possible to
test passes in isolation.

Author: atrick

include/swift/SILOptimizer/PassManager/Passes.def

@@ -357,6 +357,8 @@ PASS(ForEachLoopUnroll, "for-each-loop-unroll",
      "Unroll forEach loops over array literals")
 PASS(MandatoryCombine, "mandatory-combine",
     "Perform mandatory peephole combines")
+PASS(OptimizedMandatoryCombine, "optimized-mandatory-combine",
+    "Perform -O level mandatory peephole combines")
 PASS(BugReducerTester, "bug-reducer-tester",
      "sil-bug-reducer Tool Testing by Asserting on a Sentinel Function")
 PASS(OptRemarkGenerator, "sil-opt-remark-generator",

lib/SILOptimizer/Mandatory/MandatoryCombine.cpp

@@ -114,6 +114,8 @@ namespace {
 class MandatoryCombiner final
     : public SILInstructionVisitor<MandatoryCombiner, SILInstruction *> {
 
+  bool compilingWithOptimization;
+
   using Worklist = SmallSILInstructionWorklist<256>;
 
   /// The list of instructions remaining to visit, perhaps to combine.
@@ -135,9 +137,11 @@ class MandatoryCombiner final
   DeadEndBlocks &deadEndBlocks;
 
 public:
-  MandatoryCombiner(SmallVectorImpl<SILInstruction *> &createdInstructions,
+  MandatoryCombiner(bool optimized,
+                    SmallVectorImpl<SILInstruction *> &createdInstructions,
                     DeadEndBlocks &deadEndBlocks)
-      : worklist("MC"), madeChange(false), iteration(0),
+      : compilingWithOptimization(optimized), worklist("MC"), madeChange(false),
+        iteration(0),
         instModCallbacks(
             [&](SILInstruction *instruction) {
               worklist.erase(instruction);
@@ -210,8 +214,6 @@ void MandatoryCombiner::addReachableCodeToWorklist(SILFunction &function) {
     blockAlreadyAddedToWorklist.insert(firstBlock);
   }
 
-  bool compilingWithOptimization = function.getEffectiveOptimizationMode() !=
-                                   OptimizationMode::NoOptimization;
   while (!blockWorklist.empty()) {
     auto *block = blockWorklist.pop_back_val();
 
@@ -249,9 +251,6 @@ bool MandatoryCombiner::doOneIteration(SILFunction &function,
   addReachableCodeToWorklist(function);
   MandatoryCombineCanonicalize mcCanonicialize(worklist, deadEndBlocks);
 
-  bool compilingWithOptimization = function.getEffectiveOptimizationMode() !=
-                                   OptimizationMode::NoOptimization;
-
   while (!worklist.isEmpty()) {
     auto *instruction = worklist.pop_back_val();
     if (instruction == nullptr) {
@@ -383,9 +382,12 @@ SILInstruction *MandatoryCombiner::visitApplyInst(ApplyInst *instruction) {
 namespace {
 
 class MandatoryCombine final : public SILFunctionTransform {
-
+  bool optimized;
   SmallVector<SILInstruction *, 64> createdInstructions;
 
+public:
+  MandatoryCombine(bool optimized) : optimized(optimized) {}
+
   void run() override {
     auto *function = getFunction();
 
@@ -396,14 +398,15 @@ class MandatoryCombine final : public SILFunctionTransform {
     }
 
     DeadEndBlocks deadEndBlocks(function);
-    MandatoryCombiner combiner(createdInstructions, deadEndBlocks);
+    MandatoryCombiner combiner(optimized, createdInstructions, deadEndBlocks);
     bool madeChange = combiner.runOnFunction(*function);
 
     if (madeChange) {
       invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
     }
   }
 
+protected:
   void handleDeleteNotification(SILNode *node) override {
     // Remove instructions that were both created and deleted from the list of
     // created instructions which will eventually be added to the worklist.
@@ -426,4 +429,10 @@ class MandatoryCombine final : public SILFunctionTransform {
 
 } // end anonymous namespace
 
-SILTransform *swift::createMandatoryCombine() { return new MandatoryCombine(); }
+SILTransform *swift::createMandatoryCombine() {
+  return new MandatoryCombine(/*optimized*/ false);
+}
+
+SILTransform *swift::createOptimizedMandatoryCombine() {
+  return new MandatoryCombine(/*optimized*/ true);
+}

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -433,7 +433,7 @@ static void addPrepareOptimizationsPipeline(SILPassPipelinePlan &P) {
 #endif
 
   P.addForEachLoopUnroll();
-  P.addMandatoryCombine();
+  P.addOptimizedMandatoryCombine();
   P.addAccessMarkerElimination();
 }
 

test/SILOptimizer/ossa_rauw_tests.sil

@@ -1,4 +1,4 @@
-// RUN: %target-sil-opt -enable-sil-verify-all -mandatory-combine -sil-mandatory-combine-enable-canon-and-simple-dce -semantic-arc-opts %s | %FileCheck %s
+// RUN: %target-sil-opt -enable-sil-verify-all -optimized-mandatory-combine -sil-mandatory-combine-enable-canon-and-simple-dce -semantic-arc-opts %s | %FileCheck %s
 
 // Make sure that we can perform all of these RAUW without producing ARC traffic
 // that semantic arc opts can't eliminate.