Merge pull request #3244 from trentxintong/ReleaseCM

Implement an iterative data flow to find epilogue retains or releases

Author: trentxintong

include/swift/SILOptimizer/Analysis/ARCAnalysis.h

@@ -16,6 +16,10 @@
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILValue.h"
 #include "swift/SIL/SILBasicBlock.h"
+#include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
+#include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
+#include "swift/SILOptimizer/Analysis/RCIdentityAnalysis.h"
+#include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
@@ -386,4 +390,184 @@ SILInstruction *findReleaseToMatchUnsafeGuaranteedValue(
 
 } // end namespace swift
 
+
+namespace swift {
+
+/// EpilogueARCBlockState - Keep track of whether a epilogue ARC instruction has
+/// been found.
+struct EpilogueARCBlockState {
+  /// Keep track of whether a eplogue release has been found before and after
+  /// this basic block.
+  bool BBSetIn;
+  /// The basic block local SILValue we are interested to find epilogue ARC in.
+  SILValue LocalArg;
+  /// Constructor, we only compute epilogue ARC instruction for 1 argument at
+  /// a time.
+  /// Optimistic data flow.
+  EpilogueARCBlockState() { BBSetIn = true; LocalArg = SILValue(); }
+};
+
+/// EpilogueARCContext - This class implements a data flow with which epilogue
+/// retains or releases for a SILValue are found.
+///
+/// NOTE:
+/// In case of release finder, this function assumes the SILArgument has
+/// @owned semantic.
+/// In case of retain finder, this class assumes Arg is one of the return value
+/// of the function.
+class EpilogueARCContext {
+public:
+  enum EpilogueARCKind { Retain = 0, Release = 1 };
+
+private:
+  // Are we finding retains or releases.
+  EpilogueARCKind Kind;
+
+  // The argument we are looking for epilogue ARC instruction for.
+  SILValue Arg;
+
+  /// The allocator we are currently using.
+  llvm::SpecificBumpPtrAllocator<EpilogueARCBlockState> BPA;
+
+  /// Current function we are analyzing.
+  SILFunction *F;
+
+  /// Current post-order we are using.
+  PostOrderFunctionInfo *PO;
+
+  /// Current alias analysis we are using.
+  AliasAnalysis *AA;
+
+  /// Current rc-identity we are using.
+  RCIdentityFunctionInfo *RCFI;
+
+  /// The epilogue retains or releases.
+  llvm::SmallVector<SILInstruction *, 1> EpilogueARCInsts; 
+
+  /// All the retain/release block state for all the basic blocks in the function. 
+  llvm::DenseMap<SILBasicBlock *, EpilogueARCBlockState *> EpilogueARCBlockStates;
+
+  /// The exit blocks of the function.
+  llvm::SmallPtrSet<SILBasicBlock *, 2> ExitBlocks;
+
+  /// Return true if this is a function exit block.
+  bool isExitBlock(SILBasicBlock *BB) {
+    return ExitBlocks.count(BB);
+  }
+
+  /// Return true if this is a retain instruction.
+  bool isRetainInstruction(SILInstruction *II) {
+    return isa<RetainValueInst>(II) || isa<StrongRetainInst>(II);
+  }
+
+  /// Return true if this is a release instruction.
+  bool isReleaseInstruction(SILInstruction *II) {
+    return isa<ReleaseValueInst>(II) || isa<StrongReleaseInst>(II);
+  }
+
+  SILValue getArg(SILBasicBlock *B) {
+    SILValue A = EpilogueARCBlockStates[B]->LocalArg;
+    if (A)
+      return A;
+    return Arg;
+  }
+
+public:
+  /// Constructor.
+  EpilogueARCContext(EpilogueARCKind Kind, SILValue Arg, SILFunction *F,
+                     PostOrderFunctionInfo *PO, AliasAnalysis *AA,
+                     RCIdentityFunctionInfo *RCFI)
+    : Kind(Kind), Arg(Arg), F(F), PO(PO), AA(AA), RCFI(RCFI) {}
+
+  /// Run the data flow to find the epilogue retains or releases.
+  bool run() {
+    // Initialize the epilogue arc data flow context.
+    initializeDataflow();
+    // Converge the data flow.
+    convergeDataflow();
+    // Lastly, find the epilogue ARC instructions.
+    return computeEpilogueARC();
+  }
+
+  /// Reset the epilogue arc instructions. 
+  void resetEpilogueARCInsts() { EpilogueARCInsts.clear(); }
+  llvm::SmallVector<SILInstruction *, 1> getEpilogueARCInsts() {
+    return EpilogueARCInsts;
+  }
+
+  /// Initialize the data flow.
+  void initializeDataflow();
+
+  /// Keep iterating until the data flow is converged.
+  void convergeDataflow();
+
+  /// Find the epilogue ARC instructions.
+  bool computeEpilogueARC();
+
+  /// This instruction prevents looking further for epilogue retains on the
+  /// current path.
+  bool mayBlockEpilogueRetain(SILInstruction *II, SILValue Ptr) { 
+    // reference decrementing instruction prevents any retain to be identified as
+    // epilogue retains.
+    if (mayDecrementRefCount(II, Ptr, AA))
+      return true;
+    // Handle self-recursion. A self-recursion can be considered a +1 on the
+    // current argument.
+    if (ApplyInst *AI = dyn_cast<ApplyInst>(II))
+     if (AI->getCalleeFunction() == II->getParent()->getParent())
+       return true;
+    return false;
+  } 
+
+  /// This instruction prevents looking further for epilogue releases on the
+  /// current path.
+  bool mayBlockEpilogueRelease(SILInstruction *II, SILValue Ptr) { 
+    // Check whether this instruction read reference count, i.e. uniqueness
+    // check. Moving release past that may result in additional COW.
+   if (II->mayReleaseOrReadRefCount())
+      return true;
+    return false;
+  } 
+
+  /// Does this instruction block the interested ARC instruction ?
+  bool mayBlockEpilogueARC(SILInstruction *II, SILValue Ptr) { 
+    if (Kind == EpilogueARCKind::Retain)
+      return mayBlockEpilogueRetain(II, Ptr);
+    return mayBlockEpilogueRelease(II, Ptr);
+  }
+
+  /// This is the type of instructions the data flow is interested in.
+  bool isInterestedInstruction(SILInstruction *II) {
+    // We are checking for release.
+    if (Kind == EpilogueARCKind::Release)
+      return isReleaseInstruction(II) &&
+             RCFI->getRCIdentityRoot(II->getOperand(0)) ==
+             RCFI->getRCIdentityRoot(getArg(II->getParent()));
+    // We are checking for retain. If this is a self-recursion. call
+    // to the function (which returns an owned value) can be treated as
+    // the retain instruction.
+    if (ApplyInst *AI = dyn_cast<ApplyInst>(II))
+     if (AI->getCalleeFunction() == II->getParent()->getParent())
+       return true;
+    // Check whether this is a retain instruction and the argument it
+    // retains.
+    return isRetainInstruction(II) &&
+           RCFI->getRCIdentityRoot(II->getOperand(0)) ==
+           RCFI->getRCIdentityRoot(getArg(II->getParent()));
+  }
+};
+
+/// Compute the epilogue ARC instructions for a given SILValue. Return an
+/// empty set if no epilogue ARC instructions can be found.
+///
+/// NOTE: This function assumes Arg is has @owned semantic.
+llvm::SmallVector<SILInstruction *, 1> 
+computeEpilogueARCInstructions(EpilogueARCContext::EpilogueARCKind Kind,
+                               SILValue Arg, SILFunction *F,
+                               PostOrderFunctionInfo *PO, AliasAnalysis *AA,
+                               RCIdentityFunctionInfo *RCFI); 
+
+} // end namespace swift
+
+
 #endif

include/swift/SILOptimizer/PassManager/Passes.def

@@ -73,6 +73,8 @@ PASS(ConditionForwarding, "condition-forwarding",
      "Forward conditional branch instructions")
 PASS(CopyForwarding, "copy-forwarding",
      "Eliminate redundant copies")
+PASS(EpilogueARCMatcherDumper, "sil-epilogue-arc-dumper",
+     "Dump epilogue retains for return value and releases for arguments")
 PASS(EpilogueRetainReleaseMatcherDumper, "sil-epilogue-retain-release-dumper",
      "Dump epilogue retains for return value and releases for arguments")
 PASS(RedundantOverflowCheckRemoval, "remove-redundant-overflow-checks",

lib/SILOptimizer/Analysis/ARCAnalysis.cpp

@@ -23,6 +23,8 @@
 #include "swift/SILOptimizer/Analysis/ValueTracking.h"
 #include "swift/SILOptimizer/Utils/Local.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Debug.h"
 
 using namespace swift;
@@ -1154,3 +1156,151 @@ SILInstruction *swift::findReleaseToMatchUnsafeGuaranteedValue(
   }
   return nullptr;
 }
+
+void EpilogueARCContext::initializeDataflow() {
+  for (auto &B : *F) {
+    // Find the exit blocks.
+    if (B.getTerminator()->isFunctionExiting()) {
+      ExitBlocks.insert(&B);
+    }
+    // Allocate the storage.
+    EpilogueARCBlockStates[&B] =
+              new (BPA.Allocate()) EpilogueARCBlockState();
+  }
+
+  // Split the SILargument into local arguments to each specific basic block.
+  llvm::SmallVector<SILValue, 4> ToProcess;
+  llvm::DenseSet<SILValue> Processed;
+  ToProcess.push_back(Arg);
+  while (!ToProcess.empty()) {
+    SILValue Arg = ToProcess.pop_back_val();
+    if (Processed.find(Arg) != Processed.end())
+       continue;
+    Processed.insert(Arg);
+    SILArgument *A = dyn_cast<SILArgument>(Arg);
+    if (A && !A->isFunctionArg()) {
+      // Find predecessor and break the SILArgument to predecessors.
+      for (auto X : A->getParent()->getPreds()) {
+        // Try to find the predecessor edge-value.
+        SILValue IA = A->getIncomingValue(X);
+        EpilogueARCBlockStates[X]->LocalArg = IA;
+        // Maybe the edge value is another SILArgument.
+        ToProcess.push_back(IA);
+      }
+    }
+  }
+}
+
+void EpilogueARCContext::convergeDataflow() {
+  // Keep iterating until Changed is false.
+  bool Changed = false;
+  do {
+    Changed = false;
+    // Iterate until the data flow converges.
+    for (SILBasicBlock *B : PO->getPostOrder()) {
+      auto BS = EpilogueARCBlockStates[B];
+      // Merge in all the successors.
+      bool BBSetOut = false;
+      if (!B->succ_empty()) {
+        auto Iter = B->succ_begin();
+        BBSetOut = EpilogueARCBlockStates[*Iter]->BBSetIn;
+        Iter = std::next(Iter);
+        for (auto E = B->succ_end(); Iter != E; ++Iter) {
+	   BBSetOut &= EpilogueARCBlockStates[*Iter]->BBSetIn;
+        }
+      } else if (isExitBlock(B)) {
+        // We set the BBSetOut for exit blocks.
+        BBSetOut = true;
+      }
+
+      // If an epilogue ARC instruction or blocking operating has been identified
+      // then there is no point visiting every instruction in this block.
+      if (BBSetOut) {
+        // Iterate over all instructions in the basic block and find the
+        // interested ARC instruction in the block.
+        for (auto I = B->rbegin(), E = B->rend(); I != E; ++I) {
+          // This is a transition from 1 to 0 due to an interested instruction.
+          if (isInterestedInstruction(&*I)) {
+            BBSetOut = false;
+            break;
+          }
+          // This is a transition from 1 to 0 due to a blocking instruction.
+          if (mayBlockEpilogueARC(&*I, RCFI->getRCIdentityRoot(Arg))) {
+            BBSetOut = false;
+            break;
+          }
+        }
+      }
+
+      // Update BBSetIn.
+      Changed |= (BS->BBSetIn != BBSetOut);
+      BS->BBSetIn = BBSetOut;
+    }
+  } while(Changed);
+}
+
+bool EpilogueARCContext::computeEpilogueARC() {
+  // At this point the data flow should have converged. Find the epilogue
+  // releases.
+  for (SILBasicBlock *B : PO->getPostOrder()) {
+    bool BBSetOut = false;
+    // Merge in all the successors.
+    if (!B->succ_empty()) {
+      // Make sure we've either found no ARC instructions in all the successors
+      // or we've found ARC instructions in all successors.
+      //
+      // In case we've found ARC instructions in some and not all successors,
+      // that means from this point to the end of the function, some paths will
+      // not have an epilogue ARC instruction, which means the data flow has 
+      // failed.
+      auto Iter = B->succ_begin();
+      auto Base = EpilogueARCBlockStates[*Iter]->BBSetIn;
+      Iter = std::next(Iter);
+      for (auto E = B->succ_end(); Iter != E; ++Iter) {
+        if (EpilogueARCBlockStates[*Iter]->BBSetIn != Base)
+          return false;
+      }
+      BBSetOut = Base;
+    } else if (isExitBlock(B)) {
+      // We set the BBSetOut for exit blocks.
+      BBSetOut = true;
+    }
+
+    // If an epilogue ARC instruction or blocking operating has been identified
+    // then there is no point visiting every instruction in this block.
+    if (!BBSetOut) {
+      continue;
+    }
+
+    // An epilogue ARC instruction has not been identified, maybe its in this block.
+    //
+    // Iterate over all instructions in the basic block and find the interested ARC
+    // instruction in the block.
+    for (auto I = B->rbegin(), E = B->rend(); I != E; ++I) {
+      // This is a transition from 1 to 0 due to an interested instruction.
+      if (isInterestedInstruction(&*I)) {
+        EpilogueARCInsts.push_back(&*I);
+        break;
+      }
+      // This is a transition from 1 to 0 due to a blocking instruction.
+      if (mayBlockEpilogueARC(&*I, RCFI->getRCIdentityRoot(Arg))) {
+        break;
+      }
+    }
+  }
+  return true;
+}
+
+llvm::SmallVector<SILInstruction *, 1>
+swift::computeEpilogueARCInstructions(EpilogueARCContext::EpilogueARCKind Kind,
+                                      SILValue Arg, SILFunction *F,
+                                      PostOrderFunctionInfo *PO, AliasAnalysis *AA,
+                                      RCIdentityFunctionInfo *RCFI) {
+  EpilogueARCContext CM(Kind, Arg, F, PO, AA, RCFI); 
+  // Initialize and run the data flow. Clear the epilogue arc instructions if the
+  // data flow is aborted in middle.
+  if (!CM.run()) {
+    CM.resetEpilogueARCInsts();
+  }
+  return CM.getEpilogueARCInsts();
+}

lib/SILOptimizer/UtilityPasses/CMakeLists.txt

@@ -6,6 +6,7 @@ set(UTILITYPASSES_SOURCES
   UtilityPasses/CFGPrinter.cpp
   UtilityPasses/ComputeDominanceInfo.cpp
   UtilityPasses/ComputeLoopInfo.cpp
+  UtilityPasses/EpilogueARCMatcherDumper.cpp
   UtilityPasses/EpilogueRetainReleaseMatcherDumper.cpp
   UtilityPasses/EscapeAnalysisDumper.cpp
   UtilityPasses/FunctionOrderPrinter.cpp