Swift Optimizer: improve ergonomics of EscapeUtils

Replace the `struct EscapeInfo` with a simpler API, just consisting of methods of `ProjectedValue` and `Value`:
* `isEscaping()`
* `isAddressEscaping()`
* `visit()`
* `visitAddress()`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEffects.swift

@@ -30,12 +30,11 @@ let computeEffects = FunctionPass(name: "compute-effects", {
   (function: Function, context: PassContext) in
   var argsWithDefinedEffects = getArgIndicesWithDefinedEffects(of: function)
 
-  struct IgnoreRecursiveCallVisitor : EscapeInfoVisitor {
+  struct IgnoreRecursiveCallVisitor : EscapeVisitor {
     func visitUse(operand: Operand, path: EscapePath) -> UseResult {
       return isOperandOfRecursiveCall(operand) ? .ignore : .continueWalk
     }
   }
-  var escapeInfo = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: IgnoreRecursiveCallVisitor())
   var newEffects = Stack<ArgumentEffect>(context)
   let returnInst = function.returnInstruction
 
@@ -47,7 +46,8 @@ let computeEffects = FunctionPass(name: "compute-effects", {
     if argsWithDefinedEffects.contains(arg.index) { continue }
 
     // First check: is the argument (or a projected value of it) escaping at all?
-    if !escapeInfo.isEscapingWhenWalkingDown(object: arg, path: SmallProjectionPath(.anything)) {
+    if !arg.at(.anything).isEscaping(using: IgnoreRecursiveCallVisitor(),
+                                     startWalkingDown: true, context) {
       newEffects.push(ArgumentEffect(.notEscaping, argumentIndex: arg.index, pathPattern: SmallProjectionPath(.anything)))
       continue
     }
@@ -78,7 +78,7 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
   // containing one or more references.
   let argPath = arg.type.isClass ? ap : ap.push(.anyValueFields)
 
-  struct ArgEffectsVisitor : EscapeInfoVisitor {
+  struct ArgEffectsVisitor : EscapeVisitorWithResult {
     enum EscapeDestination {
       case notSet
       case toReturn(SmallProjectionPath)
@@ -131,8 +131,8 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
     }
   }
 
-  var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: ArgEffectsVisitor())
-  if walker.isEscapingWhenWalkingDown(object: arg, path: argPath) {
+  guard let result = arg.at(argPath).visit(using: ArgEffectsVisitor(),
+                                           startWalkingDown: true, context) else {
     return false
   }
 
@@ -142,7 +142,7 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
   }
 
   let effect: ArgumentEffect
-  switch walker.visitor.result {
+  switch result {
   case .notSet:
     effect = ArgumentEffect(.notEscaping, argumentIndex: arg.index, pathPattern: argPath)
   case .toReturn(let toPath):
@@ -200,7 +200,7 @@ private
 func isExclusiveEscapeToReturn(fromArgument: Argument, fromPath: SmallProjectionPath,
                                toPath: SmallProjectionPath,
                                returnInst: ReturnInst, _ context: PassContext) -> Bool {
-  struct IsExclusiveReturnEscapeVisitor : EscapeInfoVisitor {
+  struct IsExclusiveReturnEscapeVisitor : EscapeVisitor {
     let fromArgument: Argument
     let fromPath: SmallProjectionPath
     let toPath: SmallProjectionPath
@@ -228,14 +228,13 @@ func isExclusiveEscapeToReturn(fromArgument: Argument, fromPath: SmallProjection
     }
   }
   let visitor = IsExclusiveReturnEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath, toPath: toPath)
-  var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: visitor)
-  return !walker.isEscaping(object: returnInst.operand, path: toPath)
+  return !returnInst.operand.at(toPath).isEscaping(using: visitor, context)
 }
 
 private
 func isExclusiveEscapeToArgument(fromArgument: Argument, fromPath: SmallProjectionPath,
                                  toArgumentIndex: Int, toPath: SmallProjectionPath, _ context: PassContext) -> Bool {
-  struct IsExclusiveArgumentEscapeVisitor : EscapeInfoVisitor {
+  struct IsExclusiveArgumentEscapeVisitor : EscapeVisitor {
     let fromArgument: Argument
     let fromPath: SmallProjectionPath
     let toArgumentIndex: Int
@@ -253,8 +252,7 @@ func isExclusiveEscapeToArgument(fromArgument: Argument, fromPath: SmallProjecti
   }
   let visitor = IsExclusiveArgumentEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath,
                                                  toArgumentIndex: toArgumentIndex, toPath: toPath)
-  var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: visitor)
   let toArg = fromArgument.function.arguments[toArgumentIndex]
-  return !walker.isEscaping(object: toArg, path: toPath)
+  return !toArg.at(toPath).isEscaping(using: visitor, startWalkingDown: true, context)
 }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StackPromotion.swift

@@ -75,11 +75,8 @@ func tryPromoteAlloc(_ allocRef: AllocRefInstBase,
   if allocRef.isObjC || allocRef.canAllocOnStack {
     return false
   }
-  struct DefaultVisitor : EscapeInfoVisitor {}
-  var ei = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: DefaultVisitor())
-  
   // The most important check: does the object escape the current function?
-  if ei.isEscaping(object:allocRef) {
+  if allocRef.isEscaping(context) {
     return false
   }
 
@@ -196,21 +193,19 @@ func tryPromoteAlloc(_ allocRef: AllocRefInstBase,
 private func getDominatingBlockOfAllUsePoints(context: PassContext,
                                               _ value: SingleValueInstruction,
                                               domTree: DominatorTree) -> BasicBlock {
-  struct Visitor : EscapeInfoVisitor {
-    var dominatingBlock: BasicBlock
+  struct FindDominatingBlock : EscapeVisitorWithResult {
+    var result: BasicBlock
     let domTree: DominatorTree
     mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
       let defBlock = operand.value.definingBlock
-      if defBlock.dominates(dominatingBlock, domTree) {
-        dominatingBlock = defBlock
+      if defBlock.dominates(result, domTree) {
+        result = defBlock
       }
       return .continueWalk
     }
   }
 
-  var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: Visitor(dominatingBlock: value.block, domTree: domTree))
-  _ = walker.isEscaping(object: value)
-  return walker.visitor.dominatingBlock
+  return value.visit(using: FindDominatingBlock(result: value.block, domTree: domTree), context)!
 }
 
 
@@ -219,11 +214,13 @@ func computeInnerAndOuterLiferanges(instruction: SingleValueInstruction, in domB
   /// All uses which are dominated by the `innerInstRange`s begin-block are included
   /// in both, the `innerInstRange` and the `outerBlockRange`.
   /// All _not_ dominated uses are only included in the `outerBlockRange`.
-  struct Visitor : EscapeInfoVisitor {
+  struct Visitor : EscapeVisitorWithResult {
     var innerRange: InstructionRange
     var outerBlockRange: BasicBlockRange
     let domTree: DominatorTree
 
+    var result: (InstructionRange, BasicBlockRange) { (innerRange, outerBlockRange) }
+    
     init(instruction: Instruction, domBlock: BasicBlock, domTree: DominatorTree, context: PassContext) {
       innerRange = InstructionRange(begin: instruction, context)
       outerBlockRange = BasicBlockRange(begin: domBlock, context)
@@ -245,7 +242,7 @@ func computeInnerAndOuterLiferanges(instruction: SingleValueInstruction, in domB
       outerBlockRange.insert(defBlock)
 
       // We need to explicitly add predecessor blocks of phi-arguments becaues they
-      // are not necesesarily visited by `EscapeInfo.walkDown`.
+      // are not necesesarily visited during the down-walk in `isEscaping()`.
       // This is important for the special case where there is a back-edge from the
       // inner range to the inner rage's begin-block:
       //
@@ -261,16 +258,11 @@ func computeInnerAndOuterLiferanges(instruction: SingleValueInstruction, in domB
       return .continueWalk
     }
   }
-  
-  var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis,
-                                visitor: Visitor(
-                                  instruction: instruction,
-                                  domBlock: domBlock,
-                                  domTree: domTree,
-                                  context: context
-                                ))
-  _ = walker.isEscaping(object: instruction)
-  return (walker.visitor.innerRange, walker.visitor.outerBlockRange)
+
+  return instruction.visit(using: Visitor(instruction: instruction,
+                                          domBlock: domBlock,
+                                          domTree: domTree,
+                                          context: context), context)!
 }
 
 private extension BasicBlockRange {

SwiftCompilerSources/Sources/Optimizer/TestPasses/EscapeInfoDumper.swift

@@ -22,12 +22,12 @@ let escapeInfoDumper = FunctionPass(name: "dump-escape-info", {
 
   print("Escape information for \(function.name):")
 
-  struct Visitor : EscapeInfoVisitor {
-    var results: Set<String> =  Set()
+  struct Visitor : EscapeVisitorWithResult {
+    var result: Set<String> =  Set()
 
     mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
       if operand.instruction is ReturnInst {
-        results.insert("return[\(path.projectionPath)]")
+        result.insert("return[\(path.projectionPath)]")
         return .ignore
       }
       return .continueWalk
@@ -37,7 +37,7 @@ let escapeInfoDumper = FunctionPass(name: "dump-escape-info", {
       guard let arg = def as? FunctionArgument else {
         return .continueWalkUp
       }
-      results.insert("arg\(arg.index)[\(path.projectionPath)]")
+      result.insert("arg\(arg.index)[\(path.projectionPath)]")
       return .walkDown
     }
   }
@@ -46,19 +46,17 @@ let escapeInfoDumper = FunctionPass(name: "dump-escape-info", {
   for inst in function.instructions {
     if let allocRef = inst as? AllocRefInst {
 
-      var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: Visitor())
-      let escapes = walker.isEscaping(object: allocRef)
-      let results = walker.visitor.results
-      
-      let res: String
-      if escapes {
-        res = "global"
-      } else if results.isEmpty {
-        res = " -    "
+      let resultStr: String
+      if let result = allocRef.visit(using: Visitor(), context) {
+        if result.isEmpty {
+          resultStr = " -    "
+        } else {
+          resultStr = Array(result).sorted().joined(separator: ",")
+        }
       } else {
-        res = Array(results).sorted().joined(separator: ",")
+        resultStr = "global"
       }
-      print("\(res): \(allocRef)")
+      print("\(resultStr): \(allocRef)")
     }
   }
   print("End function \(function.name)\n")
@@ -90,7 +88,7 @@ let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info", {
     }
   }
 
-  struct Visitor : EscapeInfoVisitor {
+  struct Visitor : EscapeVisitor {
     let apply: Instruction
     mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
       let user = operand.instruction
@@ -111,13 +109,14 @@ let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info", {
     for apply in applies {
       let path = AliasAnalysis.getPtrOrAddressPath(for: value)
 
-      var escapeInfo = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: Visitor(apply: apply))
-      let escaping = escapeInfo.isEscaping(addressesOf: value, path: path)
-      print("  \(escaping ? "==>" : "-  ") \(apply)")
+      if value.at(path).isAddressEscaping(using: Visitor(apply: apply), context) {
+        print("  ==> \(apply)")
+      } else {
+        print("  -   \(apply)")
+      }
     }
   }
 
-  var eaa = EscapeAliasAnalysis(calleeAnalysis: context.calleeAnalysis)
   // test `canReferenceSameField` for each pair of `fix_lifetime`.
   if !valuesToCheck.isEmpty {
     for lhsIdx in 0..<(valuesToCheck.count - 1) {
@@ -127,9 +126,14 @@ let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info", {
         let rhs = valuesToCheck[rhsIdx]
         print(lhs)
         print(rhs)
-        if eaa.canReferenceSameField(
-            lhs, path: AliasAnalysis.getPtrOrAddressPath(for: lhs),
-            rhs, path: AliasAnalysis.getPtrOrAddressPath(for: rhs)) {
+
+        let projLhs = lhs.at(AliasAnalysis.getPtrOrAddressPath(for: lhs))
+        let projRhs = rhs.at(AliasAnalysis.getPtrOrAddressPath(for: rhs))
+        let mayAlias = projLhs.canAddressAlias(with: projRhs, context)
+        assert(mayAlias == projRhs.canAddressAlias(with: projLhs, context),
+               "canAddressAlias(with:) must be symmetric")
+
+        if mayAlias {
           print("may alias")
         } else {
           print("no alias")