SwiftCompilerSources: move SIL-related datastructures from the Optimizer to the SIL module

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/DataStructures/CMakeLists.txt

@@ -7,11 +7,6 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
-  BasicBlockRange.swift
   DeadEndBlocks.swift
   FunctionUses.swift
-  InstructionRange.swift
-  ReachableBlocks.swift
-  Set.swift
-  Stack.swift
-  Worklist.swift)
+  ReachableBlocks.swift)

SwiftCompilerSources/Sources/Optimizer/Utilities/AccessUtilsTest.swift

@@ -14,6 +14,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+import SIL
+
 let getAccessBaseTest = FunctionTest("swift_get_access_base") {
   function, arguments, context in
   let address = arguments.takeValue()

SwiftCompilerSources/Sources/Optimizer/Utilities/OwnershipLiveness.swift

@@ -904,3 +904,29 @@ let interiorLivenessTest = FunctionTest("interior_liveness_swift") {
   defer { boundary.deinitialize() }
   print(boundary)
 }
+
+//
+// TODO: Move this to InstructionRange.swift when computeLinearLiveness is in the SIL module.
+//
+let rangeOverlapsPathTest = FunctionTest("range_overlaps_path") {
+  function, arguments, context in
+  let rangeValue = arguments.takeValue()
+  print("Range of: \(rangeValue)")
+  var range = computeLinearLiveness(for: rangeValue, context)
+  defer { range.deinitialize() }
+  let pathInst = arguments.takeInstruction()
+  print("Path begin: \(pathInst)")
+  if let pathBegin = pathInst as? ScopedInstruction {
+    for end in pathBegin.endInstructions {
+      print("Overlap kind:", range.overlaps(pathBegin: pathInst, pathEnd: end, context))
+    }
+    return
+  }
+  if let pathValue = pathInst as? SingleValueInstruction, pathValue.ownership == .owned {
+    for end in pathValue.uses.endingLifetime {
+      print("Overlap kind:", range.overlaps(pathBegin: pathInst, pathEnd: end.instruction, context))
+    }
+    return
+  }
+  print("Test specification error: not a scoped or owned instruction: \(pathInst)")
+}

SwiftCompilerSources/Sources/SIL/CMakeLists.txt

@@ -35,5 +35,6 @@ add_swift_compiler_module(SIL
     VTable.swift
     WitnessTable.swift)
 
+add_subdirectory(DataStructures)
 add_subdirectory(Utilities)
 

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift renamed to SwiftCompilerSources/Sources/SIL/DataStructures/BasicBlockRange.swift

@@ -10,8 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import SIL
-
 /// A range of basic blocks.
 ///
 /// The `BasicBlockRange` defines a range from a dominating "begin" block to one or more "end" blocks.
@@ -46,16 +44,16 @@ 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, NoReflectionChildren {
+public struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
 
   /// The dominating begin block.
-  let begin: BasicBlock
+  public let begin: BasicBlock
 
   /// The inclusive range, i.e. the exclusive range plus the end blocks.
-  private(set) var inclusiveRange: Stack<BasicBlock>
-  
+  public private(set) var inclusiveRange: Stack<BasicBlock>
+
   /// The exclusive range, i.e. not containing the end blocks.
-  var range: LazyFilterSequence<Stack<BasicBlock>> {
+  public var range: LazyFilterSequence<Stack<BasicBlock>> {
     inclusiveRange.lazy.filter { contains($0) }
   }
 
@@ -66,7 +64,7 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
   private var inExclusiveRange: BasicBlockSet
   private var worklist: BasicBlockWorklist
 
-  init(begin: BasicBlock, _ context: some Context) {
+  public init(begin: BasicBlock, _ context: some Context) {
     self.begin = begin
     self.inclusiveRange = Stack(context)
     self.inserted = Stack(context)
@@ -81,7 +79,7 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
   /// 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 {
+  public mutating func insert(_ block: BasicBlock) -> Bool {
     if wasInserted.insert(block) {
       inserted.append(block)
     }
@@ -103,35 +101,35 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   /// Insert a sequence of potential end blocks.
-  mutating func insert<S: Sequence>(contentsOf other: S) where S.Element == BasicBlock {
+  public mutating func insert<S: Sequence>(contentsOf other: S) where S.Element == BasicBlock {
     for block in other {
       insert(block)
     }
   }
 
   /// Returns true if the exclusive range contains `block`.
-  func contains(_ block: BasicBlock) -> Bool { inExclusiveRange.contains(block) }
-  
+  public func contains(_ block: BasicBlock) -> Bool { inExclusiveRange.contains(block) }
+
   /// Returns true if the inclusive range contains `block`.
-  func inclusiveRangeContains (_ block: BasicBlock) -> Bool {
+  public func inclusiveRangeContains (_ block: BasicBlock) -> Bool {
     worklist.hasBeenPushed(block)
   }
 
   /// Returns true if the range is valid and that's iff the begin block dominates all blocks of the range.
-  var isValid: Bool {
+  public var isValid: Bool {
     let entry = begin.parentFunction.entryBlock
     return begin == entry ||
       // If any block in the range is not dominated by `begin`, the range propagates back to the entry block.
       !inclusiveRangeContains(entry)
   }
 
   /// Returns the end blocks.
-  var ends: LazyFilterSequence<Stack<BasicBlock>> {
+  public var ends: LazyFilterSequence<Stack<BasicBlock>> {
     inserted.lazy.filter { !contains($0) }
   }
 
   /// Returns the exit blocks.
-  var exits: LazySequence<FlattenSequence<
+  public var exits: LazySequence<FlattenSequence<
                     LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
                                     LazyFilterSequence<SuccessorArray>>>> {
     range.flatMap {
@@ -142,11 +140,11 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   /// Returns the interior blocks.
-  var interiors: LazyFilterSequence<Stack<BasicBlock>> {
+  public var interiors: LazyFilterSequence<Stack<BasicBlock>> {
     inserted.lazy.filter { contains($0) && $0 != begin }
   }
 
-  var description: String {
+  public var description: String {
     return (isValid ? "" : "<invalid>\n") +
       """
       begin:     \(begin.name)
@@ -159,7 +157,7 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   /// TODO: once we have move-only types, make this a real deinit.
-  mutating func deinitialize() {
+  public mutating func deinitialize() {
     worklist.deinitialize()
     inExclusiveRange.deinitialize()
     wasInserted.deinitialize()

SwiftCompilerSources/Sources/SIL/DataStructures/CMakeLists.txt

@@ -0,0 +1,14 @@
+# This source file is part of the Swift.org open source project
+#
+# Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+# Licensed under Apache License v2.0 with Runtime Library Exception
+#
+# See http://swift.org/LICENSE.txt for license information
+# See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+
+swift_compiler_sources(SIL
+  BasicBlockRange.swift
+  InstructionRange.swift
+  Set.swift
+  Stack.swift
+  Worklist.swift)

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift renamed to SwiftCompilerSources/Sources/SIL/DataStructures/InstructionRange.swift

@@ -10,8 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-import SIL
-
 /// A range of instructions.
 ///
 /// The `InstructionRange` defines a range from a dominating "begin" instruction to one or more "end" instructions.
@@ -38,29 +36,29 @@ 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, NoReflectionChildren {
-  
+public struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
+
   /// The underlying block range.
-  private(set) var blockRange: BasicBlockRange
+  public private(set) var blockRange: BasicBlockRange
 
   private var insertedInsts: InstructionSet
 
   // For efficiency, this set does not include instructions in blocks which are not the begin or any end block.
   private var inExclusiveRange: InstructionSet
 
-  init(begin beginInst: Instruction, _ context: some Context) {
+  public init(begin beginInst: Instruction, _ context: some Context) {
     self = InstructionRange(beginBlock: beginInst.parentBlock, context)
     self.inExclusiveRange.insert(beginInst)
   }
 
   // Note: 'ends' are simply the instructions to insert in the range. 'self.ends' might not return the same sequence
   // as this 'ends' argument because 'self.ends' will not include block exits.
-  init<S: Sequence>(begin beginInst: Instruction, ends: S, _ context: some Context) where S.Element: Instruction {
+  public init<S: Sequence>(begin beginInst: Instruction, ends: S, _ context: some Context) where S.Element: Instruction {
     self = InstructionRange(begin: beginInst, context)
     insert(contentsOf: ends)
   }
 
-  init(for value: Value, _ context: some Context) {
+  public init(for value: Value, _ context: some Context) {
     if let inst = value.definingInstruction {
       self = InstructionRange(begin: inst, context)
     } else if let arg = value as? Argument {
@@ -77,7 +75,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   /// Insert a potential end instruction.
-  mutating func insert(_ inst: Instruction) {
+  public mutating func insert(_ inst: Instruction) {
     insertedInsts.insert(inst)
     insertIntoRange(instructions: ReverseInstructionList(first: inst.previous))
     if blockRange.insert(inst.parentBlock) {
@@ -90,14 +88,14 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   /// Insert a sequence of potential end instructions.
-  mutating func insert<S: Sequence>(contentsOf other: S) where S.Element: Instruction {
+  public mutating func insert<S: Sequence>(contentsOf other: S) where S.Element: Instruction {
     for inst in other {
       insert(inst)
     }
   }
 
   /// Returns true if the exclusive range contains `inst`.
-  func contains(_ inst: Instruction) -> Bool {
+  public func contains(_ inst: Instruction) -> Bool {
     if inExclusiveRange.contains(inst) {
       return true
     }
@@ -106,37 +104,37 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   /// Returns true if the inclusive range contains `inst`.
-  func inclusiveRangeContains (_ inst: Instruction) -> Bool {
+  public func inclusiveRangeContains (_ inst: Instruction) -> Bool {
     contains(inst) || insertedInsts.contains(inst)
   }
 
   /// Returns the end instructions.
   ///
   /// Warning: this returns `begin` if no instructions were inserted.
-  var ends: LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>, Instruction> {
+  public var ends: LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>, Instruction> {
     blockRange.ends.map {
       $0.instructions.reversed().first(where: { insertedInsts.contains($0)})!
     }
   }
 
   // Returns the exit blocks.
-  var exitBlocks: LazySequence<FlattenSequence<
-                    LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
+  public var exitBlocks: LazySequence<FlattenSequence<
+                             LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
                                     LazyFilterSequence<SuccessorArray>>>> {
     blockRange.exits
   }
 
   /// Returns the exit instructions.
-  var exits: LazyMapSequence<LazySequence<FlattenSequence<
-                               LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
+  public var exits: LazyMapSequence<LazySequence<FlattenSequence<
+                                         LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
                                                LazyFilterSequence<SuccessorArray>>>>,
                              Instruction> {
     blockRange.exits.lazy.map { $0.instructions.first! }
   }
 
   /// Returns the interior instructions.
-  var interiors: LazySequence<FlattenSequence<
-                   LazyMapSequence<Stack<BasicBlock>,
+  public var interiors: LazySequence<FlattenSequence<
+                             LazyMapSequence<Stack<BasicBlock>,
                                    LazyFilterSequence<ReverseInstructionList>>>> {
     blockRange.inserted.lazy.flatMap {
       var include = blockRange.contains($0)
@@ -151,7 +149,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
     }
   }
 
-  var begin: Instruction? {
+  public var begin: Instruction? {
     blockRange.begin.instructions.first(where: inExclusiveRange.contains)
   }
 
@@ -163,7 +161,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
     }
   }
 
-  var description: String {
+  public var description: String {
     return (blockRange.isValid ? "" : "<invalid>\n") +
       """
       begin:    \(begin?.description ?? blockRange.begin.name)
@@ -174,15 +172,15 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   /// TODO: once we have move-only types, make this a real deinit.
-  mutating func deinitialize() {
+  public mutating func deinitialize() {
     inExclusiveRange.deinitialize()
     insertedInsts.deinitialize()
     blockRange.deinitialize()
   }
 }
 
 extension InstructionRange {
-  enum PathOverlap {
+  public enum PathOverlap {
     // range:  ---
     //          |    pathBegin
     //          |        |
@@ -226,7 +224,7 @@ extension InstructionRange {
   /// Returns .containsBegin, if this range has the same begin and end as the path.
   ///
   /// Precondition: `begin` dominates `end`.
-  func overlaps(pathBegin: Instruction, pathEnd: Instruction, _ context: some Context) -> PathOverlap {
+  public func overlaps(pathBegin: Instruction, pathEnd: Instruction, _ context: some Context) -> PathOverlap {
     assert(pathBegin != pathEnd, "expect an exclusive path")
     if contains(pathBegin) {
       // Note: pathEnd != self.begin here since self.contains(pathBegin)
@@ -277,25 +275,3 @@ extension InstructionRange {
   }
 }
 
-let rangeOverlapsPathTest = FunctionTest("range_overlaps_path") {
-  function, arguments, context in
-  let rangeValue = arguments.takeValue()
-  print("Range of: \(rangeValue)")
-  var range = computeLinearLiveness(for: rangeValue, context)
-  defer { range.deinitialize() }
-  let pathInst = arguments.takeInstruction()
-  print("Path begin: \(pathInst)")
-  if let pathBegin = pathInst as? ScopedInstruction {
-    for end in pathBegin.endInstructions {
-      print("Overlap kind:", range.overlaps(pathBegin: pathInst, pathEnd: end, context))
-    }
-    return
-  }
-  if let pathValue = pathInst as? SingleValueInstruction, pathValue.ownership == .owned {
-    for end in pathValue.uses.endingLifetime {
-      print("Overlap kind:", range.overlaps(pathBegin: pathInst, pathEnd: end.instruction, context))
-    }
-    return
-  }
-  print("Test specification error: not a scoped or owned instruction: \(pathInst)")
-}