Merge pull request #61433 from eeckstein/side-effects

Swift Optimizer: add side effect analysis

Author: eeckstein

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -40,19 +40,31 @@ public func assert(_ condition: Bool, file: StaticString = #fileID, line: UInt =
   }
 }
 
+//===----------------------------------------------------------------------===//
+//                            Debugging Utilities
+//===----------------------------------------------------------------------===//
+
+/// Let's lldb's `po` command not print any "internal" properties of the conforming type.
+///
+/// This is useful if the `description` already contains all the information of a type instance.
+public protocol NoReflectionChildren : CustomReflectable { }
+
+public extension NoReflectionChildren {
+  var customMirror: Mirror { Mirror(self, children: []) }
+}
+
 
 //===----------------------------------------------------------------------===//
 //                              StringRef
 //===----------------------------------------------------------------------===//
 
-public struct StringRef : CustomStringConvertible, CustomReflectable {
+public struct StringRef : CustomStringConvertible, NoReflectionChildren {
   let _bridged: llvm.StringRef
 
   public init(bridged: llvm.StringRef) { self._bridged = bridged }
 
   public var string: String { _bridged.string }
   public var description: String { string }
-  public var customMirror: Mirror { Mirror(self, children: []) }
 
   public static func ==(lhs: StringRef, rhs: StaticString) -> Bool {
     let lhsBuffer = UnsafeBufferPointer<UInt8>(

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift

@@ -46,7 +46,7 @@ import SIL
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
+struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
 
   /// The dominating begin block.
   let begin: BasicBlock
@@ -149,8 +149,6 @@ struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
       """
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
-
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     worklist.deinitialize()

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockWorklist.swift

@@ -20,7 +20,7 @@ import SIL
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct BasicBlockWorklist : CustomStringConvertible, CustomReflectable {
+struct BasicBlockWorklist : CustomStringConvertible, NoReflectionChildren {
   private var worklist: Stack<BasicBlock>
   private var pushedBlocks: BasicBlockSet
 
@@ -56,7 +56,7 @@ struct BasicBlockWorklist : CustomStringConvertible, CustomReflectable {
     """
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
+  var function: Function { pushedBlocks.function }
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func 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/InstructionRange.swift

@@ -38,7 +38,7 @@ import SIL
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct InstructionRange : CustomStringConvertible, CustomReflectable {
+struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
   /// The dominating begin instruction.
   let begin: Instruction
@@ -139,8 +139,6 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
       """
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
-
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     insertedInsts.deinitialize()

SwiftCompilerSources/Sources/Optimizer/DataStructures/Set.swift

@@ -21,7 +21,7 @@ import OptimizerBridging
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct BasicBlockSet : CustomStringConvertible, CustomReflectable {
+struct BasicBlockSet : CustomStringConvertible, NoReflectionChildren {
 
   private let context: PassContext
   private let bridged: BridgedBasicBlockSet
@@ -46,13 +46,12 @@ struct BasicBlockSet : CustomStringConvertible, CustomReflectable {
   }
 
   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 customMirror: Mirror { Mirror(self, children: []) }
+  var function: Function { BasicBlockSet_getFunction(bridged).function }
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
@@ -68,7 +67,7 @@ struct BasicBlockSet : CustomStringConvertible, CustomReflectable {
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct ValueSet : CustomStringConvertible, CustomReflectable {
+struct ValueSet : CustomStringConvertible, NoReflectionChildren {
 
   private let context: PassContext
   private let bridged: BridgedNodeSet
@@ -113,8 +112,6 @@ struct ValueSet : CustomStringConvertible, CustomReflectable {
     return d
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
-
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     PassContext_freeNodeSet(context._bridged, bridged)
@@ -129,7 +126,7 @@ struct ValueSet : CustomStringConvertible, CustomReflectable {
 /// This type should be a move-only type, but unfortunately we don't have move-only
 /// types yet. Therefore it's needed to call `deinitialize()` explicitly to
 /// destruct this data structure, e.g. in a `defer {}` block.
-struct InstructionSet : CustomStringConvertible, CustomReflectable {
+struct InstructionSet : CustomStringConvertible, NoReflectionChildren {
 
   private let context: PassContext
   private let bridged: BridgedNodeSet
@@ -165,8 +162,6 @@ struct InstructionSet : CustomStringConvertible, CustomReflectable {
     return d
   }
 
-  var customMirror: Mirror { Mirror(self, children: []) }
-
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
     PassContext_freeNodeSet(context._bridged, bridged)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -8,7 +8,8 @@
 
 swift_compiler_sources(Optimizer
   AssumeSingleThreaded.swift
-  ComputeEffects.swift
+  ComputeEscapeEffects.swift
+  ComputeSideEffects.swift
   ObjCBridgingOptimization.swift
   MergeCondFails.swift
   ReleaseDevirtualizer.swift

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEffects.swift renamed to SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -1,4 +1,4 @@
-//===--- ComputeEffects.swift - Compute function effects ------------------===//
+//===--- ComputeEscapeEffects.swift ----------------------------------------==//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -12,43 +12,47 @@
 
 import SIL
 
-/// Computes effects for function arguments.
+/// Computes escape effects for function arguments.
 ///
 /// For example, if an argument does not escape, adds a non-escaping effect,
-/// e.g. "[escapes !%0.**]":
-///
-///   sil [escapes !%0.**] @foo : $@convention(thin) (@guaranteed X) -> () {
+/// ```
+///   sil @foo : $@convention(thin) (@guaranteed X) -> () {
+///   [%0: noecape **]
 ///   bb0(%0 : $X):
 ///     %1 = tuple ()
 ///     return %1 : $()
 ///   }
-///
+/// ```
 /// The pass does not try to change or re-compute _defined_ effects.
-/// Currently, only escaping effects are handled.
-/// In future, this pass may also add other effects, like memory side effects.
-let computeEffects = FunctionPass(name: "compute-effects", {
+///
+let computeEscapeEffects = FunctionPass(name: "compute-escape-effects", {
   (function: Function, context: PassContext) in
-  var argsWithDefinedEffects = getArgIndicesWithDefinedEffects(of: function)
 
-  struct IgnoreRecursiveCallVisitor : EscapeVisitor {
-    func visitUse(operand: Operand, path: EscapePath) -> UseResult {
-      return isOperandOfRecursiveCall(operand) ? .ignore : .continueWalk
-    }
-  }
-  var newEffects = Stack<ArgumentEffect>(context)
+  var newEffects = Stack<EscapeEffects.ArgumentEffect>(context)
+  defer { newEffects.deinitialize() }
+
   let returnInst = function.returnInstruction
+  let argsWithDefinedEffects = getArgIndicesWithDefinedEscapingEffects(of: function)
 
   for arg in function.arguments {
     // We are not interested in arguments with trivial types.
     if !arg.type.isNonTrivialOrContainsRawPointer(in: function) { continue }
 
     // Also, we don't want to override defined effects.
     if argsWithDefinedEffects.contains(arg.index) { continue }
-    
+
+    struct IgnoreRecursiveCallVisitor : EscapeVisitor {
+      func visitUse(operand: Operand, path: EscapePath) -> UseResult {
+        return isOperandOfRecursiveCall(operand) ? .ignore : .continueWalk
+      }
+    }
+
     // First check: is the argument (or a projected value of it) escaping at all?
     if !arg.at(.anything).isEscapingWhenWalkingDown(using: IgnoreRecursiveCallVisitor(),
                                                     context) {
-      newEffects.push(ArgumentEffect(.notEscaping, argumentIndex: arg.index, pathPattern: SmallProjectionPath(.anything)))
+      let effect = EscapeEffects.ArgumentEffect(.notEscaping, argumentIndex: arg.index,
+                                                pathPattern: SmallProjectionPath(.anything))
+      newEffects.push(effect)
       continue
     }
 
@@ -62,17 +66,16 @@ let computeEffects = FunctionPass(name: "compute-effects", {
   }
 
   context.modifyEffects(in: function) { (effects: inout FunctionEffects) in
-    effects.removeDerivedEffects()
-    effects.argumentEffects.append(contentsOf: newEffects)
+    effects.escapeEffects.arguments = effects.escapeEffects.arguments.filter { !$0.isDerived }
+    effects.escapeEffects.arguments.append(contentsOf: newEffects)
   }
-  newEffects.removeAll()
 })
 
 
 /// Returns true if an argument effect was added.
 private
 func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
-                   to newEffects: inout Stack<ArgumentEffect>,
+                   to newEffects: inout Stack<EscapeEffects.ArgumentEffect>,
                    _ returnInst: ReturnInst?, _ context: PassContext) -> Bool {
   // Correct the path if the argument is not a class reference itself, but a value type
   // containing one or more references.
@@ -141,39 +144,36 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
     return false
   }
 
-  let effect: ArgumentEffect
+  let effect: EscapeEffects.ArgumentEffect
   switch result {
   case .notSet:
-    effect = ArgumentEffect(.notEscaping, argumentIndex: arg.index, pathPattern: argPath)
+    effect = EscapeEffects.ArgumentEffect(.notEscaping, argumentIndex: arg.index, pathPattern: argPath)
   case .toReturn(let toPath):
     let exclusive = isExclusiveEscapeToReturn(fromArgument: arg, fromPath: argPath,
                                               toPath: toPath, returnInst: returnInst, context)
-    effect = ArgumentEffect(.escapingToReturn(toPath, exclusive),
-                            argumentIndex: arg.index, pathPattern: argPath)
+    effect = EscapeEffects.ArgumentEffect(.escapingToReturn(toPath, exclusive),
+                                          argumentIndex: arg.index, pathPattern: argPath)
   case .toArgument(let toArgIdx, let toPath):
     let exclusive = isExclusiveEscapeToArgument(fromArgument: arg, fromPath: argPath,
                                                 toArgumentIndex: toArgIdx, toPath: toPath, context)
-    effect = ArgumentEffect(.escapingToArgument(toArgIdx, toPath, exclusive),
-                            argumentIndex: arg.index, pathPattern: argPath)
+    effect = EscapeEffects.ArgumentEffect(.escapingToArgument(toArgIdx, toPath, exclusive),
+                                          argumentIndex: arg.index, pathPattern: argPath)
   }
   newEffects.push(effect)
   return true
 }
 
 /// Returns a set of argument indices for which there are "defined" effects (as opposed to derived effects).
-private func getArgIndicesWithDefinedEffects(of function: Function) -> Set<Int> {
+private func getArgIndicesWithDefinedEscapingEffects(of function: Function) -> Set<Int> {
   var argsWithDefinedEffects = Set<Int>()
 
-  for effect in function.effects.argumentEffects {
+  for effect in function.effects.escapeEffects.arguments {
     if effect.isDerived { continue }
 
     argsWithDefinedEffects.insert(effect.argumentIndex)
-
     switch effect.kind {
-    case .notEscaping, .escapingToReturn:
-      break
-    case .escapingToArgument(let toArgIdx, _, _):
-      argsWithDefinedEffects.insert(toArgIdx)
+      case .notEscaping, .escapingToReturn:         break
+      case .escapingToArgument(let toArgIdx, _, _): argsWithDefinedEffects.insert(toArgIdx)
     }
   }
   return argsWithDefinedEffects