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

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -21,6 +21,13 @@ public struct CalleeAnalysis {
       // isDeinitBarrierFn:
       { (inst : BridgedInstruction, bca: BridgedCalleeAnalysis) -> Bool in
         return inst.instruction.isDeinitBarrier(bca.analysis)
+      },
+      // 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)
       }
     )
   }
@@ -52,6 +59,40 @@ 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)
+  }
 }
 
 extension FullApplySite {

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);
 };
 
 bool isDeinitBarrier(SILInstruction *const instruction,

include/swift/SILOptimizer/OptimizerBridging.h

@@ -41,8 +41,11 @@ typedef struct {
 } BridgedCalleeAnalysis;
 
 typedef bool (* _Nonnull InstructionIsDeinitBarrierFn)(BridgedInstruction, BridgedCalleeAnalysis bca);
+typedef BridgedMemoryBehavior(* _Nonnull CalleeAnalysisGetMemBehvaiorFn)(
+      BridgedPassContext context, BridgedInstruction apply, bool observeRetains);
 
-void CalleeAnalysis_register(InstructionIsDeinitBarrierFn isDeinitBarrierFn);
+void CalleeAnalysis_register(InstructionIsDeinitBarrierFn isDeinitBarrierFn,
+                             CalleeAnalysisGetMemBehvaiorFn getEffectsFn);
 
 typedef struct {
   void * _Nullable dea;

lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp

@@ -367,10 +367,24 @@ BridgedFunction BridgedFunctionArray_get(BridgedCalleeList callees,
 }
 
 static InstructionIsDeinitBarrierFn instructionIsDeinitBarrierFunction;
+static CalleeAnalysisGetMemBehvaiorFn getMemBehvaiorFunction = nullptr;
 
 void CalleeAnalysis_register(
-    InstructionIsDeinitBarrierFn instructionIsDeinitBarrierFn) {
+    InstructionIsDeinitBarrierFn instructionIsDeinitBarrierFn,
+    CalleeAnalysisGetMemBehvaiorFn getMemBehvaiorFn) {
   instructionIsDeinitBarrierFunction = instructionIsDeinitBarrierFn;
+  getMemBehvaiorFunction = getMemBehvaiorFn;
+}
+
+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;
 }
 
 /// Implementation of mayBeDeinitBarrierNotConsideringSideEffects for use only