Merge pull request #2309 from apple/revert-2284-SFSO

Revert "Simplify function signature optimization"

Author: trentxintong

include/swift/SIL/Mangle.h

@@ -104,7 +104,6 @@ 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,6 +730,11 @@ class ProjectionTreeNode {
       Initialized(false), IsLive(false) {}
 
 public:
+  enum LivenessKind : unsigned {
+    NormalUseLiveness = 0,
+    IgnoreEpilogueReleases = 1,
+  };
+
   class NewAggregateBuilder;
 
   ~ProjectionTreeNode() = default;
@@ -794,7 +799,8 @@ class ProjectionTreeNode {
 
   void processUsersOfValue(ProjectionTree &Tree,
                            llvm::SmallVectorImpl<ValueNodePair> &Worklist,
-                           SILValue Value);
+                           SILValue Value, ProjectionTreeNode::LivenessKind Kind,
+                           llvm::DenseSet<SILInstruction *> &Releases);
 
   void createNextLevelChildren(ProjectionTree &Tree);
 
@@ -810,6 +816,11 @@ 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;
@@ -820,6 +831,9 @@ 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,9 +28,12 @@
 
 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;
 
@@ -45,9 +48,6 @@ 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,13 +73,17 @@ 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)
+  ArgumentDescriptor(llvm::BumpPtrAllocator &BPA, SILArgument *A,
+                     ReleaseSet Releases)
       : 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())  {}
+        ProjTree(A->getModule(), BPA, A->getType(), 
+        ProjectionTreeNode::LivenessKind::IgnoreEpilogueReleases, 
+        Releases) {
+    ProjTree.computeUsesAndLiveness(A);
+  }
 
   ArgumentDescriptor(const ArgumentDescriptor &) = delete;
   ArgumentDescriptor(ArgumentDescriptor &&) = default;
@@ -91,6 +95,29 @@ 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();
   }
@@ -123,19 +150,15 @@ 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(), OwnedToGuaranteed(false) {}
+  ResultDescriptor() {};
+  ResultDescriptor(SILResultInfo RI) : ResultInfo(RI), CalleeRetain() {}
 
   ResultDescriptor(const ResultDescriptor &) = delete;
   ResultDescriptor(ResultDescriptor &&) = default;
@@ -148,12 +171,100 @@ struct ResultDescriptor {
   }
 };
 
-/// Returns true if F is a function which the pass know show to specialize
-/// function signatures for.
+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);
+  }
+};
+
+
+
 bool canSpecializeFunction(SILFunction *F);
 
-/// Return true if this argument is used in a non-trivial way.
-bool hasNonTrivialNonDebugUse(SILArgument *Arg);
+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);
+
 
 } // 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,7 +892,8 @@ void
 ProjectionTreeNode::
 processUsersOfValue(ProjectionTree &Tree,
                     llvm::SmallVectorImpl<ValueNodePair> &Worklist,
-                    SILValue Value) {
+                    SILValue Value, LivenessKind Kind,
+                    llvm::DenseSet<SILInstruction *> &Releases) {
   DEBUG(llvm::dbgs() << "    Looking at Users:\n");
 
   // For all uses of V...
@@ -910,6 +911,13 @@ 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;
     }
@@ -941,6 +949,12 @@ 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);
     }
   }
@@ -1143,7 +1157,21 @@ class NewAggregateBuilderMap {
 
 ProjectionTree::
 ProjectionTree(SILModule &Mod, llvm::BumpPtrAllocator &BPA, SILType BaseTy) 
-  : Mod(Mod), Allocator(BPA) {
+  : 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) {
   DEBUG(llvm::dbgs() << "Constructing Projection Tree For : " << BaseTy);
 
   // Create the root node of the tree with our base type.
@@ -1159,6 +1187,8 @@ 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));
@@ -1255,7 +1285,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);
+      Node->processUsersOfValue(*this, UseWorklist, Value, Kind, EpilogueReleases);
     }
 
     // If this node is live due to a non projection user, propagate down its