[epilogue-arc-analysis] Do not copy lists by value to read them. Use an ArrayRef instead.

I don't think I need to say more here.

rdar://41146023

Author: gottesmm

include/swift/SILOptimizer/Analysis/ARCAnalysis.h

@@ -46,9 +46,6 @@ bool isRetainInstruction(SILInstruction *II);
 /// Return true if this is a release instruction.
 bool isReleaseInstruction(SILInstruction *II);
 
-using RetainList = TinyPtrVector<SILInstruction *>;
-using ReleaseList = TinyPtrVector<SILInstruction *>;
-
 /// \returns True if the user \p User decrements the ref count of \p Ptr.
 bool mayDecrementRefCount(SILInstruction *User, SILValue Ptr,
                           AliasAnalysis *AA);
@@ -145,7 +142,7 @@ class ConsumedResultToEpilogueRetainMatcher {
 
   // We use a list of instructions for now so that we can keep the same interface
   // and handle exploded retain_value later.
-  RetainList EpilogueRetainInsts;
+  TinyPtrVector<SILInstruction *> EpilogueRetainInsts;
 
 public:
   /// Finds matching releases in the return block of the function \p F.
@@ -156,7 +153,9 @@ class ConsumedResultToEpilogueRetainMatcher {
   /// Finds matching releases in the provided block \p BB.
   void findMatchingRetains(SILBasicBlock *BB);
 
-  RetainList getEpilogueRetains() { return EpilogueRetainInsts; }
+  ArrayRef<SILInstruction *> getEpilogueRetains() const {
+    return EpilogueRetainInsts;
+  }
 
   /// Recompute the mapping from argument to consumed arg.
   void recompute();
@@ -202,7 +201,9 @@ class ConsumedArgToEpilogueReleaseMatcher {
   RCIdentityFunctionInfo *RCFI;
   ExitKind Kind;
   ArrayRef<SILArgumentConvention> ArgumentConventions;
-  llvm::SmallMapVector<SILArgument *, ReleaseList, 8> ArgInstMap;
+
+  using InstListTy = TinyPtrVector<SILInstruction *>;
+  llvm::SmallMapVector<SILArgument *, InstListTy, 8> ArgInstMap;
 
   /// Set to true if we found some releases but not all for the argument.
   llvm::DenseSet<SILArgument *> FoundSomeReleases;
@@ -267,33 +268,32 @@ class ConsumedArgToEpilogueReleaseMatcher {
     return getSingleReleaseForArgument(Arg);
   }
 
-  ReleaseList getReleasesForArgument(SILArgument *Arg) {
-    ReleaseList Releases;
+  ArrayRef<SILInstruction *> getReleasesForArgument(SILArgument *Arg) {
     auto I = ArgInstMap.find(Arg);
     if (I == ArgInstMap.end())
-      return Releases;
-    return I->second; 
+      return {};
+    return I->second;
   }
 
-  ReleaseList getReleasesForArgument(SILValue V) {
-    ReleaseList Releases;
+  ArrayRef<SILInstruction *> getReleasesForArgument(SILValue V) {
     auto *Arg = dyn_cast<SILArgument>(V);
     if (!Arg)
-      return Releases;
+      return {};
     return getReleasesForArgument(Arg);
   }
 
   /// Recompute the mapping from argument to consumed arg.
   void recompute();
 
   bool isSingleReleaseMatchedToArgument(SILInstruction *Inst) {
-    auto Pred = [&Inst](const std::pair<SILArgument *,
-                                        ReleaseList> &P) -> bool {
-      if (P.second.size() > 1)
-        return false;
-      return *P.second.begin() == Inst;
-    };
-    return count_if(ArgInstMap, Pred);
+    return count_if(
+        ArgInstMap,
+        [&Inst](const std::pair<SILArgument *, ArrayRef<SILInstruction *>> &P)
+            -> bool {
+          if (P.second.size() > 1)
+            return false;
+          return *P.second.begin() == Inst;
+        });
   }
 
   using iterator = decltype(ArgInstMap)::iterator;
@@ -322,11 +322,12 @@ class ConsumedArgToEpilogueReleaseMatcher {
   /// between the releases values in \p Insts and \p Derived, it also bails
   /// out and return true if projection path can not be formed between Base
   /// and any one the released values.
-  bool isRedundantRelease(ReleaseList Insts, SILValue Base, SILValue Derived);
+  bool isRedundantRelease(ArrayRef<SILInstruction *> Insts, SILValue Base,
+                          SILValue Derived);
 
   /// Return true if we have a release instruction for all the reference
   /// semantics part of \p Argument.
-  bool releaseArgument(ReleaseList Insts, SILValue Argument);
+  bool releaseArgument(ArrayRef<SILInstruction *> Insts, SILValue Argument);
 
   /// Walk the basic block and find all the releases that match to function
   /// arguments.

lib/SILOptimizer/Analysis/ARCAnalysis.cpp

@@ -707,9 +707,8 @@ void ConsumedArgToEpilogueReleaseMatcher::recompute() {
   findMatchingReleases(&*BB);
 }
 
-bool
-ConsumedArgToEpilogueReleaseMatcher::
-isRedundantRelease(ReleaseList Insts, SILValue Base, SILValue Derived) {
+bool ConsumedArgToEpilogueReleaseMatcher::isRedundantRelease(
+    ArrayRef<SILInstruction *> Insts, SILValue Base, SILValue Derived) {
   // We use projection path to analyze the relation.
   auto POp = ProjectionPath::getProjectionPath(Base, Derived);
   // We can not build a projection path from the base to the derived, bail out.
@@ -730,9 +729,8 @@ isRedundantRelease(ReleaseList Insts, SILValue Base, SILValue Derived) {
   return false;
 }
 
-bool
-ConsumedArgToEpilogueReleaseMatcher::
-releaseArgument(ReleaseList Insts, SILValue Arg) {
+bool ConsumedArgToEpilogueReleaseMatcher::releaseArgument(
+    ArrayRef<SILInstruction *> Insts, SILValue Arg) {
   // Reason about whether all parts are released.
   SILModule *Mod = &(*Insts.begin())->getModule();
 

lib/SILOptimizer/FunctionSignatureTransforms/FunctionSignatureOpts.h

@@ -65,14 +65,14 @@ struct ArgumentDescriptor {
   /// Is this parameter an indirect result?
   bool IsIndirectResult;
 
-  /// If non-null, this is the release in the return block of the callee, which
-  /// is associated with this parameter if it is @owned. If the parameter is not
-  /// @owned or we could not find such a release in the callee, this is null.
-  ReleaseList CalleeRelease;
-
-  /// The same as CalleeRelease, but the release in the throw block, if it is a
-  /// function which has a throw block.
-  ReleaseList CalleeReleaseInThrowBlock;
+  /// If non-empty, this is the set of releases in the return block of
+  /// the callee associated with this parameter if it is @owned. If it
+  /// is empty then we could not find any such releases.
+  TinyPtrVector<SILInstruction *> CalleeRelease;
+
+  /// The same as CalleeRelease, but the releases are post-dominated
+  /// by the throw block, if it is a function which has a throw block.
+  TinyPtrVector<SILInstruction *> CalleeReleaseInThrowBlock;
 
   /// The projection tree of this arguments.
   ProjectionTree ProjTree;

lib/SILOptimizer/FunctionSignatureTransforms/OwnedToGuaranteedTransform.cpp

@@ -92,8 +92,11 @@ bool FunctionSignatureTransform::OwnedToGuaranteedAnalyzeParameters() {
         auto ReleasesInThrow =
             ArgToThrowReleaseMap.getReleasesForArgument(A.Arg);
         if (!ArgToThrowReleaseMap.hasBlock() || !ReleasesInThrow.empty()) {
-          A.CalleeRelease = Releases;
-          A.CalleeReleaseInThrowBlock = ReleasesInThrow;
+          assert(A.CalleeRelease.empty());
+          assert(A.CalleeReleaseInThrowBlock.empty());
+          copy(Releases, std::back_inserter(A.CalleeRelease));
+          copy(ReleasesInThrow,
+               std::back_inserter(A.CalleeReleaseInThrowBlock));
           // We can convert this parameter to a @guaranteed.
           A.OwnedToGuaranteed = true;
           SignatureOptimize = true;