Swift Optimizer: add the DeadEndBlocks utility for finding dead-end blocks.

Dead-end blocks are blocks from which there is no path to the function exit (`return`, `throw` or unwind).
These are blocks which end with an unreachable instruction and blocks from which all paths end in "unreachable" blocks.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockWorklist.swift

@@ -56,6 +56,8 @@ struct BasicBlockWorklist : CustomStringConvertible, NoReflectionChildren {
     """
   }
 
+  var function: Function { pushedBlocks.function }
+
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     pushedBlocks.deinitialize()

SwiftCompilerSources/Sources/Optimizer/DataStructures/CMakeLists.txt

@@ -9,6 +9,7 @@
 swift_compiler_sources(Optimizer
   BasicBlockRange.swift
   BasicBlockWorklist.swift
+  DeadEndBlocks.swift
   FunctionUses.swift
   InstructionRange.swift
   Set.swift

SwiftCompilerSources/Sources/Optimizer/DataStructures/DeadEndBlocks.swift

@@ -0,0 +1,51 @@
+//===--- DeadEndBlocks.swift ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+/// A utility for finding dead-end blocks.
+///
+/// Dead-end blocks are blocks from which there is no path to the function exit
+/// (`return`, `throw` or unwind). These are blocks which end with an unreachable
+/// instruction and blocks from which all paths end in "unreachable" blocks.
+struct DeadEndBlocks : CustomStringConvertible, NoReflectionChildren {
+  private var worklist: BasicBlockWorklist
+  
+  init(function: Function, _ context: PassContext) {
+    self.worklist = BasicBlockWorklist(context)
+    
+    // Initialize the worklist with all function-exiting blocks.
+    for block in function.blocks where block.terminator.isFunctionExiting {
+      worklist.pushIfNotVisited(block)
+    }
+    
+    // Propagate lifeness up the control flow.
+    while let block = worklist.pop() {
+      worklist.pushIfNotVisited(contentsOf: block.predecessors)
+    }
+  }
+  
+  /// Returns true if `block` is a dead-end block.
+  func isDeadEnd(block: BasicBlock) -> Bool {
+    return !worklist.hasBeenPushed(block)
+  }
+
+  var description: String {
+    let blockNames = worklist.function.blocks.filter(isDeadEnd).map(\.name)
+    return "[" + blockNames.joined(separator: ",") + "]"
+  }
+
+  /// TODO: once we have move-only types, make this a real deinit.
+  mutating func deinitialize() {
+    worklist.deinitialize()
+  }
+}

SwiftCompilerSources/Sources/Optimizer/DataStructures/Set.swift

@@ -46,12 +46,12 @@ struct BasicBlockSet : CustomStringConvertible, NoReflectionChildren {
   }
 
   var description: String {
-    let function = BasicBlockSet_getFunction(bridged).function
     let blockNames = function.blocks.enumerated().filter { contains($0.1) }
                                                  .map { "bb\($0.0)"}
     return "{" + blockNames.joined(separator: ", ") + "}"
   }
 
+  var function: Function { BasicBlockSet_getFunction(bridged).function }
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -70,6 +70,7 @@ private func registerSwiftPasses() {
   registerPass(escapeInfoDumper, { escapeInfoDumper.run($0) })
   registerPass(addressEscapeInfoDumper, { addressEscapeInfoDumper.run($0) })
   registerPass(accessDumper, { accessDumper.run($0) })
+  registerPass(deadEndBlockDumper, { deadEndBlockDumper.run($0) })
   registerPass(rangeDumper, { rangeDumper.run($0) })
   registerPass(runUnitTests, { runUnitTests.run($0) })
 }

SwiftCompilerSources/Sources/Optimizer/TestPasses/CMakeLists.txt

@@ -9,6 +9,7 @@
 swift_compiler_sources(Optimizer
   FunctionUsesDumper.swift
   AccessDumper.swift
+  DeadEndBlockDumper.swift
   EscapeInfoDumper.swift
   SILPrinter.swift
   RangeDumper.swift

SwiftCompilerSources/Sources/Optimizer/TestPasses/DeadEndBlockDumper.swift

@@ -0,0 +1,26 @@
+//===--- DeadEndBlockDumper.swift -----------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+let deadEndBlockDumper = FunctionPass(name: "dump-deadendblocks", {
+  (function: Function, context: PassContext) in
+
+  
+  print("Function \(function.name)")
+  
+  var deadEndBlocks = DeadEndBlocks(function: function, context)
+  print(deadEndBlocks)
+  defer { deadEndBlocks.deinitialize() }
+
+  print("end function \(function.name)")
+})

docs/SIL-Utilities.md

@@ -99,6 +99,15 @@ A set of utilities for analyzing memory accesses. It defines the following conce
 
 ## Control- and Dataflow
 
+#### `DeadEndBlocks`
+A utility for finding dead-end blocks.
+Dead-end blocks are blocks from which there is no path to the function exit (`return`, `throw` or unwind).
+These are blocks which end with an unreachable instruction and blocks from which all paths end in "unreachable" blocks.
+
+**Uses:** `BasicBlockWorklist`  
+**Related C++ utilities:** `DeadEndBlocks`  
+**Status:** done
+
 #### `BasicBlockRange`
 Defines a range from a dominating "begin" block to one or more "end" blocks. To be used for all kind of backward block reachability analysis.
 

include/swift/SILOptimizer/PassManager/Passes.def

@@ -235,6 +235,8 @@ PASS(EmitDFDiagnostics, "dataflow-diagnostics",
      "Emit SIL Diagnostics")
 PASS(EscapeAnalysisDumper, "escapes-dump",
      "Dump Escape Analysis Results")
+SWIFT_FUNCTION_PASS(DeadEndBlockDumper, "dump-deadendblocks",
+     "Tests the DeadEndBlocks utility")
 SWIFT_FUNCTION_PASS(EscapeInfoDumper, "dump-escape-info",
      "Dumps escape information")
 SWIFT_FUNCTION_PASS(AddressEscapeInfoDumper, "dump-addr-escape-info",

test/SILOptimizer/deadendblocks.sil

@@ -0,0 +1,81 @@
+// RUN: %target-sil-opt %s -dump-deadendblocks -o /dev/null | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+sil_stage canonical
+
+import Builtin
+import Swift
+
+// CHECK-LABEL: Function simple_test
+// CHECK:       [bb2]
+// CHECK:       end function simple_test
+sil @simple_test : $@convention(thin) () -> () {
+bb0:
+  cond_br undef, bb1, bb2
+bb1:
+  br bb3
+bb2:
+  unreachable
+bb3:
+  %r = tuple ()
+  return %r : $()
+}
+
+sil @throwing_fun : $@convention(thin) () -> ((), @error any Error)
+
+// CHECK-LABEL: Function test_throw
+// CHECK:       [bb1]
+// CHECK:       end function test_throw
+sil @test_throw : $@convention(thin) () -> ((), @error any Error) {
+bb0:
+  %0 = function_ref @throwing_fun : $@convention(thin) () -> ((), @error any Error)
+  try_apply %0() : $@convention(thin) () -> ((), @error any Error), normal bb1, error bb2
+bb1(%2: $()):
+  unreachable
+bb2(%3 : $Error):
+  throw %3 : $Error
+}
+
+
+// CHECK-LABEL: Function test_unwind
+// CHECK:       [bb1]
+// CHECK:       end function test_unwind
+sil @test_unwind : $@yield_once @convention(thin) () -> @yields () {
+bb0:
+  %t = tuple ()
+  yield %t : $(), resume bb1, unwind bb2
+bb1:
+  unreachable
+bb2:
+  unwind
+}
+
+// CHECK-LABEL: Function complex_cfg
+// CHECK:       [bb7,bb8,bb9]
+// CHECK:       end function complex_cfg
+sil @complex_cfg : $@convention(thin) () -> ((), @error any Error) {
+bb0:
+  cond_br undef, bb1, bb7
+bb1:
+  %0 = function_ref @throwing_fun : $@convention(thin) () -> ((), @error any Error)
+  try_apply %0() : $@convention(thin) () -> ((), @error any Error), normal bb2, error bb3
+bb2(%2: $()):
+  br bb4
+bb3(%3 : $Error):
+  throw %3 : $Error
+bb4:
+  cond_br undef, bb5, bb6
+bb5:
+  br bb4
+bb6:
+  %r = tuple ()
+  return %r : $()
+bb7:
+  br bb8
+bb8:
+  cond_br undef, bb8, bb9
+bb9:
+  unreachable
+}
+