Reinstate "Moves SignatureAnalyzer and ArgumentDescriptor/ResultDescriptor into

a separate analysis pass.

This pass is run on every function and the optimized signature is return'ed through the
getArgDescList and getResultDescList.

Next step is to split to cloning and callsite rewriting into their own function passes.

rdar://24730896
"

Author: trentxintong

include/swift/SIL/Projection.h

@@ -832,6 +832,10 @@ class ProjectionTree {
   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) 
+    : Mod(Mod), Allocator(Allocator) {}
   ~ProjectionTree();
   ProjectionTree(const ProjectionTree &) = delete;
   ProjectionTree(ProjectionTree &&) = default;
@@ -842,6 +846,10 @@ class ProjectionTree {
   /// All debug instructions (debug_value, debug_value_addr) are ignored.
   void computeUsesAndLiveness(SILValue Base);
 
+  /// Initialize an empty projection tree with an existing, computed projection
+  /// tree.
+  void initializeWithExistingTree(const ProjectionTree &PT);
+
   /// Create a root SILValue iout of the given leaf node values by walking on
   /// the projection tree.
   SILValue computeExplodedArgumentValue(SILBuilder &Builder,

include/swift/SILOptimizer/Analysis/Analysis.def

@@ -29,6 +29,7 @@ ANALYSIS(ClassHierarchy)
 ANALYSIS(Destructor)
 ANALYSIS(Dominance)
 ANALYSIS(Escape)
+ANALYSIS(FunctionSignature)
 ANALYSIS(InductionVariable)
 ANALYSIS(Loop)
 ANALYSIS(LoopRegion)

include/swift/SILOptimizer/Analysis/FunctionSignatureAnalysis.h

@@ -0,0 +1,268 @@
+//===--- FunctionSignatureAnalysis.h ----------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This is an analysis that determines how a function signature should be
+// optimized.
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILOPTIMIZER_ANALYSIS_FUNCTIONSIGNATUREANALYSIS_H
+#define SWIFT_SILOPTIMIZER_ANALYSIS_FUNCTIONSIGNATUREANALYSIS_H
+
+#include "swift/SIL/Projection.h"
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILValue.h"
+#include "swift/SIL/SILArgument.h"
+#include "swift/SILOptimizer/Analysis/Analysis.h"
+#include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
+#include "swift/SILOptimizer/Analysis/ARCAnalysis.h"
+#include "swift/SILOptimizer/Analysis/RCIdentityAnalysis.h"
+#include "swift/SILOptimizer/Utils/Local.h"
+#include "swift/SILOptimizer/PassManager/PassManager.h"
+
+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;
+
+  /// The original index of this argument.
+  unsigned Index;
+
+  /// The original decl of this Argument.
+  const ValueDecl *Decl;
+
+  /// Was this parameter originally dead?
+  bool IsEntirelyDead;
+
+  /// Should the argument be exploded ?
+  bool Explode;
+
+  /// 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;
+
+  /// The projection tree of this arguments.
+  ProjectionTree ProjTree;
+
+  ArgumentDescriptor() = delete;
+
+  /// 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.
+  ArgumentDescriptor(llvm::BumpPtrAllocator &BPA, SILArgument *A,
+                     ReleaseSet Releases)
+      : Arg(A), Index(A->getIndex()),
+        Decl(A->getDecl()), IsEntirelyDead(false), Explode(false),
+        IsIndirectResult(A->isIndirectResult()),
+        CalleeRelease(), CalleeReleaseInThrowBlock(),
+        ProjTree(A->getModule(), BPA, A->getType(), 
+        ProjectionTreeNode::LivenessKind::IgnoreEpilogueReleases, 
+        Releases) {
+    ProjTree.computeUsesAndLiveness(A);
+  }
+
+  ArgumentDescriptor(const ArgumentDescriptor &) = delete;
+  ArgumentDescriptor(ArgumentDescriptor &&) = default;
+  ArgumentDescriptor &operator=(const ArgumentDescriptor &) = delete;
+  ArgumentDescriptor &operator=(ArgumentDescriptor &&) = default;
+
+  /// \returns true if this argument's convention is P.
+  bool hasConvention(SILArgumentConvention P) const {
+    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 {
+    // We cannot optimize the argument.
+    if (!canOptimizeLiveArg())
+      return false;
+
+    // See if the projection tree consists of potentially multiple levels of
+    // structs containing one field. In such a case, there is no point in
+    // exploding the argument.
+    if (ProjTree.isSingleton())
+      return false;
+
+    size_t explosionSize = ProjTree.liveLeafCount();
+    return explosionSize >= 1 && explosionSize <= 3;
+  }
+};
+
+/// A structure that maintains all of the information about a specific
+/// direct result that we are tracking.
+struct ResultDescriptor {
+  /// The original parameter info of this argument.
+  SILResultInfo ResultInfo;
+
+  /// 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.
+  RetainList CalleeRetain;
+
+  /// 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(const ResultDescriptor &) = delete;
+  ResultDescriptor(ResultDescriptor &&) = default;
+  ResultDescriptor &operator=(const ResultDescriptor &) = delete;
+  ResultDescriptor &operator=(ResultDescriptor &&) = default;
+
+  /// \returns true if this argument's ParameterConvention is P.
+  bool hasConvention(ResultConvention R) const {
+    return ResultInfo.getConvention() == R;
+  }
+};
+
+class FunctionSignatureInfo {
+  /// 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) :
+  F(F), Allocator(BPA), AA(AA), RCFI(RCFI), MayBindDynamicSelf(computeMayBindDynamicSelf(F)) {}
+
+  bool 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);
+  }
+};
+
+class FunctionSignatureAnalysis : public FunctionAnalysisBase<FunctionSignatureInfo> {
+  /// The alias analysis currently using.
+  AliasAnalysis *AA;
+
+  /// The rc-identity analysis currently using.
+  RCIdentityAnalysis *RCIA;
+
+  llvm::BumpPtrAllocator BPA;
+public:
+  FunctionSignatureAnalysis(SILModule *)
+    : FunctionAnalysisBase<FunctionSignatureInfo>(AnalysisKind::FunctionSignature),
+      AA(nullptr), RCIA(nullptr) {}
+
+  FunctionSignatureAnalysis(const FunctionSignatureAnalysis &) = delete;
+  FunctionSignatureAnalysis &operator=(const FunctionSignatureAnalysis &) = delete;
+
+  static bool classof(const SILAnalysis *S) {
+    return S->getKind() == AnalysisKind::FunctionSignature;
+  }
+
+  virtual void initialize(SILPassManager *PM) override;
+  
+  virtual FunctionSignatureInfo *newFunctionAnalysis(SILFunction *F) override {
+    return new FunctionSignatureInfo(F, BPA, AA, RCIA->get(F));
+  }
+
+  virtual bool shouldInvalidate(SILAnalysis::InvalidationKind K) override {
+    return true;
+  }
+ };
+} // end swift namespace
+
+#endif

lib/SIL/Projection.cpp

@@ -1168,8 +1168,18 @@ ProjectionTree(SILModule &Mod, llvm::BumpPtrAllocator &BPA, SILType BaseTy,
 }
 
 ProjectionTree::~ProjectionTree() {
-  for (auto *N : ProjectionTreeNodes)
-    N->~ProjectionTreeNode();
+  // Do nothing !. Eventually the all the projection tree nodes will be freed
+  // when the BPA allocator is free.
+}
+
+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));
+  }
 }
 
 SILValue

lib/SILOptimizer/Analysis/CMakeLists.txt

@@ -10,6 +10,7 @@ set(ANALYSIS_SOURCES
   Analysis/DestructorAnalysis.cpp
   Analysis/EscapeAnalysis.cpp
   Analysis/FunctionOrder.cpp
+  Analysis/FunctionSignatureAnalysis.cpp
   Analysis/IVAnalysis.cpp
   Analysis/LoopAnalysis.cpp
   Analysis/LoopRegionAnalysis.cpp