swift side effects: add CalleeAnalysis.getSideEffects(of: apply)

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -43,6 +43,51 @@ public struct CalleeAnalysis {
     }
     return FunctionArray(bridged: bridgedDtors)
   }
+
+  /// Returns the global (i.e. not argument specific) side effects of an apply.
+  public func getSideEffects(of apply: ApplySite) -> SideEffects.GlobalEffects {
+    guard let callees = getCallees(callee: apply.callee) else {
+      return .worstEffects
+    }
+
+    var result = SideEffects.GlobalEffects()
+    for callee in callees {
+      let calleeEffects = callee.getSideEffects()
+      result.merge(with: calleeEffects)
+    }
+    return result
+  }
+
+  /// Returns the argument specific side effects of an apply.
+  public func getSideEffects(of apply: ApplySite, forArgument argumentIdx: Int, path: SmallProjectionPath) -> SideEffects.GlobalEffects {
+    let calleeArgIdx = apply.calleeArgIndex(callerArgIndex: argumentIdx)
+    let convention = apply.getArgumentConvention(calleeArgIndex: calleeArgIdx)
+    let argument = apply.arguments[argumentIdx].at(path)
+
+    guard let callees = getCallees(callee: apply.callee) else {
+      return .worstEffects.restrictedTo(argument: argument, withConvention: convention)
+    }
+  
+    var result = SideEffects.GlobalEffects()
+    for callee in callees {
+      let calleeEffects = callee.getSideEffects(forArgument: argument,
+                                                atIndex: calleeArgIdx,
+                                                withConvention: convention)
+      result.merge(with: calleeEffects)
+    }
+    return result.restrictedTo(argument: argument, withConvention: convention)
+  }
+
+  static func register() {
+    CalleeAnalysis_register(
+      // getMemBehaviorFn
+      { (bridgedCtxt: BridgedPassContext, bridgedApply: BridgedInstruction, observeRetains: Bool) -> BridgedMemoryBehavior in
+        let context = PassContext(_bridged: bridgedCtxt)
+        let apply = bridgedApply.instruction as! ApplySite
+        let e = context.calleeAnalysis.getSideEffects(of: apply)
+        return e.getMemBehavior(observeRetains: observeRetains)
+      })
+  }
 }
 
 public struct FunctionArray : RandomAccessCollection, FormattedLikeArray {

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -17,6 +17,7 @@ import Parse
 @_cdecl("initializeSwiftModules")
 public func initializeSwiftModules() {
   registerSILClasses()
+  registerAnalysis()
   registerSwiftPasses()
   initializeSwiftParseModules()
 }
@@ -45,6 +46,10 @@ private func registerPass<InstType: Instruction>(
   }
 }
 
+private func registerAnalysis() {
+  CalleeAnalysis.register()
+}
+
 private func registerSwiftPasses() {
   // Module passes
   registerPass(stackProtection, { stackProtection.run($0) })

include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h

@@ -31,6 +31,7 @@ class ClassDecl;
 class SILFunction;
 class SILModule;
 class SILWitnessTable;
+class SILPassManager;
 
 /// CalleeList is a data structure representing the list of potential
 /// callees at a particular apply site. It also has a query that
@@ -166,16 +167,20 @@ class CalleeCache {
 
 class BasicCalleeAnalysis : public SILAnalysis {
   SILModule &M;
+  SILPassManager *pm = nullptr;
   std::unique_ptr<CalleeCache> Cache;
 
 public:
+
   BasicCalleeAnalysis(SILModule *M)
       : SILAnalysis(SILAnalysisKind::BasicCallee), M(*M), Cache(nullptr) {}
 
   static bool classof(const SILAnalysis *S) {
     return S->getKind() == SILAnalysisKind::BasicCallee;
   }
 
+  virtual void initialize(SILPassManager *pm) override { this->pm = pm; }
+
   /// Invalidate all information in this analysis.
   virtual void invalidate() override {
     Cache.reset();
@@ -228,6 +233,8 @@ class BasicCalleeAnalysis : public SILAnalysis {
     updateCache();
     return Cache->getDestructors(type, isExactType);
   }
+
+  SILInstruction::MemoryBehavior getMemoryBehavior(ApplySite as, bool observeRetains);
 };
 
 } // end namespace swift

include/swift/SILOptimizer/OptimizerBridging.h

@@ -128,6 +128,11 @@ SwiftInt PostDominatorTree_postDominates(BridgedPostDomTree pdomTree,
                                          BridgedBasicBlock dominating,
                                          BridgedBasicBlock dominated);
 
+typedef BridgedMemoryBehavior(* _Nonnull CalleeAnalysisGetMemBehvaiorFn)(
+      BridgedPassContext context, BridgedInstruction apply, bool observeRetains);
+
+void CalleeAnalysis_register(CalleeAnalysisGetMemBehvaiorFn getEffectsFn);
+
 BridgedSlab PassContext_getNextSlab(BridgedSlab slab);
 BridgedSlab PassContext_getPreviousSlab(BridgedSlab slab);
 BridgedSlab PassContext_allocSlab(BridgedPassContext passContext,

lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp

@@ -27,6 +27,9 @@
 
 using namespace swift;
 
+// Bridging functions.
+static CalleeAnalysisGetMemBehvaiorFn getMemBehvaiorFunction = nullptr;
+
 void CalleeList::dump() const {
   print(llvm::errs());
 }
@@ -311,6 +314,17 @@ CalleeList CalleeCache::getDestructors(SILType type, bool isExactType) const {
   return getCalleeList(SILDeclRef(classDecl->getDestructor()));
 }
 
+SILInstruction::MemoryBehavior BasicCalleeAnalysis::
+getMemoryBehavior(ApplySite as, bool observeRetains) {
+  if (getMemBehvaiorFunction) {
+    auto b = getMemBehvaiorFunction({pm->getSwiftPassInvocation()},
+                                    {as.getInstruction()->asSILNode()},
+                                    observeRetains);
+    return (SILInstruction::MemoryBehavior)b;
+  }
+  return SILInstruction::MemoryBehavior::MayHaveSideEffects;
+}
+
 void BasicCalleeAnalysis::dump() const {
   print(llvm::errs());
 }
@@ -334,6 +348,10 @@ void BasicCalleeAnalysis::print(llvm::raw_ostream &os) const {
 //                            Swift Bridging
 //===----------------------------------------------------------------------===//
 
+void CalleeAnalysis_register(CalleeAnalysisGetMemBehvaiorFn getMemBehvaiorFn) {
+  getMemBehvaiorFunction = getMemBehvaiorFn;
+}
+
 BridgedCalleeList CalleeAnalysis_getCallees(BridgedCalleeAnalysis calleeAnalysis,
                                             BridgedValue callee) {
   BasicCalleeAnalysis *bca = static_cast<BasicCalleeAnalysis *>(calleeAnalysis.bca);