Simplify function signature optimzation.

Several functionalities have been added to FSO over time and the logic has become
muddled.

We were always looking at a static image of the SIL and try to reason about what kind of
function signature related optimizations we can do.

This can easily lead to muddled logic. e.g. we need to consider 2 different function
signature optimizations together instead of independently.

Split 1 single function to do all sorts of different analyses in FSO into several
small transformations, each of which does a specific job. After every analysis, we produce
a new function and eventually we collapse all intermediate thunks to in a single thunk.

With this change, it will be easier to implement function signature optimization as now
we can do them independently now.

Small modifications to the test cases.

Author: trentxintong

include/swift/SIL/Mangle.h

@@ -104,6 +104,7 @@ template <typename SubType>
 class SpecializationMangler : public SpecializationManglerBase {
   SubType *asImpl() { return static_cast<SubType *>(this); }
 public:
+  Mangle::Mangler &getMangler() const { return M; }
 
   ~SpecializationMangler() = default;
 

include/swift/SIL/Projection.h

@@ -730,11 +730,6 @@ class ProjectionTreeNode {
       Initialized(false), IsLive(false) {}
 
 public:
-  enum LivenessKind : unsigned {
-    NormalUseLiveness = 0,
-    IgnoreEpilogueReleases = 1,
-  };
-
   class NewAggregateBuilder;
 
   ~ProjectionTreeNode() = default;
@@ -799,8 +794,7 @@ class ProjectionTreeNode {
 
   void processUsersOfValue(ProjectionTree &Tree,
                            llvm::SmallVectorImpl<ValueNodePair> &Worklist,
-                           SILValue Value, ProjectionTreeNode::LivenessKind Kind,
-                           llvm::DenseSet<SILInstruction *> &Releases);
+                           SILValue Value);
 
   void createNextLevelChildren(ProjectionTree &Tree);
 
@@ -816,11 +810,6 @@ class ProjectionTree {
 
   llvm::BumpPtrAllocator &Allocator;
 
-  /// The way we compute what is live and what is dead.
-  ProjectionTreeNode::LivenessKind Kind;
-
-  llvm::DenseSet<SILInstruction *> EpilogueReleases;
-
   // A common pattern is a 3 field struct.
   llvm::SmallVector<ProjectionTreeNode *, 4> ProjectionTreeNodes;
   llvm::SmallVector<unsigned, 3> LiveLeafIndices;
@@ -831,9 +820,6 @@ class ProjectionTree {
   /// Construct a projection tree from BaseTy.
   ProjectionTree(SILModule &Mod, llvm::BumpPtrAllocator &Allocator,
                  SILType BaseTy);
-  ProjectionTree(SILModule &Mod, llvm::BumpPtrAllocator &Allocator,
-                 SILType BaseTy, ProjectionTreeNode::LivenessKind Kind, 
-                 llvm::DenseSet<SILInstruction*> Insts);
   /// Construct an uninitialized projection tree, which can then be
   /// initialized by initializeWithExistingTree.
   ProjectionTree(SILModule &Mod, llvm::BumpPtrAllocator &Allocator) 

include/swift/SILOptimizer/Analysis/ARCAnalysis.h

@@ -189,6 +189,9 @@ class ConsumedArgToEpilogueReleaseMatcher {
   ExitKind Kind;
   llvm::SmallMapVector<SILArgument *, ReleaseList, 8> ArgInstMap;
 
+  /// Set to true if we found some releases but not all for the argument.
+  llvm::DenseSet<SILArgument *> FoundSomeReleases;
+
   /// Eventually this will be used in place of HasBlock.
   SILBasicBlock *ProcessedBlock;
 
@@ -240,6 +243,12 @@ class ConsumedArgToEpilogueReleaseMatcher {
     return false;
   }
 
+  /// Return true if we've found some epilgoue releases for the argument
+  /// but not all.
+  bool hasSomeReleasesForArgument(SILArgument *Arg) {
+    return FoundSomeReleases.find(Arg) != FoundSomeReleases.end();
+  }
+
   bool isSingleRelease(SILArgument *Arg) const {
     auto Iter = ArgInstMap.find(Arg);
     assert(Iter != ArgInstMap.end() && "Failed to get release list for argument");

include/swift/SILOptimizer/Utils/FunctionSignatureOptUtils.h

@@ -28,15 +28,15 @@
 
 namespace swift {
 
-using ReleaseSet = llvm::DenseSet<SILInstruction *>;
-
 /// A structure that maintains all of the information about a specific
 /// SILArgument that we are tracking.
 struct ArgumentDescriptor {
-
   /// The argument that we are tracking original data for.
   SILArgument *Arg;
 
+  /// Parameter Info.
+  SILParameterInfo PInfo;
+
   /// The original index of this argument.
   unsigned Index;
 
@@ -48,6 +48,9 @@ struct ArgumentDescriptor {
 
   /// Should the argument be exploded ?
   bool Explode;
+  
+  /// This parameter is owned to guaranteed.
+  bool OwnedToGuaranteed;
 
   /// Is this parameter an indirect result?
   bool IsIndirectResult;
@@ -73,17 +76,13 @@ struct ArgumentDescriptor {
   /// to the original argument. The reason why we do this is to make sure we
   /// have access to the original argument's state if we modify the argument
   /// when optimizing.
-  ArgumentDescriptor(llvm::BumpPtrAllocator &BPA, SILArgument *A,
-                     ReleaseSet Releases)
-      : Arg(A), Index(A->getIndex()),
+  ArgumentDescriptor(llvm::BumpPtrAllocator &BPA, SILArgument *A)
+      : Arg(A), PInfo(Arg->getKnownParameterInfo()), Index(A->getIndex()),
         Decl(A->getDecl()), IsEntirelyDead(false), Explode(false),
+        OwnedToGuaranteed(false),
         IsIndirectResult(A->isIndirectResult()),
         CalleeRelease(), CalleeReleaseInThrowBlock(),
-        ProjTree(A->getModule(), BPA, A->getType(), 
-        ProjectionTreeNode::LivenessKind::IgnoreEpilogueReleases, 
-        Releases) {
-    ProjTree.computeUsesAndLiveness(A);
-  }
+        ProjTree(A->getModule(), BPA, A->getType())  {}
 
   ArgumentDescriptor(const ArgumentDescriptor &) = delete;
   ArgumentDescriptor(ArgumentDescriptor &&) = default;
@@ -95,35 +94,12 @@ struct ArgumentDescriptor {
     return Arg->hasConvention(P);
   }
 
-  /// Convert the potentially multiple interface params associated with this
-  /// argument.
-  void
-  computeOptimizedInterfaceParams(SmallVectorImpl<SILParameterInfo> &Out) const;
-
-  /// Add potentially multiple new arguments to NewArgs from the caller's apply
-  /// or try_apply inst.
-  void addCallerArgs(SILBuilder &Builder, FullApplySite FAS,
-                     SmallVectorImpl<SILValue> &NewArgs) const;
-
-  /// Add potentially multiple new arguments to NewArgs from the thunk's
-  /// function arguments.
-  void addThunkArgs(SILBuilder &Builder, SILBasicBlock *BB,
-                    SmallVectorImpl<SILValue> &NewArgs) const;
-
-  /// Optimize the argument at ArgOffset and return the index of the next
-  /// argument to be optimized.
-  ///
-  /// The return value makes it easy to SROA arguments since we can return the
-  /// amount of SROAed arguments we created.
-  unsigned updateOptimizedBBArgs(SILBuilder &Builder, SILBasicBlock *BB,
-                                 unsigned ArgOffset);
-
   bool canOptimizeLiveArg() const {
     return Arg->getType().isObject();
   }
 
   /// Return true if it's both legal and a good idea to explode this argument.
-  bool shouldExplode() const {
+  bool shouldExplode(ConsumedArgToEpilogueReleaseMatcher &ERM) const {
     // We cannot optimize the argument.
     if (!canOptimizeLiveArg())
       return false;
@@ -150,15 +126,19 @@ struct ResultDescriptor {
   /// @owned or we could not find such a release in the callee, this is null.
   RetainList CalleeRetain;
 
+  /// This is owned to guaranteed.
+  bool OwnedToGuaranteed;
+
   /// Initialize this argument descriptor with all information from A that we
   /// use in our optimization.
   ///
   /// *NOTE* We cache a lot of data from the argument and maintain a reference
   /// to the original argument. The reason why we do this is to make sure we
   /// have access to the original argument's state if we modify the argument
   /// when optimizing.
-  ResultDescriptor() {};
-  ResultDescriptor(SILResultInfo RI) : ResultInfo(RI), CalleeRetain() {}
+  ResultDescriptor() {}
+  ResultDescriptor(SILResultInfo RI) 
+    : ResultInfo(RI), CalleeRetain(), OwnedToGuaranteed(false) {}
 
   ResultDescriptor(const ResultDescriptor &) = delete;
   ResultDescriptor(ResultDescriptor &&) = default;
@@ -171,100 +151,12 @@ struct ResultDescriptor {
   }
 };
 
-class FunctionSignatureInfo {
-  /// Should this function be optimized.
-  bool ShouldOptimize;
-
-  /// Optimizing this function may lead to good performance potential.
-  bool HighlyProfitable;
-
-  /// Function currently analyzing.
-  SILFunction *F;
-
-  /// The allocator we are using.
-  llvm::BumpPtrAllocator &Allocator;
-
-  /// The alias analysis currently using.
-  AliasAnalysis *AA;
-
-  /// The rc-identity analysis currently using.
-  RCIdentityFunctionInfo *RCFI;
-
-  /// Does any call inside the given function may bind dynamic 'Self' to a
-  /// generic argument of the callee.
-  bool MayBindDynamicSelf;
-
-  /// Did we decide to change the self argument? If so we need to
-  /// change the calling convention 'method' to 'freestanding'.
-  bool ShouldModifySelfArgument = false;
-
-  /// A list of structures which present a "view" of precompiled information on
-  /// an argument that we will use during our optimization.
-  llvm::SmallVector<ArgumentDescriptor, 8> ArgDescList;
-
-  /// Keep a "view" of precompiled information on the direct results
-  /// which we will use during our optimization.
-  llvm::SmallVector<ResultDescriptor, 4> ResultDescList;
-
-
-public:
-  FunctionSignatureInfo(SILFunction *F, llvm::BumpPtrAllocator &BPA,
-                        AliasAnalysis *AA, RCIdentityFunctionInfo *RCFI) :
-  ShouldOptimize(false), HighlyProfitable(false), F(F), Allocator(BPA),
-  AA(AA), RCFI(RCFI), MayBindDynamicSelf(computeMayBindDynamicSelf(F)) {
-    analyze();
-  }
-
-  bool shouldOptimize() const { return ShouldOptimize; }
-  bool profitableOptimize() const { return HighlyProfitable; }
-
-  void analyze();
-  bool analyzeParameters();
-  bool analyzeResult();
-
-  /// Returns the mangled name of the function that should be generated from
-  /// this function analyzer.
-  std::string getOptimizedName() const;
-
-  bool shouldModifySelfArgument() const { return ShouldModifySelfArgument; }
-  ArrayRef<ArgumentDescriptor> getArgDescList() const { return ArgDescList; }
-  ArrayRef<ResultDescriptor> getResultDescList() {return ResultDescList;}
-  SILFunction *getAnalyzedFunction() const { return F; }
-
-private:
-  /// Is the given argument required by the ABI?
-  ///
-  /// Metadata arguments may be required if dynamic Self is bound to any generic
-  /// parameters within this function's call sites.
-  bool isArgumentABIRequired(SILArgument *Arg) {
-    // This implicitly asserts that a function binding dynamic self has a self
-    // metadata argument or object from which self metadata can be obtained.
-    return MayBindDynamicSelf && (F->getSelfMetadataArgument() == Arg);
-  }
-};
-
-
-
+/// Returns true if F is a function which the pass know show to specialize
+/// function signatures for.
 bool canSpecializeFunction(SILFunction *F);
 
-void 
-addReleasesForConvertedOwnedParameter(SILBuilder &Builder,
-                                      SILLocation Loc,
-                                      OperandValueArrayRef Parameters,
-                                      ArrayRef<ArgumentDescriptor> &ArgDescs);
-
-void
-addReleasesForConvertedOwnedParameter(SILBuilder &Builder,
-                                      SILLocation Loc,
-                                      ArrayRef<SILArgument*> Parameters,
-                                      ArrayRef<ArgumentDescriptor> &ArgDescs);
-void
-addRetainsForConvertedDirectResults(SILBuilder &Builder,
-                                    SILLocation Loc,
-                                    SILValue ReturnValue,
-                                    SILInstruction *AI,
-                                    ArrayRef<ResultDescriptor> DirectResults);
-
+/// Return true if this argument is used in a non-trivial way.
+bool hasNonTrivialNonDebugUse(SILArgument *Arg);
 
 } // end namespace swift
 

lib/SIL/Mangle.cpp

@@ -81,7 +81,7 @@ FunctionSignatureSpecializationMangler(SpecializationPass P, Mangler &M,
 void
 FunctionSignatureSpecializationMangler::
 setArgumentDead(unsigned ArgNo) {
-  Args[ArgNo].first = ArgumentModifierIntBase(ArgumentModifier::Dead);
+  Args[ArgNo].first |= ArgumentModifierIntBase(ArgumentModifier::Dead);
 }
 
 void

lib/SIL/Projection.cpp

@@ -892,8 +892,7 @@ void
 ProjectionTreeNode::
 processUsersOfValue(ProjectionTree &Tree,
                     llvm::SmallVectorImpl<ValueNodePair> &Worklist,
-                    SILValue Value, LivenessKind Kind,
-                    llvm::DenseSet<SILInstruction *> &Releases) {
+                    SILValue Value) {
   DEBUG(llvm::dbgs() << "    Looking at Users:\n");
 
   // For all uses of V...
@@ -911,13 +910,6 @@ processUsersOfValue(ProjectionTree &Tree,
     if (!P.isValid()) {
       DEBUG(llvm::dbgs() << "            Failed to create projection. Adding "
             "to non projection user!\n");
-      // Is the user an epilogue release ?
-      if (Kind == IgnoreEpilogueReleases) {
-        bool EpilogueReleaseUser = !Releases.empty();
-        EpilogueReleaseUser &= Releases.find(User) != Releases.end();
-        if (EpilogueReleaseUser)
-          continue;
-      }
       addNonProjectionUser(Op);
       continue;
     }
@@ -949,12 +941,6 @@ processUsersOfValue(ProjectionTree &Tree,
       // The only projection which we do not currently handle are enums since we
       // may not know the correct case. This can be extended in the future.
       // Is the user an epilogue release ?
-      if (Kind == IgnoreEpilogueReleases) {
-        bool EpilogueReleaseUser = !Releases.empty();
-        EpilogueReleaseUser &= Releases.find(User) != Releases.end();
-        if (EpilogueReleaseUser)
-          continue;
-      }
       addNonProjectionUser(Op);
     }
   }
@@ -1157,21 +1143,7 @@ class NewAggregateBuilderMap {
 
 ProjectionTree::
 ProjectionTree(SILModule &Mod, llvm::BumpPtrAllocator &BPA, SILType BaseTy) 
-  : Mod(Mod), Allocator(BPA),
-    Kind(ProjectionTreeNode::LivenessKind::NormalUseLiveness) {
-  DEBUG(llvm::dbgs() << "Constructing Projection Tree For : " << BaseTy);
-
-  // Create the root node of the tree with our base type.
-  createRoot(BaseTy);
-
-  // Create the rest of the type tree lazily based on uses.
-}
-
-ProjectionTree::
-ProjectionTree(SILModule &Mod, llvm::BumpPtrAllocator &BPA, SILType BaseTy,
-               ProjectionTreeNode::LivenessKind Kind,
-               llvm::DenseSet<SILInstruction *> Insts)
-  : Mod(Mod), Allocator(BPA), Kind(Kind), EpilogueReleases(Insts) {
+  : Mod(Mod), Allocator(BPA) {
   DEBUG(llvm::dbgs() << "Constructing Projection Tree For : " << BaseTy);
 
   // Create the root node of the tree with our base type.
@@ -1187,8 +1159,6 @@ ProjectionTree::~ProjectionTree() {
 
 void
 ProjectionTree::initializeWithExistingTree(const ProjectionTree &PT) {
-  Kind = PT.Kind;
-  EpilogueReleases = PT.EpilogueReleases;
   LiveLeafIndices = PT.LiveLeafIndices;
   for (const auto &N : PT.ProjectionTreeNodes) {
     ProjectionTreeNodes.push_back(new (Allocator) ProjectionTreeNode(*N));
@@ -1285,7 +1255,7 @@ computeUsesAndLiveness(SILValue Base) {
     // If Value is not null, collate all users of Value the appropriate child
     // nodes and add such items to the worklist.
     if (Value) {
-      Node->processUsersOfValue(*this, UseWorklist, Value, Kind, EpilogueReleases);
+      Node->processUsersOfValue(*this, UseWorklist, Value);
     }
 
     // If this node is live due to a non projection user, propagate down its
@@ -1449,11 +1419,9 @@ replaceValueUsesWithLeafUses(SILBuilder &Builder, SILLocation Loc,
 
     // Grab the parent of this node.
     ProjectionTreeNode *Parent = Node->getParent(*this);
-    DEBUG(llvm::dbgs() << "        Visiting parent of leaf: " <<
-          Parent->getType() << "\n");
 
     // If the parent is dead, continue.
-    if (!Parent->IsLive) {
+    if (!Parent || !Parent->IsLive) {
       DEBUG(llvm::dbgs() << "        Parent is dead... continuing.\n");
       continue;
     }