Merge pull request #2284 from trentxintong/SFSO

Simplify function signature optimization

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/Utils/FunctionSignatureOptUtils.h

@@ -28,12 +28,9 @@
 
 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;
 
@@ -48,6 +45,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 +73,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)
+  ArgumentDescriptor(llvm::BumpPtrAllocator &BPA, SILArgument *A)
       : Arg(A), 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,29 +91,6 @@ 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();
   }
@@ -150,15 +123,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 +148,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