copy required stuff from SideEffectAnalysis to AccessStorageAnalysis

... before we delete SideEffectAnalysis at all.

Author: eeckstein

include/swift/SILOptimizer/Analysis/AccessStorageAnalysis.h

@@ -19,22 +19,19 @@
 // FunctionAccessStorage.unidentifiedAccess. This does not imply that all
 // accesses within the function have Unidentified AccessStorage.
 //
-// Note: This interprocedural analysis can be easily augmented to simultaneously
-// compute FunctionSideEffects, without using a separate analysis, by adding
-// FunctionSideEffects as a member of FunctionAccessStorage. However, passes
-// that use AccessStorageAnalysis do not currently need SideEffectAnalysis.
-//
 //===----------------------------------------------------------------------===//
 #ifndef SWIFT_SILOPTIMIZER_ANALYSIS_ACCESSED_STORAGE_ANALYSIS_H
 #define SWIFT_SILOPTIMIZER_ANALYSIS_ACCESSED_STORAGE_ANALYSIS_H
 
 #include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
-#include "swift/SILOptimizer/Analysis/SideEffectAnalysis.h"
+#include "swift/SILOptimizer/Analysis/BottomUpIPAnalysis.h"
 
 namespace swift {
 
+class BasicCalleeAnalysis;
+
 /// Information about a formal access within a function pertaining to a
 /// particular AccessStorage location.
 class StorageAccessInfo : public AccessStorage {
@@ -340,16 +337,121 @@ class FunctionAccessStorage {
 /// Use the GenericFunctionEffectAnalysis API to get the results of the analysis:
 /// - geEffects(SILFunction*)
 /// - getCallSiteEffects(FunctionEffects &callEffects, FullApplySite fullApply)
-class AccessStorageAnalysis
-    : public GenericFunctionEffectAnalysis<FunctionAccessStorage> {
+class AccessStorageAnalysis : public BottomUpIPAnalysis {
+
+  /// Stores the analysis data, e.g. side-effects, for a function.
+  struct FunctionInfo : public FunctionInfoBase<FunctionInfo> {
+
+    /// The function effects.
+    FunctionAccessStorage functionEffects;
+
+    /// Back-link to the function.
+    SILFunction *F;
+
+    /// Used during recomputation to indicate if the side-effects of a caller
+    /// must be updated.
+    bool needUpdateCallers = false;
+
+    FunctionInfo(SILFunction *F) : F(F) {}
+
+    /// Clears the analysis data on invalidation.
+    void clear() { functionEffects.clear(); }
+  };
+
+  typedef BottomUpFunctionOrder<FunctionInfo> FunctionOrder;
+
+  enum {
+    /// The maximum call-graph recursion depth for recomputing the analysis.
+    /// This is a relatively small number to reduce compile time in case of
+    /// large cycles in the call-graph.
+    /// In case of no cycles, we should not hit this limit at all because the
+    /// pass manager processes functions in bottom-up order.
+    MaxRecursionDepth = 5
+  };
+
+  /// All the function effect information for the whole module.
+  llvm::DenseMap<SILFunction *, FunctionInfo *> functionInfoMap;
+
+  /// The allocator for the map of values in FunctionInfoMap.
+  llvm::SpecificBumpPtrAllocator<FunctionInfo> allocator;
+
+  /// Callee analysis, used for determining the callees at call sites.
+  BasicCalleeAnalysis *BCA;
+
 public:
   AccessStorageAnalysis()
-      : GenericFunctionEffectAnalysis<FunctionAccessStorage>(
-            SILAnalysisKind::AccessStorage) {}
+      : BottomUpIPAnalysis(SILAnalysisKind::AccessStorage) {}
 
   static bool classof(const SILAnalysis *S) {
     return S->getKind() == SILAnalysisKind::AccessStorage;
   }
+
+  const FunctionAccessStorage &getEffects(SILFunction *F) {
+    FunctionInfo *functionInfo = getFunctionInfo(F);
+    if (!functionInfo->isValid())
+      recompute(functionInfo);
+    return functionInfo->functionEffects;
+  }
+
+  /// Get the merged effects of all callees at the given call site from the
+  /// callee's perspective (don't transform parameter effects).
+  void getCalleeEffects(FunctionAccessStorage &calleeEffects,
+                        FullApplySite fullApply);
+
+  /// Get the merge effects of all callees at the given call site from the
+  /// caller's perspective. Parameter effects are translated into information
+  /// for the caller's arguments, and local effects are dropped.
+  void getCallSiteEffects(FunctionAccessStorage &callEffects,
+                          FullApplySite fullApply) {
+    FunctionAccessStorage calleeEffects;
+    getCalleeEffects(calleeEffects, fullApply);
+    callEffects.mergeFromApply(calleeEffects, fullApply);
+  }
+
+  BasicCalleeAnalysis *getBasicCalleeAnalysis() { return BCA; }
+
+  virtual void initialize(SILPassManager *PM) override;
+
+  /// Invalidate all information in this analysis.
+  virtual void invalidate() override;
+
+  /// Invalidate all of the information for a specific function.
+  virtual void invalidate(SILFunction *F, InvalidationKind K) override;
+
+  /// Notify the analysis about a newly created function.
+  virtual void notifyAddedOrModifiedFunction(SILFunction *F) override {}
+
+  /// Notify the analysis about a function which will be deleted from the
+  /// module.
+  virtual void notifyWillDeleteFunction(SILFunction *F) override {
+    invalidate(F, InvalidationKind::Nothing);
+  }
+
+  /// Notify the analysis about changed witness or vtables.
+  virtual void invalidateFunctionTables() override {}
+
+private:
+  /// Gets or creates FunctionAccessStorage for \p F.
+  FunctionInfo *getFunctionInfo(SILFunction *F) {
+    FunctionInfo *&functionInfo = functionInfoMap[F];
+    if (!functionInfo) {
+      functionInfo = new (allocator.Allocate()) FunctionInfo(F);
+    }
+    return functionInfo;
+  }
+
+  /// Analyze the side-effects of a function, including called functions.
+  /// Visited callees are added to \p BottomUpOrder until \p RecursionDepth
+  /// reaches MaxRecursionDepth.
+  void analyzeFunction(FunctionInfo *functionInfo, FunctionOrder &bottomUpOrder,
+                       int recursionDepth);
+
+  void analyzeCall(FunctionInfo *functionInfo, FullApplySite fullApply,
+                   FunctionOrder &bottomUpOrder, int recursionDepth);
+
+  /// Recomputes the side-effect information for the function \p Initial and
+  /// all called functions, up to a recursion depth of MaxRecursionDepth.
+  void recompute(FunctionInfo *initialInfo);
 };
 
 } // end namespace swift

lib/SILOptimizer/Analysis/AccessStorageAnalysis.cpp

@@ -357,23 +357,19 @@ bool FunctionAccessStorage::summarizeFunction(SILFunction *F) {
   // conservative value, since analyzeInstruction will never be called.
   //
   // If FunctionSideEffects can be summarized, use that information.
-  FunctionSideEffects functionSideEffects;
-  if (!functionSideEffects.summarizeFunction(F)) {
+
+  auto b = F->getMemoryBehavior(/*observeRetains*/ false);
+  if (b == SILInstruction::MemoryBehavior::MayHaveSideEffects) {
     setWorstEffects();
     // May as well consider this a successful summary since there are no
     // instructions to visit anyway.
     return true;
   }
-  bool mayRead = functionSideEffects.getGlobalEffects().mayRead();
-  bool mayWrite = functionSideEffects.getGlobalEffects().mayWrite();
-  for (auto &paramEffects : functionSideEffects.getParameterEffects()) {
-    mayRead |= paramEffects.mayRead();
-    mayWrite |= paramEffects.mayWrite();
-  }
-  if (mayWrite)
+  if (b >= SILInstruction::MemoryBehavior::MayWrite) {
     accessResult.setUnidentifiedAccess(SILAccessKind::Modify);
-  else if (mayRead)
+  } else if (b == SILInstruction::MemoryBehavior::MayRead) {
     accessResult.setUnidentifiedAccess(SILAccessKind::Read);
+  }
 
   // If function side effects is "readnone" then this result will have an empty
   // storageAccessSet and unidentifiedAccess == None.
@@ -393,6 +389,161 @@ bool FunctionAccessStorage::summarizeCall(FullApplySite fullApply) {
   return false;
 }
 
+void AccessStorageAnalysis::initialize(
+    SILPassManager *PM) {
+  BCA = PM->getAnalysis<BasicCalleeAnalysis>();
+}
+
+void AccessStorageAnalysis::invalidate() {
+  functionInfoMap.clear();
+  allocator.DestroyAll();
+  LLVM_DEBUG(llvm::dbgs() << "invalidate all\n");
+}
+
+void AccessStorageAnalysis::invalidate(
+    SILFunction *F, InvalidationKind K) {
+  if (FunctionInfo *FInfo = functionInfoMap.lookup(F)) {
+    LLVM_DEBUG(llvm::dbgs() << "  invalidate " << FInfo->F->getName() << '\n');
+    invalidateIncludingAllCallers(FInfo);
+  }
+}
+
+void AccessStorageAnalysis::getCalleeEffects(
+    FunctionAccessStorage &calleeEffects, FullApplySite fullApply) {
+  if (calleeEffects.summarizeCall(fullApply))
+    return;
+
+  auto callees = BCA->getCalleeList(fullApply);
+  if (!callees.allCalleesVisible() ||
+      // @callee_owned function calls implicitly release the context, which
+      // may call deinits of boxed values.
+      // TODO: be less conservative about what destructors might be called.
+      fullApply.getOrigCalleeType()->isCalleeConsumed()) {
+    calleeEffects.setWorstEffects();
+    return;
+  }
+
+  // We can see all the callees, so merge the effects from all of them.
+  for (auto *callee : callees)
+    calleeEffects.mergeFrom(getEffects(callee));
+}
+
+void AccessStorageAnalysis::analyzeFunction(
+    FunctionInfo *functionInfo, FunctionOrder &bottomUpOrder,
+    int recursionDepth) {
+  functionInfo->needUpdateCallers = true;
+
+  if (bottomUpOrder.prepareForVisiting(functionInfo))
+    return;
+
+  auto *F = functionInfo->F;
+  if (functionInfo->functionEffects.summarizeFunction(F))
+    return;
+
+  LLVM_DEBUG(llvm::dbgs() << "  >> analyze " << F->getName() << '\n');
+
+  // Check all instructions of the function
+  for (auto &BB : *F) {
+    for (auto &I : BB) {
+      if (auto fullApply = FullApplySite::isa(&I))
+        analyzeCall(functionInfo, fullApply, bottomUpOrder, recursionDepth);
+      else
+        functionInfo->functionEffects.analyzeInstruction(&I);
+    }
+  }
+  LLVM_DEBUG(llvm::dbgs() << "  << finished " << F->getName() << '\n');
+}
+
+void AccessStorageAnalysis::analyzeCall(
+    FunctionInfo *functionInfo, FullApplySite fullApply,
+    FunctionOrder &bottomUpOrder, int recursionDepth) {
+
+  FunctionAccessStorage applyEffects;
+  if (applyEffects.summarizeCall(fullApply)) {
+    functionInfo->functionEffects.mergeFromApply(applyEffects, fullApply);
+    return;
+  }
+
+  if (recursionDepth >= MaxRecursionDepth) {
+    functionInfo->functionEffects.setWorstEffects();
+    return;
+  }
+  CalleeList callees = BCA->getCalleeList(fullApply);
+  if (!callees.allCalleesVisible() ||
+      // @callee_owned function calls implicitly release the context, which
+      // may call deinits of boxed values.
+      // TODO: be less conservative about what destructors might be called.
+      fullApply.getOrigCalleeType()->isCalleeConsumed()) {
+    functionInfo->functionEffects.setWorstEffects();
+    return;
+  }
+  // Derive the effects of the apply from the known callees.
+  // Defer merging callee effects until the callee is scheduled
+  for (SILFunction *callee : callees) {
+    FunctionInfo *calleeInfo = getFunctionInfo(callee);
+    calleeInfo->addCaller(functionInfo, fullApply);
+    if (!calleeInfo->isVisited()) {
+      // Recursively visit the called function.
+      analyzeFunction(calleeInfo, bottomUpOrder, recursionDepth + 1);
+      bottomUpOrder.tryToSchedule(calleeInfo);
+    }
+  }
+}
+
+void AccessStorageAnalysis::recompute(
+    FunctionInfo *initialInfo) {
+  allocNewUpdateID();
+
+  LLVM_DEBUG(llvm::dbgs() << "recompute function-effect analysis with UpdateID "
+                          << getCurrentUpdateID() << '\n');
+
+  // Collect and analyze all functions to recompute, starting at initialInfo.
+  FunctionOrder bottomUpOrder(getCurrentUpdateID());
+  analyzeFunction(initialInfo, bottomUpOrder, 0);
+
+  // Build the bottom-up order.
+  bottomUpOrder.tryToSchedule(initialInfo);
+  bottomUpOrder.finishScheduling();
+
+  // Second step: propagate the side-effect information up the call-graph until
+  // it stabilizes.
+  bool needAnotherIteration;
+  do {
+    LLVM_DEBUG(llvm::dbgs() << "new iteration\n");
+    needAnotherIteration = false;
+
+    for (FunctionInfo *functionInfo : bottomUpOrder) {
+      if (!functionInfo->needUpdateCallers)
+        continue;
+
+      LLVM_DEBUG(llvm::dbgs() << "  update callers of "
+                              << functionInfo->F->getName() << '\n');
+      functionInfo->needUpdateCallers = false;
+
+      // Propagate the function effects to all callers.
+      for (const auto &E : functionInfo->getCallers()) {
+        assert(E.isValid());
+
+        // Only include callers which we are actually recomputing.
+        if (!bottomUpOrder.wasRecomputedWithCurrentUpdateID(E.Caller))
+          continue;
+
+        LLVM_DEBUG(llvm::dbgs() << "    merge into caller "
+                                << E.Caller->F->getName() << '\n');
+
+        if (E.Caller->functionEffects.mergeFromApply(
+                functionInfo->functionEffects, FullApplySite(E.FAS))) {
+          E.Caller->needUpdateCallers = true;
+          if (!E.Caller->isScheduledAfter(functionInfo)) {
+            // This happens if we have a cycle in the call-graph.
+            needAnotherIteration = true;
+          }
+        }
+      }
+    }
+  } while (needAnotherIteration);
+}
+
 SILAnalysis *swift::createAccessStorageAnalysis(SILModule *) {
   return new AccessStorageAnalysis();
 }