Merge pull request #86042 from eeckstein/sil-unit-tests

SwiftCompilerSources: convert all unit-test passes to real 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/CMakeLists.txt

@@ -17,5 +17,4 @@ add_subdirectory(InstructionSimplification)
 add_subdirectory(PassManager)
 add_subdirectory(ModulePasses)
 add_subdirectory(FunctionPasses)
-add_subdirectory(TestPasses)
 add_subdirectory(Utilities)

SwiftCompilerSources/Sources/Optimizer/DataStructures/DeadEndBlocks.swift

@@ -51,3 +51,19 @@ struct DeadEndBlocks : CustomStringConvertible, NoReflectionChildren {
     worklist.deinitialize()
   }
 }
+
+//===--------------------------------------------------------------------===//
+//                              Tests
+//===--------------------------------------------------------------------===//
+
+let deadEndBlockTest = FunctionTest("deadendblocks") {
+  function, arguments, context in
+
+  print("Function \(function.name)")
+  
+  var deadEndBlocks = DeadEndBlocks(function: function, context)
+  print(deadEndBlocks)
+  defer { deadEndBlocks.deinitialize() }
+
+  print("end function \(function.name)")
+}

SwiftCompilerSources/Sources/Optimizer/DataStructures/FunctionUses.swift

@@ -162,3 +162,22 @@ struct FunctionUses {
     uses[function, default: FirstUse(of: function)].hasUnknownUses = true
   }
 }
+
+//===--------------------------------------------------------------------===//
+//                              Tests
+//===--------------------------------------------------------------------===//
+
+let functionUsesTest = ModuleTest("function-uses") {
+    (context: ModulePassContext) in
+
+  var functionUses = FunctionUses()
+  functionUses.collect(context: context)
+
+  for function in context.functions {
+    let uses = functionUses.getUses(of: function)
+
+    print("Uses of \(function.name)")
+    print(uses)
+    print("End function \(function.name)\n")
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -23,7 +23,7 @@ public func initializeSwiftModules() {
   registerOptimizerTests()
 }
 
-private func registerPass(
+func registerPass(
       _ pass: ModulePass,
       _ runFn: @escaping (@convention(c) (BridgedContext) -> ())) {
   pass.name._withBridgedStringRef { nameStr in
@@ -146,19 +146,6 @@ private func registerSwiftPasses() {
   registerForSILCombine(ApplyInst.self,             { run(ApplyInst.self, $0) })
   registerForSILCombine(TryApplyInst.self,          { run(TryApplyInst.self, $0) })
   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(escapeInfoDumper, { escapeInfoDumper.run($0) })
-  registerPass(addressEscapeInfoDumper, { addressEscapeInfoDumper.run($0) })
-  registerPass(accessDumper, { accessDumper.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) })
 }
 
 private func registerSwiftAnalyses() {