Optimizer: convert the AliasInfoDumper and MemBehaviorDumper passes to tests

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -975,3 +975,116 @@ private extension BridgedAliasAnalysis {
     UnsafeMutableRawPointer(aa)
   }
 }
+
+//===--------------------------------------------------------------------===//
+//                              Tests
+//===--------------------------------------------------------------------===//
+
+/// Prints the memory behavior of relevant instructions in relation to address values of the function.
+let aliasingTest = FunctionTest("aliasing") {
+  function, arguments, context in
+
+  let aliasAnalysis = context.aliasAnalysis
+
+  print("@\(function.name)")
+
+  let values = function.allValues
+
+  var pair = 0
+  for (index1, value1) in values.enumerated() {
+    for (index2, value2) in values.enumerated() {
+      if index2 >= index1 {
+        let result = aliasAnalysis.mayAlias(value1, value2)
+        precondition(result == aliasAnalysis.mayAlias(value2, value1), "alias analysis not symmetric")
+
+        print("PAIR #\(pair).")
+        print("  \(value1)")
+        print("  \(value2)")
+        if result {
+          print("  MayAlias")
+        } else if !value1.uses.isEmpty && !value2.uses.isEmpty {
+          print("  NoAlias")
+        } else {
+          print("  noalias?")
+        }
+
+        pair += 1
+      }
+    }
+  }
+}
+
+/// Prints the memory behavior of relevant instructions in relation to address values of the function.
+let memoryEffectsTest = FunctionTest("memory_effects") {
+  function, arguments, context in
+
+  let aliasAnalysis = context.aliasAnalysis
+
+  print("@\(function.name)")
+
+  let values = function.allValues
+
+  var currentPair = 0
+  for inst in function.instructions where inst.shouldTest {
+
+    for value in values where value.definingInstruction != inst {
+
+      if value.type.isAddress {
+        let read = inst.mayRead(fromAddress: value, aliasAnalysis)
+        let write = inst.mayWrite(toAddress: value, aliasAnalysis)
+        print("PAIR #\(currentPair).")
+        print("  \(inst)")
+        print("  \(value)")
+        print("  r=\(read ? 1 : 0),w=\(write ? 1 : 0)")
+        currentPair += 1
+      }
+    }
+  }
+  print()
+}
+
+private extension Instruction {
+  var shouldTest: Bool {
+    switch self {
+    case is ApplySite,
+         is EndApplyInst,
+         is AbortApplyInst,
+         is BeginAccessInst,
+         is EndAccessInst,
+         is EndCOWMutationInst,
+         is EndCOWMutationAddrInst,
+         is CopyValueInst,
+         is DestroyValueInst,
+         is StrongReleaseInst,
+         is IsUniqueInst,
+         is EndBorrowInst,
+         is LoadInst,
+         is LoadBorrowInst,
+         is StoreInst,
+         is CopyAddrInst,
+         is BuiltinInst,
+         is StoreBorrowInst,
+         is MarkDependenceInst,
+         is MarkDependenceAddrInst,
+         is DebugValueInst,
+         is DebugStepInst:
+      return true
+    default:
+      return false
+    }
+  }
+}
+
+private extension Function {
+  var allValues: [Value] {
+    var values: [Value] = []
+    for block in blocks {
+      values.append(contentsOf: block.arguments.map { $0 })
+      for inst in block.instructions {
+        values.append(contentsOf: inst.results)
+      }
+    }
+    return values
+  }
+}
+

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -148,11 +148,9 @@ private func registerSwiftPasses() {
   registerForSILCombine(EndCOWMutationAddrInst.self, { run(EndCOWMutationAddrInst.self, $0) })
 
   // Test passes
-  registerPass(aliasInfoDumper, { aliasInfoDumper.run($0) })
   registerPass(functionUsesDumper, { functionUsesDumper.run($0) })
   registerPass(silPrinterPass, { silPrinterPass.run($0) })
   registerPass(deadEndBlockDumper, { deadEndBlockDumper.run($0) })
-  registerPass(memBehaviorDumper, { memBehaviorDumper.run($0) })
   registerPass(rangeDumper, { rangeDumper.run($0) })
   registerPass(testInstructionIteration, { testInstructionIteration.run($0) })
   registerPass(updateBorrowedFromPass, { updateBorrowedFromPass.run($0) })

SwiftCompilerSources/Sources/Optimizer/TestPasses/AliasInfoDumper.swift

@@ -8,9 +8,7 @@
 
 swift_compiler_sources(Optimizer
   FunctionUsesDumper.swift
-  AliasInfoDumper.swift
   DeadEndBlockDumper.swift
-  MemBehaviorDumper.swift
   SILPrinter.swift
   RangeDumper.swift
   UpdateBorrowedFrom.swift

SwiftCompilerSources/Sources/Optimizer/TestPasses/CMakeLists.txt

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

SwiftCompilerSources/Sources/Optimizer/TestPasses/MemBehaviorDumper.swift

@@ -63,8 +63,6 @@ PASS(AllocBoxToStack, "allocbox-to-stack",
      "stack promotion of box objects")
 PASS(CopyToBorrowOptimization, "copy-to-borrow-optimization",
      "Convert load [copy] instructions to load_borrow and remove copies of borrowed values")
-PASS(AliasInfoDumper, "dump-alias-info",
-     "Dump Alias Analysis over all Pairs")
 PASS(AssumeSingleThreaded, "sil-assume-single-threaded",
      "Assume Single-Threaded Environment")
 PASS(BooleanLiteralFolding, "boolean-literal-folding",
@@ -110,8 +108,6 @@ PASS(LifetimeDependenceInsertion,
 PASS(LifetimeDependenceScopeFixup,
      "lifetime-dependence-scope-fixup",
      "Fixup scope for lifetime dependence")
-PASS(MemBehaviorDumper, "dump-mem-behavior",
-     "Print SIL Instruction MemBehavior from Alias Analysis over all Pairs")
 PASS(MergeCondFails, "merge-cond_fails",
      "Merge SIL cond_fail to Eliminate Redundant Overflow Checks")
 PASS(ObjCBridgingOptimization, "objc-bridging-opt",

SwiftCompilerSources/Sources/Optimizer/Utilities/FunctionTest.swift

@@ -1,4 +1,4 @@
-// RUN: %target-sil-opt %s -dump-alias-info -o /dev/null | %FileCheck %s
+// RUN: %target-sil-opt %s -test-runner -o /dev/null | %FileCheck %s
 
 // General black-box alias analysis tests. White-box unit tests are
 // specific to the aa-kind, such as basic-aa.sil and typed-access-tb-aa.sil.
@@ -28,6 +28,7 @@ struct OuterStruct {
 // CHECK-NEXT:    NoAlias
 sil shared @testOffsetBehindProjection : $@convention(thin) (@inout MyStruct) -> () {
 bb0(%0 : $*MyStruct):
+  specify_test "aliasing"
   %1 = struct_element_addr %0 : $*MyStruct, #MyStruct.i
   %2 = integer_literal $Builtin.Word, 1
   %3 = index_addr %1 : $*Int64, %2 : $Builtin.Word
@@ -46,6 +47,7 @@ bb0(%0 : $*MyStruct):
 // CHECK-NEXT:    NoAlias
 sil shared @testOffsetsBehindProjectionOverlap : $@convention(thin) (@inout OuterStruct) -> () {
 bb0(%0 : $*OuterStruct):
+  specify_test "aliasing"
   %1 = struct_element_addr %0 : $*OuterStruct, #OuterStruct.s
   %2 = struct_element_addr %1 : $*MyStruct, #MyStruct.i
   %3 = load %2 : $*Int64
@@ -70,6 +72,7 @@ bb0(%0 : $*OuterStruct):
 // CHECK-NEXT:   MayAlias
 sil @testIndexOf0 : $@convention(thin) (@inout MyStruct) -> () {
 bb0(%0 : $*MyStruct):
+  specify_test "aliasing"
   %1 = struct_element_addr %0 : $*MyStruct, #MyStruct.i
   %2 = integer_literal $Builtin.Word, 0
   %3 = index_addr %0 : $*MyStruct, %2 : $Builtin.Word
@@ -91,6 +94,7 @@ bb0(%0 : $*MyStruct):
 // CHECK-NEXT:    MayAlias
 sil @testUnknownIndex : $@convention(thin) (@inout MyStruct, Builtin.Word) -> () {
 bb0(%0 : $*MyStruct, %1 : $Builtin.Word):
+  specify_test "aliasing"
   %2 = struct_element_addr %0 : $*MyStruct, #MyStruct.i
   %3 = index_addr %0 : $*MyStruct, %1 : $Builtin.Word
   %4 = struct_element_addr %3 : $*MyStruct, #MyStruct.i
@@ -127,6 +131,7 @@ bb0(%0 : $*MyStruct, %1 : $Builtin.Word):
 // CHECK-NEXT:    NoAlias
 sil @testVectorBaseAddr : $@convention(thin) (@inout Builtin.FixedArray<10, Int>, Builtin.Word) -> () {
 bb0(%0 : $*Builtin.FixedArray<10, Int>, %1 : $Builtin.Word):
+  specify_test "aliasing"
   %2 = vector_base_addr %0
   %3 = index_addr %2, %1
   %4 = integer_literal $Builtin.Word, 1