[semantic-arc] Expand out the infrastructure for disabling/enabling specific opts and use that to add new split up semantic-arc tests.

This split will ensure we are testing only what a specific optimization is doing
rather than all together.

NOTE: The way I split up the tests is I first split up each of the tests by
subject area by hand that I thought were specifically testing one pass. Then any
tests where the FileCheck tests started to fail due to us not running the other
passes, I put back a copy in the original semantic-arc-opts.sil to ensure we do
not regress.

Note, the tests that I copied for each of these passes
are originally from semantic-arc-opts.sil. I left them there as well so we could
see all of the opts together. I also only copied the ones that were testing pass
specific functionality.

Author: gottesmm

lib/SILOptimizer/SemanticARC/BorrowScopeOpts.cpp

@@ -18,12 +18,17 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "Context.h"
 #include "SemanticARCOptVisitor.h"
 
 using namespace swift;
 using namespace swift::semanticarc;
 
 bool SemanticARCOptVisitor::visitBeginBorrowInst(BeginBorrowInst *bbi) {
+  // Quickly check if we are supposed to perform this transformation.
+  if (!ctx.shouldPerform(ARCTransformKind::RedundantBorrowScopeElimPeephole))
+    return false;
+
   auto kind = bbi->getOperand().getOwnershipKind();
   SmallVector<EndBorrowInst *, 16> endBorrows;
   for (auto *op : bbi->getUses()) {

lib/SILOptimizer/SemanticARC/Context.h

@@ -14,6 +14,7 @@
 #define SWIFT_SILOPTIMIZER_SEMANTICARC_CONTEXT_H
 
 #include "OwnershipLiveRange.h"
+#include "SemanticARCOpts.h"
 
 #include "swift/Basic/BlotSetVector.h"
 #include "swift/Basic/FrozenMultiMap.h"
@@ -30,6 +31,7 @@ namespace semanticarc {
 
 struct LLVM_LIBRARY_VISIBILITY Context {
   SILFunction &fn;
+  ARCTransformKind transformKind = ARCTransformKind::All;
   Optional<DeadEndBlocks> deadEndBlocks;
   ValueLifetimeAnalysis::Frontier lifetimeFrontier;
   SmallMultiMapCache<SILValue, Operand *> addressToExhaustiveWriteListCache;
@@ -91,6 +93,25 @@ struct LLVM_LIBRARY_VISIBILITY Context {
 
   void verify() const;
 
+  bool shouldPerform(ARCTransformKind testKind) const {
+    // When asserts are enabled, we allow for specific arc transforms to be
+    // turned on/off via LLVM args. So check that if we have asserts, perform
+    // all optimizations otherwise.
+#ifndef NDEBUG
+    if (transformKind == ARCTransformKind::Invalid)
+      return false;
+    return bool(testKind & transformKind);
+#else
+    return true;
+#endif
+  }
+
+  void reset() {
+    lifetimeFrontier.clear();
+    addressToExhaustiveWriteListCache.clear();
+    joinedOwnedIntroducerToConsumedOperands.reset();
+  }
+
 private:
   static bool
   constructCacheValue(SILValue initialValue,

lib/SILOptimizer/SemanticARC/CopyValueOpts.cpp

@@ -517,22 +517,26 @@ bool SemanticARCOptVisitor::tryPerformOwnedCopyValueOptimization(
 bool SemanticARCOptVisitor::visitCopyValueInst(CopyValueInst *cvi) {
   // If our copy value inst has only destroy_value users, it is a dead live
   // range. Try to eliminate them.
-  if (eliminateDeadLiveRangeCopyValue(cvi)) {
+  if (ctx.shouldPerform(ARCTransformKind::RedundantCopyValueElimPeephole) &&
+      eliminateDeadLiveRangeCopyValue(cvi)) {
     return true;
   }
 
   // Then see if copy_value operand's lifetime ends after our copy_value via a
   // destroy_value. If so, we can join their lifetimes.
-  if (tryJoiningCopyValueLiveRangeWithOperand(cvi)) {
+  if (ctx.shouldPerform(ARCTransformKind::LifetimeJoiningPeephole) &&
+      tryJoiningCopyValueLiveRangeWithOperand(cvi)) {
     return true;
   }
 
   // Then try to perform the guaranteed copy value optimization.
-  if (performGuaranteedCopyValueOptimization(cvi)) {
+  if (ctx.shouldPerform(ARCTransformKind::RedundantCopyValueElimPeephole) &&
+      performGuaranteedCopyValueOptimization(cvi)) {
     return true;
   }
 
-  if (tryPerformOwnedCopyValueOptimization(cvi)) {
+  if (ctx.shouldPerform(ARCTransformKind::RedundantCopyValueElimPeephole) &&
+      tryPerformOwnedCopyValueOptimization(cvi)) {
     return true;
   }
 

lib/SILOptimizer/SemanticARC/LoadCopyToLoadBorrowOpt.cpp

@@ -329,6 +329,10 @@ bool SemanticARCOptVisitor::visitLoadInst(LoadInst *li) {
   if (ctx.onlyGuaranteedOpts)
     return false;
 
+  // If we are not supposed to perform this transform, bail.
+  if (!ctx.shouldPerform(ARCTransformKind::LoadCopyToLoadBorrowPeephole))
+    return false;
+
   if (li->getOwnershipQualifier() != LoadOwnershipQualifier::Copy)
     return false;
 

lib/SILOptimizer/SemanticARC/SemanticARCOptVisitor.cpp

@@ -23,6 +23,15 @@
 using namespace swift;
 using namespace swift::semanticarc;
 
+bool SemanticARCOptVisitor::optimizeWithoutFixedPoint() {
+  bool madeChange = false;
+
+  // First process the worklist until we reach a fixed point.
+  madeChange |= processWorklist();
+
+  return madeChange;
+}
+
 bool SemanticARCOptVisitor::optimize() {
   bool madeChange = false;
 

lib/SILOptimizer/SemanticARC/SemanticARCOptVisitor.h

@@ -15,6 +15,8 @@
 
 #include "Context.h"
 #include "OwnershipLiveRange.h"
+#include "SemanticARCOpts.h"
+
 #include "swift/Basic/BlotSetVector.h"
 #include "swift/Basic/FrozenMultiMap.h"
 #include "swift/Basic/MultiMapCache.h"
@@ -56,6 +58,12 @@ struct LLVM_LIBRARY_VISIBILITY SemanticARCOptVisitor
                   eraseAndRAUWSingleValueInstruction(i, value);
                 })) {}
 
+  void reset() {
+    ctx.reset();
+    worklist.clear();
+    visitedSinceLastMutation.clear();
+  }
+
   DeadEndBlocks &getDeadEndBlocks() { return ctx.getDeadEndBlocks(); }
 
   /// Given a single value instruction, RAUW it with newValue, add newValue to
@@ -192,6 +200,7 @@ struct LLVM_LIBRARY_VISIBILITY SemanticARCOptVisitor
 
   bool processWorklist();
   bool optimize();
+  bool optimizeWithoutFixedPoint();
 
   bool performGuaranteedCopyValueOptimization(CopyValueInst *cvi);
   bool eliminateDeadLiveRangeCopyValue(CopyValueInst *cvi);

lib/SILOptimizer/SemanticARC/SemanticARCOpts.cpp

@@ -12,6 +12,7 @@
 
 #define DEBUG_TYPE "sil-semantic-arc-opts"
 
+#include "SemanticARCOpts.h"
 #include "SemanticARCOptVisitor.h"
 #include "Transforms.h"
 
@@ -22,22 +23,24 @@
 using namespace swift;
 using namespace swift::semanticarc;
 
-namespace {
-
-/// An enum used so that at the command line, we can override
-enum class TransformToPerformKind {
-  Peepholes,
-  OwnedToGuaranteedPhi,
-};
-
-} // anonymous namespace
-
-static llvm::cl::list<TransformToPerformKind> TransformsToPerform(
+static llvm::cl::list<ARCTransformKind> TransformsToPerform(
     llvm::cl::values(
-        clEnumValN(TransformToPerformKind::Peepholes,
-                   "sil-semantic-arc-peepholes",
-                   "Perform ARC canonicalizations and peepholes"),
-        clEnumValN(TransformToPerformKind::OwnedToGuaranteedPhi,
+        clEnumValN(ARCTransformKind::AllPeepholes,
+                   "sil-semantic-arc-peepholes-all",
+                   "Perform All ARC canonicalizations and peepholes"),
+        clEnumValN(ARCTransformKind::LoadCopyToLoadBorrowPeephole,
+                   "sil-semantic-arc-peepholes-loadcopy-to-loadborrow",
+                   "Perform the load [copy] to load_borrow peephole"),
+        clEnumValN(ARCTransformKind::RedundantBorrowScopeElimPeephole,
+                   "sil-semantic-arc-peepholes-redundant-borrowscope-elim",
+                   "Perform the redundant borrow scope elimination peephole"),
+        clEnumValN(ARCTransformKind::RedundantCopyValueElimPeephole,
+                   "sil-semantic-arc-peepholes-redundant-copyvalue-elim",
+                   "Perform the redundant copy_value peephole"),
+        clEnumValN(ARCTransformKind::LifetimeJoiningPeephole,
+                   "sil-semantic-arc-peepholes-lifetime-joining",
+                   "Perform the join lifetimes peephole"),
+        clEnumValN(ARCTransformKind::OwnedToGuaranteedPhi,
                    "sil-semantic-arc-owned-to-guaranteed-phi",
                    "Perform Owned To Guaranteed Phi. NOTE: Seeded by peephole "
                    "optimizer for compile time saving purposes, so run this "
@@ -64,23 +67,52 @@ struct SemanticARCOpts : SILFunctionTransform {
 #ifndef NDEBUG
   void performCommandlineSpecifiedTransforms(SemanticARCOptVisitor &visitor) {
     for (auto transform : TransformsToPerform) {
+      visitor.ctx.transformKind = transform;
+      SWIFT_DEFER {
+        visitor.ctx.transformKind = ARCTransformKind::Invalid;
+        visitor.reset();
+      };
       switch (transform) {
-      case TransformToPerformKind::Peepholes:
-        if (performPeepholes(visitor)) {
+      case ARCTransformKind::LifetimeJoiningPeephole:
+      case ARCTransformKind::RedundantCopyValueElimPeephole:
+      case ARCTransformKind::RedundantBorrowScopeElimPeephole:
+      case ARCTransformKind::LoadCopyToLoadBorrowPeephole:
+      case ARCTransformKind::AllPeepholes:
+        // We never assume we are at fixed point when running these transforms.
+        if (performPeepholesWithoutFixedPoint(visitor)) {
           invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
         }
         continue;
-      case TransformToPerformKind::OwnedToGuaranteedPhi:
+      case ARCTransformKind::OwnedToGuaranteedPhi:
         if (tryConvertOwnedPhisToGuaranteedPhis(visitor.ctx)) {
           invalidateAnalysis(
               SILAnalysis::InvalidationKind::BranchesAndInstructions);
         }
         continue;
+      case ARCTransformKind::All:
+      case ARCTransformKind::Invalid:
+        llvm_unreachable("unsupported option");
       }
     }
   }
 #endif
 
+  bool performPeepholesWithoutFixedPoint(SemanticARCOptVisitor &visitor) {
+    // Add all the results of all instructions that we want to visit to the
+    // worklist.
+    for (auto &block : *getFunction()) {
+      for (auto &inst : block) {
+        if (SemanticARCOptVisitor::shouldVisitInst(&inst)) {
+          for (SILValue v : inst.getResults()) {
+            visitor.worklist.insert(v);
+          }
+        }
+      }
+    }
+    // Then process the worklist, performing peepholes.
+    return visitor.optimizeWithoutFixedPoint();
+  }
+
   bool performPeepholes(SemanticARCOptVisitor &visitor) {
     // Add all the results of all instructions that we want to visit to the
     // worklist.

lib/SILOptimizer/SemanticARC/SemanticARCOpts.h

@@ -0,0 +1,48 @@
+//===--- SemanticARCOpts.h ------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILOPTIMIZER_SEMANTICARC_SEMANTICARCOPTS_H
+#define SWIFT_SILOPTIMIZER_SEMANTICARC_SEMANTICARCOPTS_H
+
+#include <cstdint>
+#include <type_traits>
+
+namespace swift {
+namespace semanticarc {
+
+/// An enum used so that at the command line, we can override which transforms
+/// we perform.
+enum class ARCTransformKind : uint64_t {
+  Invalid = 0,
+  OwnedToGuaranteedPhi = 0x1,
+  LoadCopyToLoadBorrowPeephole = 0x2,
+  RedundantBorrowScopeElimPeephole = 0x4,
+  // TODO: Split RedundantCopyValueElimPeephole into more granular categories
+  // such as dead live range, guaranteed copy_value opt, etc.
+  RedundantCopyValueElimPeephole = 0x8,
+  LifetimeJoiningPeephole = 0x10,
+
+  AllPeepholes = LoadCopyToLoadBorrowPeephole |
+                 RedundantBorrowScopeElimPeephole |
+                 RedundantCopyValueElimPeephole | LifetimeJoiningPeephole,
+  All = AllPeepholes | OwnedToGuaranteedPhi,
+};
+
+inline ARCTransformKind operator&(ARCTransformKind lhs, ARCTransformKind rhs) {
+  using UnderlyingTy = std::underlying_type<ARCTransformKind>::type;
+  return ARCTransformKind(UnderlyingTy(lhs) & UnderlyingTy(rhs));
+}
+
+} // namespace semanticarc
+} // namespace swift
+
+#endif