Merge pull request #63052 from eeckstein/swift-sil-infrastructure

Swift SIL and Optimizer: improvements, refactoring and bug fixes

Author: eeckstein

SwiftCompilerSources/README.md

@@ -156,9 +156,9 @@ With instruction passes it's possible to implement small peephole optimizations
 
 To add a new instruction pass:
 
-* add a `SWIFT_INSTRUCTION_PASS` entry in `Passes.def`
+* add a `SWIFT_SILCOMBINE_PASS` entry in `Passes.def`
 * create a new Swift file in `SwiftCompilerSources/Optimizer/InstructionPasses`
-* add an `InstructionPass` global
+* implement the `simplify` function in conformance to `SILCombineSimplifyable`
 * register the pass in `registerSwiftPasses()`
 * if this pass replaces an existing `SILCombiner` visit function, remove the old visit function
 

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -65,7 +65,7 @@ struct AliasAnalysis {
  AliasAnalysis_register(
  // getMemEffectsFn
  { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction) -> BridgedMemoryBehavior in
- let context = PassContext(_bridged: bridgedCtxt)
+ let context = FunctionPassContext(_bridged: bridgedCtxt)
  let inst = bridgedInst.instruction
  let val = bridgedVal.value
  let path = AliasAnalysis.getPtrOrAddressPath(for: val)
@@ -78,28 +78,28 @@ struct AliasAnalysis {
  case (true, true): return MayReadWriteBehavior
  }
  }
- if val.at(path).isAddressEscaping(using: EscapesToInstructionVisitor(target: inst), context) {
+ if val.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: true), context) {
  return MayReadWriteBehavior
  }
  return NoneBehavior
  },
 
  // isObjReleasedFn
  { (bridgedCtxt: BridgedPassContext, bridgedObj: BridgedValue, bridgedInst: BridgedInstruction) -> Bool in
- let context = PassContext(_bridged: bridgedCtxt)
+ let context = FunctionPassContext(_bridged: bridgedCtxt)
  let inst = bridgedInst.instruction
  let obj = bridgedObj.value
  let path = SmallProjectionPath(.anyValueFields)
  if let apply = inst as? ApplySite {
  let effect = getOwnershipEffect(of: apply, for: obj, path: path, context)
  return effect.destroy
  }
- return obj.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst), context)
+ return obj.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst, isAddress: false), context)
  },
 
  // isAddrVisibleFromObj
  { (bridgedCtxt: BridgedPassContext, bridgedAddr: BridgedValue, bridgedObj: BridgedValue) -> Bool in
- let context = PassContext(_bridged: bridgedCtxt)
+ let context = FunctionPassContext(_bridged: bridgedCtxt)
  let addr = bridgedAddr.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedAddr.value))
 
  // This is similar to `canReferenceSameFieldFn`, except that all addresses of all objects are
@@ -110,7 +110,7 @@ struct AliasAnalysis {
 
  // canReferenceSameFieldFn
  { (bridgedCtxt: BridgedPassContext, bridgedLhs: BridgedValue, bridgedRhs: BridgedValue) -> Bool in
- let context = PassContext(_bridged: bridgedCtxt)
+ let context = FunctionPassContext(_bridged: bridgedCtxt)
 
  // If `lhs` or `rhs` is not an address, but an object, it means: check for alias of any class
  // field address of the object.
@@ -122,13 +122,13 @@ struct AliasAnalysis {
  }
 }
 
-private func getMemoryEffect(of apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: PassContext) -> SideEffects.Memory {
+private func getMemoryEffect(of apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Memory {
  let calleeAnalysis = context.calleeAnalysis
- let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: calleeAnalysis)
+ let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: calleeAnalysis, isAddress: true)
  let memoryEffects: SideEffects.Memory
 
  // First try to figure out to which argument(s) the address "escapes" to.
- if let result = address.at(path).visitAddress(using: visitor, context) {
+ if let result = address.at(path).visit(using: visitor, context) {
  // The resulting effects are the argument effects to which `address` escapes to.
  memoryEffects = result.memory
  } else {
@@ -145,8 +145,8 @@ private func getMemoryEffect(of apply: ApplySite, for address: Value, path: Smal
  return memoryEffects
 }
 
-private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: SmallProjectionPath, _ context: PassContext) -> SideEffects.Ownership {
- let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: context.calleeAnalysis)
+private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: SmallProjectionPath, _ context: FunctionPassContext) -> SideEffects.Ownership {
+ let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: context.calleeAnalysis, isAddress: false)
  if let result = value.at(path).visit(using: visitor, context) {
  // The resulting effects are the argument effects to which `value` escapes to.
  return result.ownership
@@ -159,6 +159,7 @@ private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: Sma
 private struct SideEffectsVisitor : EscapeVisitorWithResult {
  let apply: ApplySite
  let calleeAnalysis: CalleeAnalysis
+ let isAddress: Bool
  var result = SideEffects.GlobalEffects()
 
  mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
@@ -175,6 +176,30 @@ private struct SideEffectsVisitor : EscapeVisitorWithResult {
  }
  return .continueWalk
  }
+
+ var followTrivialTypes: Bool { isAddress }
+ var followLoads: Bool { !isAddress }
+}
+
+/// Lets `ProjectedValue.isEscaping` return true if the value is "escaping" to the `target` instruction.
+private struct EscapesToInstructionVisitor : EscapeVisitor {
+ let target: Instruction
+ let isAddress: Bool
+
+ mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
+ let user = operand.instruction
+ if user == target {
+ return .abort
+ }
+ if user is ReturnInst {
+ // Anything which is returned cannot escape to an instruction inside the function.
+ return .ignore
+ }
+ return .continueWalk
+ }
+
+ var followTrivialTypes: Bool { isAddress }
+ var followLoads: Bool { !isAddress }
 }
 
 private extension Value {

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -24,7 +24,7 @@ public struct CalleeAnalysis {
  },
  // getMemBehaviorFn
  { (bridgedCtxt: BridgedPassContext, bridgedApply: BridgedInstruction, observeRetains: Bool) -> BridgedMemoryBehavior in
- let context = PassContext(_bridged: bridgedCtxt)
+ let context = FunctionPassContext(_bridged: bridgedCtxt)
  let apply = bridgedApply.instruction as! ApplySite
  let e = context.calleeAnalysis.getSideEffects(of: apply)
  return e.getMemBehavior(observeRetains: observeRetains)

SwiftCompilerSources/Sources/Optimizer/CMakeLists.txt

@@ -13,7 +13,7 @@ add_swift_compiler_module(Optimizer DEPENDS ${dependencies})
 
 add_subdirectory(Analysis)
 add_subdirectory(DataStructures)
-add_subdirectory(InstructionPasses)
+add_subdirectory(InstructionSimplification)
 add_subdirectory(PassManager)
 add_subdirectory(ModulePasses)
 add_subdirectory(FunctionPasses)

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift

@@ -66,7 +66,7 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
  private var inExclusiveRange: BasicBlockSet
  private var worklist: BasicBlockWorklist
 
- init(begin: BasicBlock, _ context: PassContext) {
+ init(begin: BasicBlock, _ context: some Context) {
  self.begin = begin
  self.inclusiveRange = Stack(context)
  self.inserted = Stack(context)
@@ -110,7 +110,7 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
 
  /// Returns true if the range is valid and that's iff the begin block dominates all blocks of the range.
  var isValid: Bool {
- let entry = begin.function.entryBlock
+ 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)

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockWorklist.swift

@@ -8,9 +8,10 @@
 
 swift_compiler_sources(Optimizer
  BasicBlockRange.swift
- BasicBlockWorklist.swift
  DeadEndBlocks.swift
  FunctionUses.swift
  InstructionRange.swift
+ ReachableBlocks.swift
  Set.swift
- Stack.swift)
+ Stack.swift
+ Worklist.swift)

SwiftCompilerSources/Sources/Optimizer/DataStructures/CMakeLists.txt

@@ -19,8 +19,10 @@ import SIL
 /// instruction and blocks from which all paths end in "unreachable" blocks.
 struct DeadEndBlocks : CustomStringConvertible, NoReflectionChildren {
  private var worklist: BasicBlockWorklist
+ private var function: Function
 
- init(function: Function, _ context: PassContext) {
+ init(function: Function, _ context: FunctionPassContext) {
+ self.function = function
  self.worklist = BasicBlockWorklist(context)
 
  // Initialize the worklist with all function-exiting blocks.
@@ -40,7 +42,7 @@ struct DeadEndBlocks : CustomStringConvertible, NoReflectionChildren {
  }
 
  var description: String {
- let blockNames = worklist.function.blocks.filter(isDeadEnd).map(\.name)
+ let blockNames = function.blocks.filter(isDeadEnd).map(\.name)
  return "[" + blockNames.joined(separator: ",") + "]"
  }
 

SwiftCompilerSources/Sources/Optimizer/DataStructures/DeadEndBlocks.swift

@@ -93,7 +93,7 @@ struct FunctionUses {
  result += "<unknown uses>\n"
  }
  for inst in self {
- result += "@\(inst.function.name): \(inst)\n"
+ result += "@\(inst.parentFunction.name): \(inst)\n"
 
  }
  result += "]"

SwiftCompilerSources/Sources/Optimizer/DataStructures/FunctionUses.swift

@@ -48,16 +48,16 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
  private var insertedInsts: InstructionSet
 
- init(begin beginInst: Instruction, _ context: PassContext) {
+ init(begin beginInst: Instruction, _ context: some Context) {
  self.begin = beginInst
- self.blockRange = BasicBlockRange(begin: beginInst.block, context)
+ self.blockRange = BasicBlockRange(begin: beginInst.parentBlock, context)
  self.insertedInsts = InstructionSet(context)
  }
 
  /// Insert a potential end instruction.
  mutating func insert(_ inst: Instruction) {
  insertedInsts.insert(inst)
- blockRange.insert(inst.block)
+ blockRange.insert(inst.parentBlock)
  }
 
  /// Insert a sequence of potential end instructions.
@@ -69,7 +69,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
  /// Returns true if the exclusive range contains `inst`.
  func contains(_ inst: Instruction) -> Bool {
- let block = inst.block
+ let block = inst.parentBlock
  if !blockRange.inclusiveRangeContains(block) { return false }
  var inRange = false
  if blockRange.contains(block) {