[semantic-arc] Extract owned phi to guaranteed phi conversion from the visitor to its own function that works on the SemanticARCContext.

Author: gottesmm

lib/SILOptimizer/SemanticARC/Context.h

@@ -72,6 +72,9 @@ struct LLVM_LIBRARY_VISIBILITY Context {
   /// copy_values we /do/ allow.
   bool onlyGuaranteedOpts;
 
+  /// Callbacks that we must use to remove or RAUW values.
+  InstModCallbacks instModCallbacks;
+
   using FrozenMultiMapRange =
       decltype(joinedOwnedIntroducerToConsumedOperands)::PairToSecondEltRange;
 
@@ -81,7 +84,7 @@ struct LLVM_LIBRARY_VISIBILITY Context {
     return *deadEndBlocks;
   }
 
-  Context(SILFunction &fn, bool onlyGuaranteedOpts)
+  Context(SILFunction &fn, bool onlyGuaranteedOpts, InstModCallbacks callbacks)
       : fn(fn), deadEndBlocks(), lifetimeFrontier(),
         addressToExhaustiveWriteListCache(constructCacheValue),
         onlyGuaranteedOpts(onlyGuaranteedOpts) {}

lib/SILOptimizer/SemanticARC/OwnedToGuaranteedPhiOpt.cpp

@@ -16,8 +16,9 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "Context.h"
 #include "OwnershipPhiOperand.h"
-#include "SemanticARCOptVisitor.h"
+#include "Transforms.h"
 
 using namespace swift;
 using namespace swift::semanticarc;
@@ -120,7 +121,7 @@ static bool getIncomingJoinedLiveRangeOperands(
 //                            Top Level Entrypoint
 //===----------------------------------------------------------------------===//
 
-bool SemanticARCOptVisitor::performPostPeepholeOwnedArgElimination() {
+bool swift::semanticarc::tryConvertOwnedPhisToGuaranteedPhis(Context &ctx) {
   bool madeChange = false;
 
   // First freeze our multi-map so we can use it for map queries. Also, setup a
@@ -211,7 +212,7 @@ bool SemanticARCOptVisitor::performPostPeepholeOwnedArgElimination() {
           incomingValueUpdates.emplace_back(cvi->getOperand(), updateOffset);
         }
         std::move(lr).convertToGuaranteedAndRAUW(cvi->getOperand(),
-                                                 getCallbacks());
+                                                 ctx.instModCallbacks);
         continue;
       }
       llvm_unreachable("Unhandled optimizable introducer!");
@@ -227,7 +228,7 @@ bool SemanticARCOptVisitor::performPostPeepholeOwnedArgElimination() {
     // Then convert the phi's live range to be guaranteed.
     std::move(joinedLiveRange)
         .convertJoinedLiveRangePhiToGuaranteed(
-            getDeadEndBlocks(), ctx.lifetimeFrontier, getCallbacks());
+            ctx.getDeadEndBlocks(), ctx.lifetimeFrontier, ctx.instModCallbacks);
 
     // Now if our phi operand consumes/forwards its guaranteed input, insert a
     // begin_borrow along the incoming value edges. We have to do this after

lib/SILOptimizer/SemanticARC/SemanticARCOptVisitor.h

@@ -48,7 +48,13 @@ struct LLVM_LIBRARY_VISIBILITY SemanticARCOptVisitor
   Context ctx;
 
   explicit SemanticARCOptVisitor(SILFunction &fn, bool onlyGuaranteedOpts)
-      : ctx(fn, onlyGuaranteedOpts) {}
+      : ctx(fn, onlyGuaranteedOpts,
+            InstModCallbacks(
+                [this](SILInstruction *inst) { eraseInstruction(inst); },
+                [](SILInstruction *) {}, [](SILValue, SILValue) {},
+                [this](SingleValueInstruction *i, SILValue value) {
+                  eraseAndRAUWSingleValueInstruction(i, value);
+                })) {}
 
   DeadEndBlocks &getDeadEndBlocks() { return ctx.getDeadEndBlocks(); }
 
@@ -190,7 +196,6 @@ struct LLVM_LIBRARY_VISIBILITY SemanticARCOptVisitor
   bool performGuaranteedCopyValueOptimization(CopyValueInst *cvi);
   bool eliminateDeadLiveRangeCopyValue(CopyValueInst *cvi);
   bool tryJoiningCopyValueLiveRangeWithOperand(CopyValueInst *cvi);
-  bool performPostPeepholeOwnedArgElimination();
 };
 
 } // namespace semanticarc

lib/SILOptimizer/SemanticARC/SemanticARCOpts.cpp

@@ -12,11 +12,12 @@
 
 #define DEBUG_TYPE "sil-semantic-arc-opts"
 
-#include "swift/Basic/LLVM.h"
-
 #include "OwnershipLiveRange.h"
 #include "OwnershipPhiOperand.h"
 #include "SemanticARCOptVisitor.h"
+#include "Transforms.h"
+
+#include "swift/Basic/LLVM.h"
 
 #include "swift/Basic/BlotSetVector.h"
 #include "swift/Basic/FrozenMultiMap.h"
@@ -74,9 +75,6 @@ bool SemanticARCOptVisitor::optimize() {
     assert(!madeAdditionalChanges && "Should be at the fixed point");
   }
 
-  // Then use the newly seeded peephole map to
-  madeChange |= performPostPeepholeOwnedArgElimination();
-
   return madeChange;
 }
 
@@ -180,13 +178,21 @@ struct SemanticARCOpts : SILFunctionTransform {
       }
     }
 
-    // Then process the worklist. We only destroy instructions, so invalidate
-    // that. Once we modify the ownership of block arguments, we will need to
-    // perhaps invalidate branches as well.
-    if (visitor.optimize()) {
+    // Then process the worklist, performing peepholes.
+    bool madeChange = visitor.optimize();
+
+    // Now that we have seeded the map of phis to incoming values that could be
+    // converted to guaranteed, ignoring the phi, try convert those phis to be
+    // guaranteed.
+    if (tryConvertOwnedPhisToGuaranteedPhis(visitor.ctx)) {
       invalidateAnalysis(
           SILAnalysis::InvalidationKind::BranchesAndInstructions);
+      return;
     }
+
+    // Otherwise, we only deleted instructions and did not touch phis.
+    if (madeChange)
+      invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
   }
 };
 

lib/SILOptimizer/SemanticARC/Transforms.h

@@ -0,0 +1,41 @@
+//===--- Transforms.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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///
+/// Top level transforms for SemanticARCOpts
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILOPTIMIZER_SEMANTICARCOPT_TRANSFORMS_H
+#define SWIFT_SILOPTIMIZER_SEMANTICARCOPT_TRANSFORMS_H
+
+#include "llvm/Support/Compiler.h"
+
+namespace swift {
+namespace semanticarc {
+
+struct Context;
+
+/// Given the current map of owned phi arguments to consumed incoming values in
+/// ctx, attempt to convert these owned phi arguments to guaranteed phi
+/// arguments if the phi arguments are the only thing that kept us from
+/// converting these incoming values to be guaranteed.
+///
+/// \returns true if we converted atleast one phi from owned -> guaranteed and
+/// eliminated ARC traffic as a result.
+bool tryConvertOwnedPhisToGuaranteedPhis(Context &ctx) LLVM_LIBRARY_VISIBILITY;
+
+} // namespace semanticarc
+} // namespace swift
+
+#endif