Optimizer: convert the SILPrinter and TestInstructionIteration passes to tests

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -148,8 +148,6 @@ private func registerSwiftPasses() {
   registerForSILCombine(EndCOWMutationAddrInst.self, { run(EndCOWMutationAddrInst.self, $0) })
 
   // Test passes
-  registerPass(silPrinterPass, { silPrinterPass.run($0) })
-  registerPass(testInstructionIteration, { testInstructionIteration.run($0) })
   registerPass(updateBorrowedFromPass, { updateBorrowedFromPass.run($0) })
 }
 

SwiftCompilerSources/Sources/Optimizer/TestPasses/CMakeLists.txt

@@ -7,7 +7,5 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
-  SILPrinter.swift
   UpdateBorrowedFrom.swift
-  TestInstructionIteration.swift
 )

SwiftCompilerSources/Sources/Optimizer/TestPasses/SILPrinter.swift

@@ -306,3 +306,133 @@ extension OptionalBridgedSuccessor {
     return nil
   }
 }
+
+//===--------------------------------------------------------------------===//
+//                              Tests
+//===--------------------------------------------------------------------===//
+
+/// Most basic test of a BasicBlock and its contents
+let basicBlockTest = Test("basic_block") {
+  function, arguments, context in
+
+  print("run SILPrinter on function: \(function.name)")
+
+  for (bbIdx, block) in function.blocks.enumerated() {
+    print("bb\(bbIdx):")
+
+    print("  predecessors: \(block.predecessors)")
+    print("  successors:   \(block.successors)")
+
+    print("  arguments:")
+    for arg in block.arguments {
+      print("    arg: \(arg)")
+      for use in arg.uses {
+        print("      user: \(use.instruction)")
+      }
+      if let phi = Phi(arg) {
+        for incoming in phi.incomingValues {
+          print("      incoming: \(incoming)")
+        }
+      }
+    }
+
+    print("  instructions:")
+    for inst in block.instructions {
+      print("  \(inst)")
+      for op in inst.operands {
+        print("      op: \(op.value)")
+      }
+      for (resultIdx, result) in inst.results.enumerated() {
+        for use in result.uses {
+          print("      user of result \(resultIdx): \(use.instruction)")
+        }
+      }
+    }
+  }
+}
+
+/// Tests instruction iteration while modifying the instruction list.
+///
+/// This test iterates over the instruction list of the function's block and performs
+/// modifications of the instruction list - mostly deleting instructions.
+/// Modifications are triggered by `string_literal` instructions with known "commands".
+/// E.g. if a
+/// ```
+///   %1 = string_literal utf8 "delete_strings"
+/// ```
+/// is encountered during the iteration, it triggers the deletion of all `string_literal`
+/// instructions of the basic block (including the current one).
+///
+let instructionIterationTest = Test("instruction_iteration") {
+  function, arguments, context in
+
+  print("Test instruction iteration in \(function.name):")
+
+  let reverse = function.name.string.hasSuffix("backward")
+
+  for block in function.blocks {
+    print("\(block.name):")
+    let termLoc = block.terminator.location
+    if reverse {
+      for inst in block.instructions.reversed() {
+        handle(instruction: inst, context)
+      }
+    } else {
+      for inst in block.instructions {
+        handle(instruction: inst, context)
+      }
+    }
+    if block.instructions.isEmpty || !(block.instructions.reversed().first is TermInst) {
+      let builder = Builder(atEndOf: block, location: termLoc, context)
+      builder.createUnreachable()
+    }
+  }
+  print("End function \(function.name):")
+}
+
+private func handle(instruction: Instruction, _ context: TestContext) {
+  print(instruction)
+  if let sl = instruction as? StringLiteralInst {
+    switch sl.value {
+      case "delete_strings":
+        deleteAllInstructions(ofType: StringLiteralInst.self, in: instruction.parentBlock, context)
+      case "delete_ints":
+        deleteAllInstructions(ofType: IntegerLiteralInst.self, in: instruction.parentBlock, context)
+      case "delete_branches":
+        deleteAllInstructions(ofType: BranchInst.self, in: instruction.parentBlock, context)
+      case "split_block":
+        _ = context.splitBlock(before: instruction)
+      case "print_uses":
+        for use in sl.uses {
+          print("use: \(use)")
+        }
+      case "delete_first_user":
+        deleteUser(of: sl, at: 0, context)
+      case "delete_second_user":
+        deleteUser(of: sl, at: 1, context)
+      default:
+        break
+    }
+  }
+}
+
+private func deleteAllInstructions<InstType: Instruction>(ofType: InstType.Type,
+                                                          in block: BasicBlock,
+                                                          _ context: TestContext)
+{
+  for inst in block.instructions {
+    if inst is InstType {
+      context.erase(instruction: inst)
+    }
+  }
+}
+
+private func deleteUser(of value: Value, at deleteIndex: Int, _ context: TestContext) {
+  for (idx, use) in value.uses.enumerated() {
+    if idx == deleteIndex {
+      context.erase(instruction: use.instruction)
+    } else {
+      print("use: \(use)")
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/TestPasses/TestInstructionIteration.swift

@@ -142,6 +142,8 @@ public func registerTests() {
   // Register each test.
   registerTests(
     parseTestSpecificationTest,
+    basicBlockTest,
+    instructionIterationTest,
     smallProjectionPathTest,
     getAccessBaseTest,
     accessPathTest,

SwiftCompilerSources/Sources/SIL/BasicBlock.swift

@@ -81,8 +81,6 @@ PASS(ComputeSideEffects, "compute-side-effects",
      "Computes function side effects")
 PASS(DiagnoseInfiniteRecursion, "diagnose-infinite-recursion",
      "Diagnose Infinitely-Recursive Code")
-PASS(TestInstructionIteration, "test-instruction-iteration",
-     "Tests instruction iteration")
 PASS(InitializeStaticGlobals, "initialize-static-globals",
      "Initializes static global variables")
 PASS(MandatoryRedundantLoadElimination, "mandatory-redundant-load-elimination",
@@ -116,8 +114,6 @@ PASS(ReleaseDevirtualizer, "release-devirtualizer",
      "SIL release Devirtualization")
 PASS(LetPropertyLowering, "let-property-lowering",
      "Lowers accesses to let properties of classes")
-PASS(SILPrinter, "sil-printer",
-     "Test pass which prints the SIL of a function")
 PASS(FunctionStackProtection, "function-stack-protection",
      "Decides which functions need stack protectors")
 PASS(Simplification, "simplification",