Optimizer: convert the EscapeInfoDumper from a pass to a test

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -151,8 +151,6 @@ private func registerSwiftPasses() {
   registerPass(aliasInfoDumper, { aliasInfoDumper.run($0) })
   registerPass(functionUsesDumper, { functionUsesDumper.run($0) })
   registerPass(silPrinterPass, { silPrinterPass.run($0) })
-  registerPass(escapeInfoDumper, { escapeInfoDumper.run($0) })
-  registerPass(addressEscapeInfoDumper, { addressEscapeInfoDumper.run($0) })
   registerPass(accessDumper, { accessDumper.run($0) })
   registerPass(deadEndBlockDumper, { deadEndBlockDumper.run($0) })
   registerPass(memBehaviorDumper, { memBehaviorDumper.run($0) })

SwiftCompilerSources/Sources/Optimizer/TestPasses/CMakeLists.txt

@@ -11,7 +11,6 @@ swift_compiler_sources(Optimizer
   AccessDumper.swift
   AliasInfoDumper.swift
   DeadEndBlockDumper.swift
-  EscapeInfoDumper.swift
   MemBehaviorDumper.swift
   SILPrinter.swift
   RangeDumper.swift

SwiftCompilerSources/Sources/Optimizer/TestPasses/EscapeInfoDumper.swift

@@ -990,3 +990,146 @@ private extension PartialApplyInst {
     }
   }
 }
+
+//===--------------------------------------------------------------------===//
+//                              Tests
+//===--------------------------------------------------------------------===//
+
+let escapeInfoTest = FunctionTest("escape_info") {
+  function, arguments, context in
+
+  print("Escape information for \(function.name):")
+  
+  struct Visitor : EscapeVisitorWithResult {
+    var result: Set<String> =  Set()
+    
+    mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
+      if operand.instruction is ReturnInstruction {
+        result.insert("return[\(path.projectionPath)]")
+        return .ignore
+      }
+      return .continueWalk
+    }
+    
+    mutating func visitDef(def: Value, path: EscapePath) -> DefResult {
+      guard let arg = def as? FunctionArgument else {
+        return .continueWalkUp
+      }
+      result.insert("arg\(arg.index)[\(path.projectionPath)]")
+      return .walkDown
+    }
+  }
+  
+  // Dump the EscapeInfo query results for all `alloc_ref` instructions in the function.
+  //
+  for inst in function.instructions {
+    if let allocRef = inst as? AllocRefInst {
+      
+      let resultStr: String
+      if let result = allocRef.visit(using: Visitor(), context) {
+        if result.isEmpty {
+          resultStr = " -    "
+        } else {
+          resultStr = Array(result).sorted().joined(separator: ",")
+        }
+      } else {
+        resultStr = "global"
+      }
+      print("\(resultStr): \(allocRef)")
+    }
+  }
+  print("End function \(function.name)\n")
+}
+
+let addressEscapeInfoTest = FunctionTest("address_escape_info") {
+  function, arguments, context in
+
+  // Dumps the EscapeInfo query results for addresses escaping to function calls.
+  // The `fix_lifetime` instruction is used as marker for addresses and values to query.
+
+  print("Address escape information for \(function.name):")
+
+  var valuesToCheck = [Value]()
+  var applies = [Instruction]()
+  
+  for inst in function.instructions {
+    switch inst {
+      case let fli as FixLifetimeInst:
+        valuesToCheck.append(fli.operand.value)
+      case is FullApplySite:
+        applies.append(inst)
+      default:
+        break
+    }
+  }
+  
+  struct Visitor : EscapeVisitor {
+    let apply: Instruction
+    mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
+      let user = operand.instruction
+      if user == apply {
+        return .abort
+      }
+      if user is ReturnInstruction {
+        // Anything which is returned cannot escape to an instruction inside the function.
+        return .ignore
+      }
+      return .continueWalk
+    }
+
+    var followTrivialTypes: Bool { true }
+    var followLoads: Bool { false }
+  }
+
+  // test `isEscaping(addressesOf:)`
+  for value in valuesToCheck {
+    print("value:\(value)")
+    for apply in applies {
+      if value.allContainedAddresses.isEscaping(using: Visitor(apply: apply), context) {
+        print("  ==> \(apply)")
+      } else {
+        print("  -   \(apply)")
+      }
+    }
+  }
+  
+  // test `canReferenceSameField` for each pair of `fix_lifetime`.
+  if !valuesToCheck.isEmpty {
+    for lhsIdx in 0..<(valuesToCheck.count - 1) {
+      for rhsIdx in (lhsIdx + 1) ..< valuesToCheck.count {
+        print("pair \(lhsIdx) - \(rhsIdx)")
+        let lhs = valuesToCheck[lhsIdx]
+        let rhs = valuesToCheck[rhsIdx]
+        print(lhs)
+        print(rhs)
+
+        let projLhs = lhs.allContainedAddresses
+        let projRhs = rhs.allContainedAddresses
+        let mayAlias = projLhs.canAddressAlias(with: projRhs, context)
+        if mayAlias != projRhs.canAddressAlias(with: projLhs, context) {
+          fatalError("canAddressAlias(with:) must be symmetric")
+        }
+
+        let addrReachable: Bool
+        if lhs.type.isAddress && !rhs.type.isAddress {
+          let anythingReachableFromRhs = rhs.at(SmallProjectionPath(.anything))
+          addrReachable = projLhs.canAddressAlias(with: anythingReachableFromRhs, context)
+          if mayAlias && !addrReachable {
+            fatalError("mayAlias implies addrReachable")
+          }
+        } else {
+          addrReachable = false
+        }
+        if mayAlias {
+          print("may alias")
+        } else if addrReachable {
+          print("address reachable but no alias")
+        } else {
+          print("no alias")
+        }
+      }
+    }
+  }
+  
+  print("End function \(function.name)\n")
+}

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -52,7 +52,9 @@ public func registerOptimizerTests() {
     localVariableReachingAssignmentsTest,
     rangeOverlapsPathTest,
     variableIntroducerTest,
-    destroyBarrierTest
+    destroyBarrierTest,
+    escapeInfoTest,
+    addressEscapeInfoTest
   )
 
   // Finally register the thunk they all call through.

SwiftCompilerSources/Sources/Optimizer/Utilities/FunctionTest.swift

@@ -77,10 +77,6 @@ PASS(DeadEndBlockDumper, "dump-deadendblocks",
      "Tests the DeadEndBlocks utility")
 PASS(EmbeddedWitnessCallSpecialization, "embedded-witness-call-specialization",
      "Mandatory witness method call specialization")
-PASS(EscapeInfoDumper, "dump-escape-info",
-     "Dumps escape information")
-PASS(AddressEscapeInfoDumper, "dump-addr-escape-info",
-     "Dumps address escape information")
 PASS(AccessDumper, "dump-access",
      "Dump access information")
 PASS(ConstantCapturePropagation, "constant-capture-propagation",