Merge pull request #82349 from eeckstein/alloc-box-to-stack

Optimizer: re-implement and improve the AllocBoxToStack pass

Author: eeckstein

SwiftCompilerSources/Sources/AST/Declarations.swift

@@ -157,3 +157,9 @@ extension OptionalBridgedDeclObj {
   public var decl: Decl? { obj.getAs(Decl.self) }
   public func getAs<T: Decl>(_ declType: T.Type) -> T? { obj.getAs(T.self) }
 }
+
+extension Optional where Wrapped == Decl {
+  public var bridged: OptionalBridgedDeclObj {
+    OptionalBridgedDeclObj(self?.bridged.obj)
+  }
+}

SwiftCompilerSources/Sources/AST/Type.swift

@@ -141,6 +141,7 @@ extension TypeProperties {
   public var isMetatype: Bool { rawType.bridged.isMetatypeType() }
   public var isExistentialMetatype: Bool { rawType.bridged.isExistentialMetatypeType() }
   public var isDynamicSelf: Bool { rawType.bridged.isDynamicSelf()}
+  public var isBox: Bool { rawType.bridged.isBox() }
 
   /// True if this is the type which represents an integer literal used in a type position.
   /// For example `N` in `struct T<let N: Int> {}`

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift

@@ -77,20 +77,29 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   /// Insert a potential end block.
-  mutating func insert(_ block: BasicBlock) {
+  ///
+  /// Returns true if the begin-block is reached during backward propagation.
+  /// Usually this is not relevant, but InstructionRange needs this information.
+  @discardableResult
+  mutating func insert(_ block: BasicBlock) -> Bool {
     if wasInserted.insert(block) {
       inserted.append(block)
     }
     worklist.pushIfNotVisited(block)
+    var visitedBeginBlock = false
     while let b = worklist.pop() {
       inclusiveRange.append(b)
       if b != begin {
         for pred in b.predecessors {
+          if pred == begin {
+            visitedBeginBlock = true
+          }
           worklist.pushIfNotVisited(pred)
           inExclusiveRange.insert(pred)
         }
       }
     }
+    return visitedBeginBlock
   }
 
   /// Insert a sequence of potential end blocks.

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -80,8 +80,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   mutating func insert(_ inst: Instruction) {
     insertedInsts.insert(inst)
     insertIntoRange(instructions: ReverseInstructionList(first: inst.previous))
-    blockRange.insert(inst.parentBlock)
-    if inst.parentBlock != blockRange.begin {
+    if blockRange.insert(inst.parentBlock) {
       // The first time an instruction is inserted in another block than the begin-block we need to insert
       // instructions from the begin instruction to the end of the begin block.
       // For subsequent insertions this is a no-op: `insertIntoRange` will return immediately because those

SwiftCompilerSources/Sources/Optimizer/DataStructures/Worklist.swift

@@ -110,3 +110,63 @@ extension InstructionWorklist {
   }
 }
 
+/// A worklist for `Function`s.
+struct FunctionWorklist {
+
+  // The current functions in the worklist.
+  private(set) var functions = Array<Function>()
+
+  // All functions which were ever pushed to the worklist.
+  private var pushedFunctions = Set<Function>()
+
+  mutating func pushIfNotVisited(_ function: Function) {
+    if pushedFunctions.insert(function).inserted {
+      functions.append(function)
+    }
+  }
+
+  mutating func pushIfNotVisited(contentsOf functions: [Function]) {
+    for f in functions {
+      pushIfNotVisited(f)
+    }
+  }
+
+  mutating func pop() -> Function? {
+    return functions.popLast()
+  }
+}
+
+/// Like `ValueWorklist`, but allows pushing `Value`s from different functions -
+/// at the cost of a less efficient implementation.
+struct CrossFunctionValueWorklist {
+
+  // The current values in the worklist.
+  private(set) var values = Array<Value>()
+
+  // All values which were ever pushed to the worklist.
+  private var pushedValues = Set<ObjectIdentifier>(minimumCapacity: 8)
+
+  init() {
+    values.reserveCapacity(8)
+  }
+
+  mutating func pop() -> Value? {
+    return values.popLast()
+  }
+
+  mutating func pushIfNotVisited(_ value: Value) {
+    if pushedValues.insert(ObjectIdentifier(value)).inserted {
+      values.append(value)
+    }
+  }
+
+  mutating func pushIfNotVisited<S: Sequence>(contentsOf values: S) where S.Element == Value {
+    for value in values {
+      pushIfNotVisited(value)
+    }
+  }
+
+  func hasBeenPushed(_ value: Value) -> Bool {
+    return pushedValues.contains(ObjectIdentifier(value))
+  }
+}