AliasAnalysis: add complexity budget for the getMemEffectsFunction

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -36,7 +36,7 @@ struct AliasAnalysis {
   static func register() {
     BridgedAliasAnalysis.registerAnalysis(
       // getMemEffectsFn
-      { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction) -> swift.MemoryBehavior in
+      { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction, complexityBudget: Int) -> swift.MemoryBehavior in
         let context = FunctionPassContext(_bridged: bridgedCtxt)
         let inst = bridgedInst.instruction
         let val = bridgedVal.value
@@ -47,7 +47,8 @@ struct AliasAnalysis {
         case let builtin as BuiltinInst:
           return getMemoryEffect(ofBuiltin: builtin, for: val, path: path, context).bridged
         default:
-          if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true), context) {
+          if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true),
+                                     complexityBudget: complexityBudget, context) {
             return .MayReadWrite
           }
           return .None

include/swift/SILOptimizer/Analysis/AliasAnalysis.h

@@ -217,7 +217,7 @@ class AliasAnalysis {
   /// Returns true if \p Ptr may be released by the builtin \p BI.
   bool canBuiltinDecrementRefCount(BuiltinInst *BI, SILValue Ptr);
 
-  int getEstimatedFunctionSize(SILValue valueInFunction);
+  int getComplexityBudget(SILValue valueInFunction);
 
   /// Returns true if the object(s of) `obj` can escape to `toInst`.
   ///

include/swift/SILOptimizer/OptimizerBridging.h

@@ -33,7 +33,7 @@ struct BridgedAliasAnalysis {
   }
 
   typedef swift::MemoryBehavior (* _Nonnull GetMemEffectFn)(
-        BridgedPassContext context, BridgedValue, BridgedInstruction);
+        BridgedPassContext context, BridgedValue, BridgedInstruction, SwiftInt);
   typedef bool (* _Nonnull Escaping2InstFn)(
         BridgedPassContext context, BridgedValue, BridgedInstruction);
   typedef bool (* _Nonnull Escaping2ValFn)(

lib/SILOptimizer/Analysis/AliasAnalysis.cpp

@@ -715,7 +715,8 @@ MemoryBehavior AliasAnalysis::getMemoryEffectOnEscapedAddress(
             SILValue addr, SILInstruction *toInst) {
   if (getMemEffectsFunction) {
     return (MemoryBehavior)getMemEffectsFunction({PM->getSwiftPassInvocation()}, {addr},
-                                                 {toInst->asSILNode()});
+                                                 {toInst->asSILNode()},
+                                                 getComplexityBudget(addr));
   }
   return MemoryBehavior::MayHaveSideEffects;
 }
@@ -729,16 +730,8 @@ bool AliasAnalysis::isObjectReleasedByInst(SILValue obj, SILInstruction *inst) {
 
 bool AliasAnalysis::isAddrVisibleFromObject(SILValue addr, SILValue obj) {
   if (isAddrVisibleFromObjFunction) {
-    // This function is called a lot from ARCSequenceOpt and ReleaseHoisting.
-    // To avoid quadratic complexity for large functions, we limit the amount
-    // of work what the EscapeUtils are allowed to to.
-    // This keeps the complexity linear.
-    //
-    // This arbitrary limit is good enough for almost all functions. It lets
-    // the EscapeUtils do several hundred up/down walks which is much more than
-    // needed in most cases.
-    SwiftInt complexityLimit = 1000000 / getEstimatedFunctionSize(addr);
-    return isAddrVisibleFromObjFunction({PM->getSwiftPassInvocation()}, {addr}, {obj}, complexityLimit) != 0;
+    return isAddrVisibleFromObjFunction({PM->getSwiftPassInvocation()}, {addr}, {obj},
+                                        getComplexityBudget(addr)) != 0;
   }
   return true;
 }
@@ -750,7 +743,14 @@ bool AliasAnalysis::canReferenceSameField(SILValue lhs, SILValue rhs) {
   return true;
 }
 
-int AliasAnalysis::getEstimatedFunctionSize(SILValue valueInFunction) {
+// To avoid quadratic complexity for large functions, we limit the amount
+// of work what the EscapeUtils are allowed to to.
+// This keeps the complexity linear.
+//
+// This arbitrary limit is good enough for almost all functions. It lets
+// the EscapeUtils do several hundred up/down walks which is much more than
+// needed in most cases.
+int AliasAnalysis::getComplexityBudget(SILValue valueInFunction) {
   if (estimatedFunctionSize < 0) {
     int numInsts = 0;
     SILFunction *f = valueInFunction->getFunction();
@@ -759,5 +759,5 @@ int AliasAnalysis::getEstimatedFunctionSize(SILValue valueInFunction) {
     }
     estimatedFunctionSize = numInsts;
   }
-  return estimatedFunctionSize;
+  return 1000000 / estimatedFunctionSize;
 }