Merge pull request #2310 from trentxintong/SFSO

Simplify function signature optimzation and fix a memory leak in function signature.

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);
 
@@ -814,12 +808,8 @@ class ProjectionTree {
 
   SILModule &Mod;
 
-  llvm::BumpPtrAllocator &Allocator;
-
-  /// The way we compute what is live and what is dead.
-  ProjectionTreeNode::LivenessKind Kind;
-
-  llvm::DenseSet<SILInstruction *> EpilogueReleases;
+  /// The allocator we use to allocate ProjectionTreeNodes in the tree.
+  llvm::SpecificBumpPtrAllocator<ProjectionTreeNode> Allocator;
 
   // A common pattern is a 3 field struct.
   llvm::SmallVector<ProjectionTreeNode *, 4> ProjectionTreeNodes;
@@ -829,15 +819,10 @@ class ProjectionTree {
 
 public:
   /// 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);
+  ProjectionTree(SILModule &Mod, SILType BaseTy);
   /// Construct an uninitialized projection tree, which can then be
   /// initialized by initializeWithExistingTree.
-  ProjectionTree(SILModule &Mod, llvm::BumpPtrAllocator &Allocator) 
-    : Mod(Mod), Allocator(Allocator) {}
+  ProjectionTree(SILModule &Mod) : Mod(Mod)  {}
   ~ProjectionTree();
   ProjectionTree(const ProjectionTree &) = delete;
   ProjectionTree(ProjectionTree &&) = default;
@@ -950,15 +935,16 @@ class ProjectionTree {
   void createRoot(SILType BaseTy) {
     assert(ProjectionTreeNodes.empty() &&
            "Should only create root when ProjectionTreeNodes is empty");
-    auto *Node = new (Allocator) ProjectionTreeNode(BaseTy);
+    auto *Node = new (Allocator.Allocate()) ProjectionTreeNode(BaseTy);
     ProjectionTreeNodes.push_back(Node);
   }
 
   ProjectionTreeNode *createChild(ProjectionTreeNode *Parent,
                                      SILType BaseTy,
                                      const Projection &P) {
     unsigned Index = ProjectionTreeNodes.size();
-    auto *Node = new (Allocator) ProjectionTreeNode(Parent, Index, BaseTy, P);
+    auto *Node = new (Allocator.Allocate()) ProjectionTreeNode(Parent, Index,
+                                                               BaseTy, P);
     ProjectionTreeNodes.push_back(Node);
     return ProjectionTreeNodes[Index];
   }

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(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(), 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