[arc] Clean up ConsumedArgToEpilogueReleaseMatcher so we can recompute if we need to.

This can happen if ARCSequenceOpts moves around retains, releases.

Author: gottesmm

include/swift/SILAnalysis/ARCAnalysis.h

@@ -108,19 +108,27 @@ valueHasARCDecrementOrCheckInInstructionRange(SILValue Op,
 ///
 /// TODO: This really needs a better name.
 class ConsumedArgToEpilogueReleaseMatcher {
+public:
+  enum class ExitKind { Return, Throw };
+
+private:
+  SILFunction *F;
+  RCIdentityFunctionInfo *RCFI;
+  ExitKind Kind;
   llvm::SmallMapVector<SILArgument *, SILInstruction *, 8> ArgInstMap;
+  bool HasBlock = false;
 
 public:
-  /// Default constructor: does not find matching releases, so
-  /// findMatchingReleases should be called explicitly.
-  ConsumedArgToEpilogueReleaseMatcher() { }
 
   /// Finds matching releases in the return block of the function \p F.
-  ConsumedArgToEpilogueReleaseMatcher(RCIdentityFunctionInfo *RCIA,
-                                      SILFunction *F);
+  ConsumedArgToEpilogueReleaseMatcher(RCIdentityFunctionInfo *RCFI,
+                                      SILFunction *F,
+                                      ExitKind Kind = ExitKind::Return);
 
   /// Finds matching releases in the provided block \p BB.
-  void findMatchingReleases(RCIdentityFunctionInfo *RCIA, SILBasicBlock *BB);
+  void findMatchingReleases(SILBasicBlock *BB);
+
+  bool hasBlock() const { return HasBlock; }
 
   bool argumentHasRelease(SILArgument *Arg) const {
     return ArgInstMap.find(Arg) != ArgInstMap.end();
@@ -140,6 +148,9 @@ class ConsumedArgToEpilogueReleaseMatcher {
     return I->second;
   }
 
+  /// Recompute the mapping from argument to consumed arg.
+  void recompute();
+
   bool isReleaseMatchedToArgument(SILInstruction *Inst) const {
     auto Pred = [&Inst](const std::pair<SILArgument *,
                                         SILInstruction *> &P) -> bool {

lib/SILAnalysis/ARCAnalysis.cpp

@@ -508,17 +508,34 @@ mayGuaranteedUseValue(SILInstruction *User, SILValue Ptr, AliasAnalysis *AA) {
 //                          Owned Argument Utilities
 //===----------------------------------------------------------------------===//
 
-ConsumedArgToEpilogueReleaseMatcher::
-ConsumedArgToEpilogueReleaseMatcher(RCIdentityFunctionInfo *RCIA,
-                                    SILFunction *F) {
+ConsumedArgToEpilogueReleaseMatcher::ConsumedArgToEpilogueReleaseMatcher(
+    RCIdentityFunctionInfo *RCFI, SILFunction *F, ExitKind Kind)
+    : F(F), RCFI(RCFI), Kind(Kind) {
+  recompute();
+}
+
+void ConsumedArgToEpilogueReleaseMatcher::recompute() {
   // Find the return BB of F. If we fail, then bail.
-  auto ReturnBB = F->findReturnBB();
-  if (ReturnBB != F->end())
-    findMatchingReleases(RCIA, &*ReturnBB);
+  SILFunction::iterator BB;
+  switch (Kind) {
+  case ExitKind::Return:
+    BB = F->findReturnBB();
+    break;
+  case ExitKind::Throw:
+    BB = F->findThrowBB();
+    break;
+  }
+
+  if (BB == F->end()) {
+    HasBlock = false;
+    return;
+  }
+  HasBlock = true;
+  findMatchingReleases(&*BB);
 }
 
-void ConsumedArgToEpilogueReleaseMatcher::
-findMatchingReleases(RCIdentityFunctionInfo *RCIA, SILBasicBlock *BB) {
+void ConsumedArgToEpilogueReleaseMatcher::findMatchingReleases(
+    SILBasicBlock *BB) {
   for (auto II = std::next(BB->rbegin()), IE = BB->rend();
        II != IE; ++II) {
     // If we do not have a release_value or strong_release...
@@ -536,7 +553,7 @@ findMatchingReleases(RCIdentityFunctionInfo *RCIA, SILBasicBlock *BB) {
     // Ok, we have a release_value or strong_release. Grab Target and find the
     // RC identity root of its operand.
     SILInstruction *Target = &*II;
-    SILValue Op = RCIA->getRCIdentityRoot(Target->getOperand(0));
+    SILValue Op = RCFI->getRCIdentityRoot(Target->getOperand(0));
 
     // If Op is not a consumed argument, we must break since this is not an Op
     // that is a part of a return sequence. We are being conservative here since

lib/SILPasses/IPO/FunctionSignatureOpts.cpp

@@ -502,10 +502,8 @@ bool FunctionAnalyzer::analyze() {
   // A map from consumed SILArguments to the release associated with an
   // argument.
   ConsumedArgToEpilogueReleaseMatcher ArgToReturnReleaseMap(RCIA, F);
-  ConsumedArgToEpilogueReleaseMatcher ArgToThrowReleaseMap;
-  auto ThrowBBIter = F->findThrowBB();
-  if (ThrowBBIter != F->end())
-    ArgToThrowReleaseMap.findMatchingReleases(RCIA, &*ThrowBBIter);
+  ConsumedArgToEpilogueReleaseMatcher ArgToThrowReleaseMap(
+      RCIA, F, ConsumedArgToEpilogueReleaseMatcher::ExitKind::Throw);
 
   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
     ArgumentDescriptor A(Allocator, Args[i]);
@@ -530,7 +528,7 @@ bool FunctionAnalyzer::analyze() {
 
         // If the function has a throw block we must also find a matching
         // release in the throw block.
-        if (ThrowBBIter == F->end() ||
+        if (!ArgToThrowReleaseMap.hasBlock() ||
             (ReleaseInThrow = ArgToThrowReleaseMap.releaseForArgument(A.Arg))) {
 
           // TODO: accept a second release in the throw block to let the