Optimizer: convert the AccessDumper from a pass to a test

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

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

SwiftCompilerSources/Sources/Optimizer/TestPasses/AccessDumper.swift

@@ -8,7 +8,6 @@
 
 swift_compiler_sources(Optimizer
   FunctionUsesDumper.swift
-  AccessDumper.swift
   AliasInfoDumper.swift
   DeadEndBlockDumper.swift
   MemBehaviorDumper.swift

SwiftCompilerSources/Sources/Optimizer/TestPasses/CMakeLists.txt

@@ -903,10 +903,124 @@ extension Function {
   }
 }
 
+//===--------------------------------------------------------------------===//
+//                              Tests
+//===--------------------------------------------------------------------===//
+
 let getAccessBaseTest = Test("swift_get_access_base") {
   function, arguments, context in
   let address = arguments.takeValue()
   print("Address: \(address)")
   let base = address.accessBase
   print("Base: \(base)")
 }
+
+let accessPathTest = Test("access_path") {
+  function, arguments, context in
+  
+  // Prints access path information for memory accesses (`load` and `store`) instructions.
+  // Also verifies that `AccessPath.isDistinct(from:)` is correct.
+
+  print("Accesses for \(function.name)")
+
+  for block in function.blocks {
+    for instr in block.instructions {
+      switch instr {
+      case let st as StoreInst:
+        printAccessInfo(address: st.destination)
+      case let load as LoadInst:
+        printAccessInfo(address: load.address)
+      case let apply as ApplyInst:
+        guard let callee = apply.referencedFunction else {
+          break
+        }
+        if callee.name == "_isDistinct" {
+          checkAliasInfo(forArgumentsOf: apply, expectDistinct: true)
+        } else if callee.name == "_isNotDistinct" {
+          checkAliasInfo(forArgumentsOf: apply, expectDistinct: false)
+        }
+      default:
+        break
+      }
+    }
+  }
+
+  print("End accesses for \(function.name)")
+}
+
+private struct AccessStoragePathVisitor : ValueUseDefWalker {
+  var walkUpCache = WalkerCache<Path>()
+  mutating func rootDef(value: Value, path: SmallProjectionPath) -> WalkResult {
+    print("    Storage: \(value)")
+    print("    Path: \"\(path)\"")
+    return .continueWalk
+  }
+}
+
+private func printAccessInfo(address: Value) {
+  print("Value: \(address)")
+
+  let (ap, scope) = address.accessPathWithScope
+  if let beginAccess = scope {
+    print("  Scope: \(beginAccess)")
+  } else {
+    print("  Scope: base")
+  }
+
+  let constAp = address.constantAccessPath
+  if constAp == ap {
+    print("  Base: \(ap.base)")
+    print("  Path: \"\(ap.projectionPath)\"")
+  } else {
+    print("  nonconst-base: \(ap.base)")
+    print("  nonconst-path: \"\(ap.projectionPath)\"")
+    print("  const-base: \(constAp.base)")
+    print("  const-path: \"\(constAp.projectionPath)\"")
+  }
+
+  var arw = AccessStoragePathVisitor()
+  if !arw.visitAccessStorageRoots(of: ap) {
+    print("   no Storage paths")
+  }
+}
+
+private func checkAliasInfo(forArgumentsOf apply: ApplyInst, expectDistinct: Bool) {
+  let address1 = apply.arguments[0]
+  let address2 = apply.arguments[1]
+
+  checkIsDistinct(path1: address1.accessPath,
+                  path2: address2.accessPath,
+                  expectDistinct: expectDistinct,
+                  instruction: apply)
+
+  if !expectDistinct {
+    // Also check all combinations with the constant variant of access paths.
+    // Note: we can't do that for "isDistinct" because "isDistinct" might be more conservative in one of the variants.
+    checkIsDistinct(path1: address1.constantAccessPath,
+                    path2: address2.constantAccessPath,
+                    expectDistinct: false,
+                    instruction: apply)
+    checkIsDistinct(path1: address1.accessPath,
+                    path2: address2.constantAccessPath,
+                    expectDistinct: false,
+                    instruction: apply)
+    checkIsDistinct(path1: address1.constantAccessPath,
+                    path2: address2.accessPath,
+                    expectDistinct: false,
+                    instruction: apply)
+  }
+}
+
+private func checkIsDistinct(path1: AccessPath, path2: AccessPath, expectDistinct: Bool, instruction: Instruction) {
+  if path1.isDistinct(from: path2) != expectDistinct {
+    print("wrong isDistinct result of \(instruction)")
+  } else if path2.isDistinct(from: path1) != expectDistinct {
+    print("wrong reverse isDistinct result of \(instruction)")
+  } else {
+    return
+  }
+
+  print("in function")
+  print(instruction.parentFunction)
+  fatalError()
+}

SwiftCompilerSources/Sources/SIL/Utilities/AccessUtils.swift

@@ -144,6 +144,7 @@ public func registerTests() {
     parseTestSpecificationTest,
     smallProjectionPathTest,
     getAccessBaseTest,
+    accessPathTest,
     borrowIntroducersTest,
     enclosingValuesTest,
     forwardingDefUseTest,

SwiftCompilerSources/Sources/SIL/Utilities/Test.swift

@@ -77,8 +77,6 @@ PASS(DeadEndBlockDumper, "dump-deadendblocks",
      "Tests the DeadEndBlocks utility")
 PASS(EmbeddedWitnessCallSpecialization, "embedded-witness-call-specialization",
      "Mandatory witness method call specialization")
-PASS(AccessDumper, "dump-access",
-     "Dump access information")
 PASS(ConstantCapturePropagation, "constant-capture-propagation",
      "Specialize closures with constant captures")
 PASS(ComputeEscapeEffects, "compute-escape-effects",

include/swift/SILOptimizer/PassManager/Passes.def

@@ -1,4 +1,4 @@
-// RUN: %target-sil-opt %s -dump-access -o /dev/null | %FileCheck %s
+// RUN: %target-sil-opt %s -test-runner -o /dev/null | %FileCheck %s
 
 // REQUIRES: swift_in_compiler
 
@@ -36,6 +36,7 @@ struct MoveOnlyPair: ~Copyable {
 // CHECK-NEXT: End accesses for testMarkUnresolvedNonCopyableValueInst
 sil [ossa] @testMarkUnresolvedNonCopyableValueInst : $@convention(thin) (@guaranteed List) -> () {
 bb0(%0 : @guaranteed $List):
+  specify_test "access_path"
   %1 = alloc_box ${ var MoveOnlyPair }
   %2 = project_box %1 : ${ var MoveOnlyPair }, 0
   %3 = mark_unresolved_non_copyable_value [consumable_and_assignable] %2 : $*MoveOnlyPair