Implement a Caller Analysis.

The analysis can tell all the callsites which calls a function in the module.

The analysis is computed and kept up-to-date lazily.

At the core of it, it keeps a list of functions that need to be recomputed for
the Caller/Callee relation to be precise and on every query, the analysis makes
sure to recompute them and clear the list before any query.

This is NFC right now. I am going to wire it up to function signature analysis
eventually.

Author: trentxintong

include/swift/SILOptimizer/Analysis/Analysis.def

@@ -25,6 +25,7 @@
 
 ANALYSIS(Alias)
 ANALYSIS(BasicCallee)
+ANALYSIS(Caller)
 ANALYSIS(ClassHierarchy)
 ANALYSIS(Destructor)
 ANALYSIS(Dominance)

include/swift/SILOptimizer/Analysis/Analysis.h

@@ -117,6 +117,8 @@ namespace swift {
     /// Invalidate all of the information for a specific function.
     virtual void invalidate(SILFunction *F, InvalidationKind K) {}
 
+    virtual void notifyAnalysisOfFunction(SILFunction *F) {}
+
     /// Verify the state of this analysis.
     virtual void verify() const {}
 

include/swift/SILOptimizer/Analysis/CallerAnalysis.h

@@ -0,0 +1,96 @@
+//===- CallerAnalysis.h - Determine callees per call site ------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILOPTIMIZER_ANALYSIS_CALLERANALYSIS_H
+#define SWIFT_SILOPTIMIZER_ANALYSIS_CALLERANALYSIS_H
+
+#include "swift/SILOptimizer/Analysis/Analysis.h"
+#include "swift/SIL/SILFunction.h"
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILModule.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/TinyPtrVector.h"
+
+namespace swift {
+
+using ApplyList = llvm::SmallVector<FullApplySite, 4>;
+
+struct CallerAnalysisFunctionInfo {
+  /// A list of all the functions this function calls.
+  llvm::SmallVector<SILFunction *, 4> Callees;
+  /// A map between all the callers and the callsites in them which
+  /// calls this function.
+  llvm::DenseMap<SILFunction *, ApplyList> CallSites; 
+};
+
+class CallerAnalysis : public SILAnalysis {
+  /// Current module we are analyzing.
+  SILModule &Mod;
+
+  /// A map between all the functions and their callsites in the module.
+  llvm::DenseMap<SILFunction *, CallerAnalysisFunctionInfo> CallInfo;
+
+  /// A list of functions that needs to be recomputed.
+  llvm::DenseSet<SILFunction *> RecomputeFunctionList;
+
+  /// Iterate over all the call sites in the function and update
+  /// FuncToCallsites.
+  void processFunctionCallSites(SILFunction *F); 
+
+  /// This function is about to become "unknown" to us. Invalidate any 
+  /// callsite information related to it.
+  void invalidateExistingCalleeRelation(SILFunction *F); 
+
+public:
+  CallerAnalysis(SILModule *M) : SILAnalysis(AnalysisKind::Caller), Mod(*M) {
+    // Make sure we compute everything first time called.
+    for(auto &F : Mod) {
+      RecomputeFunctionList.insert(&F);
+    }
+  }
+
+  static bool classof(const SILAnalysis *S) {
+    return S->getKind() == AnalysisKind::Caller;
+  }
+
+  virtual void notifyAnalysisOfFunction(SILFunction *F) {
+    RecomputeFunctionList.insert(F);
+  }
+
+  virtual void invalidate(SILFunction *F, InvalidationKind K) {
+    // This function has become "unknown" to us. Invalidate any callsite
+    // information related to this function.
+    invalidateExistingCalleeRelation(F);
+    // Make sure this function is recomputed next time.
+    RecomputeFunctionList.insert(F);
+  }
+
+  /// Return true if the function has a caller inside current module.
+  bool existCaller(SILFunction *F) {
+    // Recompute every function in the invaldiated function list and empty the
+    // list.
+    for (auto &F : RecomputeFunctionList) {
+      processFunctionCallSites(F);
+    }
+    RecomputeFunctionList.clear(); 
+
+    auto Iter = CallInfo.FindAndConstruct(F);
+    return !Iter.second.CallSites.empty();
+  }
+
+};
+
+} // end namespace swift
+
+#endif

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -125,6 +125,11 @@ class SILPassManager {
     CompletedPassesMap.clear();
   }
 
+  void notifyAnalysisOfFunction(SILFunction *F) {
+    for (auto AP : Analysis)
+      AP->notifyAnalysisOfFunction(F);
+  }
+
   /// \brief Broadcast the invalidation of the function to all analysis.
   void invalidateAnalysis(SILFunction *F,
                           SILAnalysis::InvalidationKind K) {

lib/SILOptimizer/Analysis/CMakeLists.txt

@@ -4,6 +4,7 @@ set(ANALYSIS_SOURCES
   Analysis/Analysis.cpp
   Analysis/ArraySemantic.cpp
   Analysis/BasicCalleeAnalysis.cpp
+  Analysis/CallerAnalysis.cpp
   Analysis/CFG.cpp
   Analysis/ClassHierarchyAnalysis.cpp
   Analysis/ColdBlockInfo.cpp

lib/SILOptimizer/Analysis/CallerAnalysis.cpp

@@ -0,0 +1,71 @@
+//===--- CallerAnalysis.cpp - Determine callsites to a function  ----------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/SILOptimizer/Analysis/CallerAnalysis.h"
+
+#include "swift/Basic/Fallthrough.h"
+#include "swift/SIL/SILModule.h"
+#include "swift/SILOptimizer/Utils/Local.h"
+
+using namespace swift;
+
+static SILFunction *getCallee(FullApplySite &Apply) {
+  SILValue Callee = Apply.getCallee();
+  //  Strip ThinToThickFunctionInst.
+  if (auto TTTF = dyn_cast<ThinToThickFunctionInst>(Callee)) {
+    Callee = TTTF->getOperand();
+  }   
+
+  // Find the target function.
+  auto *FRI = dyn_cast<FunctionRefInst>(Callee);
+  if (!FRI)
+    return nullptr;
+
+  return FRI->getReferencedFunction();
+}
+
+void CallerAnalysis::processFunctionCallSites(SILFunction *F) {
+  // Scan the whole module and search Apply sites.
+  for (auto &BB : *F) {
+    for (auto &II : BB) {
+      if (auto Apply = FullApplySite::isa(&II)) {
+        SILFunction *CalleeFn = getCallee(Apply);
+        if (!CalleeFn)
+          continue;
+        // Update the callee information for this fucntion.
+        CallerAnalysisFunctionInfo &CallerInfo
+                             = CallInfo.FindAndConstruct(F).second;
+        CallerInfo.Callees.push_back(CalleeFn);
+        
+        // Update the callsite information for the callee.
+        CallerAnalysisFunctionInfo &CalleeInfo
+                           = CallInfo.FindAndConstruct(CalleeFn).second;
+        CalleeInfo.CallSites[F].push_back(Apply);
+      }   
+    }   
+  }   
+}
+
+void CallerAnalysis::invalidateExistingCalleeRelation(SILFunction *F) {
+  CallerAnalysisFunctionInfo &CallerInfo = CallInfo.FindAndConstruct(F).second;
+  for (auto Callee : CallerInfo.Callees) {
+    CallerAnalysisFunctionInfo &CalleeInfo = CallInfo.find(Callee)->second;
+    CalleeInfo.CallSites[F].clear();
+  }
+}
+
+//===----------------------------------------------------------------------===//
+//                              Main Entry Point
+//===----------------------------------------------------------------------===//
+SILAnalysis *swift::createCallerAnalysis(SILModule *M) {
+  return new CallerAnalysis(M);
+}