Optimizer: convert the RangeDumper pass to a test

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -149,7 +149,6 @@ private func registerSwiftPasses() {
 
   // Test passes
   registerPass(silPrinterPass, { silPrinterPass.run($0) })
-  registerPass(rangeDumper, { rangeDumper.run($0) })
   registerPass(testInstructionIteration, { testInstructionIteration.run($0) })
   registerPass(updateBorrowedFromPass, { updateBorrowedFromPass.run($0) })
 }

SwiftCompilerSources/Sources/Optimizer/TestPasses/CMakeLists.txt

@@ -8,7 +8,6 @@
 
 swift_compiler_sources(Optimizer
   SILPrinter.swift
-  RangeDumper.swift
   UpdateBorrowedFrom.swift
   TestInstructionIteration.swift
 )

SwiftCompilerSources/Sources/Optimizer/TestPasses/RangeDumper.swift

@@ -275,3 +275,89 @@ extension InstructionRange {
   }
 }
 
+//===--------------------------------------------------------------------===//
+//                              Tests
+//===--------------------------------------------------------------------===//
+
+let rangeTest = Test("ranges") {
+  function, arguments, context in
+
+  var begin: Instruction?
+  var ends = Stack<Instruction>(context)
+  defer { ends.deinitialize() }
+  var interiors = Stack<Instruction>(context)
+  defer { interiors.deinitialize() }
+  var ins = Stack<Instruction>(context)
+  defer { ins.deinitialize() }
+  var outs = Stack<Instruction>(context)
+  defer { outs.deinitialize() }
+
+  for inst in function.instructions {
+    if let sli = inst as? StringLiteralInst {
+      switch sli.value {
+        case "begin":
+          assert(begin == nil, "more than one begin instruction")
+          begin = sli
+        case "end":
+          ends.append(sli)
+        case "interior":
+          interiors.append(sli)
+        case "inside":
+          ins.append(sli)
+        case "outside":
+          outs.append(sli)
+        default:
+          break
+      }
+    }
+  }
+
+  guard let begin = begin else { return }
+
+  var instRange = InstructionRange(begin: begin, context)
+  defer { instRange.deinitialize() }
+
+  instRange.insert(contentsOf: ends)
+  instRange.insert(contentsOf: interiors)
+
+  print("Instruction range in \(function.name):")
+  print(instRange)
+  print("Block range in \(function.name):")
+  print(instRange.blockRange)
+  print("End function \(function.name)\n")
+
+  verify(instRange.blockRange, context)
+
+  for i in ins {
+    assert(instRange.contains(i))
+    assert(instRange.inclusiveRangeContains(i))
+  }
+  for e in ends {
+    assert(!instRange.contains(e))
+    assert(instRange.inclusiveRangeContains(e))
+  }
+  for o in outs {
+    assert(!instRange.contains(o))
+    assert(!instRange.inclusiveRangeContains(o))
+  }
+}
+
+private func verify(_ blockRange: BasicBlockRange, _ context: TestContext) {
+  var inRange = BasicBlockSet(context)
+  defer { inRange.deinitialize() }
+  for b in blockRange.range {
+    inRange.insert(b)
+  }
+
+  var inInclusiveRange = BasicBlockSet(context)
+  defer { inInclusiveRange.deinitialize() }
+  for b in blockRange.inclusiveRange {
+    inInclusiveRange.insert(b)
+  }
+
+  for b in blockRange.begin.parentFunction.blocks {
+    assert(blockRange.contains(b) == inRange.contains(b))
+    assert(blockRange.inclusiveRangeContains(b) == inInclusiveRange.contains(b))
+  }
+}
+

SwiftCompilerSources/Sources/SIL/DataStructures/InstructionRange.swift

@@ -149,6 +149,7 @@ public func registerTests() {
     enclosingValuesTest,
     forwardingDefUseTest,
     forwardingUseDefTest,
+    rangeTest,
     addressableTest
   )
 

SwiftCompilerSources/Sources/SIL/Utilities/Test.swift

@@ -85,8 +85,6 @@ PASS(TestInstructionIteration, "test-instruction-iteration",
      "Tests instruction iteration")
 PASS(InitializeStaticGlobals, "initialize-static-globals",
      "Initializes static global variables")
-PASS(RangeDumper, "dump-ranges",
-     "Dumps block and instruction ranges")
 PASS(MandatoryRedundantLoadElimination, "mandatory-redundant-load-elimination",
      "Mandatory Redundant Load Elimination")
 PASS(EarlyRedundantLoadElimination, "early-redundant-load-elimination",

include/swift/SILOptimizer/PassManager/Passes.def

@@ -1,4 +1,4 @@
-// RUN: %target-sil-opt %s -dump-ranges -o /dev/null | %FileCheck %s
+// RUN: %target-sil-opt %s -test-runner -o /dev/null | %FileCheck %s
 
 // REQUIRES: swift_in_compiler
 
@@ -21,6 +21,7 @@ sil_stage canonical
 // CHECK-NEXT: End function basic_test
 sil @basic_test : $@convention(thin) () -> () {
 bb0:
+  specify_test "ranges"
   %0 = string_literal utf8 "outside"
   br bb1
 bb1:
@@ -66,6 +67,7 @@ bb6:
 // CHECK-NEXT: End function loops
 sil @loops : $@convention(thin) () -> () {
 bb0:
+  specify_test "ranges"
   %0 = string_literal utf8 "outside"
   br bb1
 bb1:
@@ -104,6 +106,7 @@ bb7:
 // CHECK-NEXT: End function minimal
 sil @minimal : $@convention(thin) () -> () {
 bb0:
+  specify_test "ranges"
   %0 = string_literal utf8 "begin"
   %1 = string_literal utf8 "end"
   %r = tuple()
@@ -117,6 +120,7 @@ bb0:
 // CHECK:      End function invalid
 sil @invalid : $@convention(thin) () -> () {
 bb0:
+  specify_test "ranges"
   cond_br undef, bb1, bb2
 bb1:
   %1 = string_literal utf8 "begin"