Merge pull request #73576 from nate-chandler/gardening/20240510/1

[Gardening] SIL: Spelling of live range.

Author: nate-chandler

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -20,7 +20,7 @@ import SIL
 /// One or more "potential" end instructions can be inserted.
 /// Though, not all inserted instructions end up as "end" instructions.
 ///
-/// `InstructionRange` is useful for calculating the liferange of values.
+/// `InstructionRange` is useful for calculating the liverange of values.
 ///
 /// The `InstructionRange` is similar to a `BasicBlockRange`, but defines the range
 /// in a "finer" granularity, i.e. on instructions instead of blocks.

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift

@@ -19,7 +19,7 @@ import SIL
 /// are initialized, a statically initialized global is created where the initializer is a
 /// `vector` instruction.
 ///
-/// TODO: liferange computation is done very ad-hoc and should be eventually done by inspecting
+/// TODO: liverange computation is done very ad-hoc and should be eventually done by inspecting
 ///       forwarding instructions.
 let allocVectorLowering = FunctionPass(name: "alloc-vector-lowering") {
   (function: Function, context: FunctionPassContext) in
@@ -190,7 +190,7 @@ private extension StructInst {
 /// Lowers the allocateVector builtin either to an stack-allocated vector (`alloc_vector`)
 /// or to a statically initialized global.
 private func lower(allocVectorBuiltin: BuiltinInst, _ context: FunctionPassContext) {
-  let visitor = ComputeNonEscapingLiferange(of: allocVectorBuiltin, context)
+  let visitor = ComputeNonEscapingLiverange(of: allocVectorBuiltin, context)
 
   guard let result = allocVectorBuiltin.visit(using: visitor, context) else {
     if allocVectorBuiltin.parentFunction.isTransparent {
@@ -203,9 +203,9 @@ private func lower(allocVectorBuiltin: BuiltinInst, _ context: FunctionPassConte
   case .storeToGlobal(let storeInst):
     createOutlinedGlobal(for: allocVectorBuiltin, storeToGlobal: storeInst, context)
 
-  case .liferange(var liferange):
-    defer { liferange.deinitialize() }
-    createStackAllocatedVector(for: allocVectorBuiltin, liferange: liferange, context)
+  case .liverange(var liverange):
+    defer { liverange.deinitialize() }
+    createStackAllocatedVector(for: allocVectorBuiltin, liverange: liverange, context)
 
   case .invalid:
     context.diagnosticEngine.diagnose(allocVectorBuiltin.location.sourceLoc, .lifetime_value_outside_scope)
@@ -255,7 +255,7 @@ private func createOutlinedGlobal(
 
 private func createStackAllocatedVector(
   for allocVectorBuiltin: BuiltinInst,
-  liferange: InstructionRange,
+  liverange: InstructionRange,
   _ context: FunctionPassContext
 ) {
   let builder = Builder(before: allocVectorBuiltin, context)
@@ -267,7 +267,7 @@ private func createStackAllocatedVector(
   allocVectorBuiltin.uses.replaceAll(with: rawVectorPointer, context)
   context.erase(instruction: allocVectorBuiltin)
 
-  for endInst in liferange.ends {
+  for endInst in liverange.ends {
     let builder = Builder(after: endInst, context)
     builder.createDeallocStack(allocVec)
   }
@@ -336,47 +336,47 @@ private func findInitStores(of address: Value, atIndex: Int, _ initStores: inout
 
 // This is very experimental and not ideal at all.
 // TODO: replace this with DiagnoseLifetimeDependence from https://github.com/apple/swift/pull/68682
-private struct ComputeNonEscapingLiferange : EscapeVisitorWithResult {
+private struct ComputeNonEscapingLiverange : EscapeVisitorWithResult {
 
   enum Result {
-    case liferange(InstructionRange)
+    case liverange(InstructionRange)
     case storeToGlobal(StoreInst)
     case invalid
   }
 
-  var liferange: InstructionRange
+  var liverange: InstructionRange
   var storeToGlobal: StoreInst? = nil
   let domTree: DominatorTree
 
   init(of instruction: Instruction, _ context: FunctionPassContext) {
-    self.liferange = InstructionRange(begin: instruction, context)
+    self.liverange = InstructionRange(begin: instruction, context)
     self.domTree = context.dominatorTree
   }
 
   var result: Result {
     if let storeToGlobal = storeToGlobal {
       defer {
-        var lr = liferange
+        var lr = liverange
         lr.deinitialize()
       }
-      precondition(liferange.inclusiveRangeContains(storeToGlobal))
-      if liferange.inclusiveRangeContains(storeToGlobal.next!) ||
-         liferange.ends.contains(where: { $0 != storeToGlobal }) ||
+      precondition(liverange.inclusiveRangeContains(storeToGlobal))
+      if liverange.inclusiveRangeContains(storeToGlobal.next!) ||
+         liverange.ends.contains(where: { $0 != storeToGlobal }) ||
          !storeToGlobal.isInitializingGlobal
       {
         return .invalid
       }
       return .storeToGlobal(storeToGlobal)
     }
-    return .liferange(liferange)
+    return .liverange(liverange)
   }
 
   mutating func cleanupOnAbort() {
-    liferange.deinitialize()
+    liverange.deinitialize()
   }
 
   mutating func visitDef(def: Value, path: EscapePath) -> DefResult {
-    if def.definingInstruction == liferange.begin {
+    if def.definingInstruction == liverange.begin {
       return .walkDown
     }
     switch def {
@@ -392,12 +392,12 @@ private struct ComputeNonEscapingLiferange : EscapeVisitorWithResult {
 
   mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
     let user = operand.instruction
-    let beginBlockOfRange = liferange.blockRange.begin
+    let beginBlockOfRange = liverange.blockRange.begin
     let dominates = beginBlockOfRange.dominates(user.parentBlock, domTree)
     switch user {
     case let store as StoreInst:
       if dominates {
-        liferange.insert(store)
+        liverange.insert(store)
       }
       let accessPath = store.destination.accessPath
       if case .global = accessPath.base {
@@ -412,7 +412,7 @@ private struct ComputeNonEscapingLiferange : EscapeVisitorWithResult {
       return .continueWalk
     case let apply as ApplyInst:
       if dominates {
-        liferange.insert(user)
+        liverange.insert(user)
       }
       if !apply.isEscapable {
         return .abort
@@ -422,7 +422,7 @@ private struct ComputeNonEscapingLiferange : EscapeVisitorWithResult {
       return .continueWalk
     default:
       if dominates {
-        liferange.insert(user)
+        liverange.insert(user)
       }
       return .continueWalk
     }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ClosureSpecialization.swift

@@ -192,9 +192,9 @@ private func gatherCallSites(in caller: Function, _ context: FunctionPassContext
 
 private func updateCallSites(for rootClosure: SingleValueInstruction, in callSiteMap: inout CallSiteMap, 
                              convertedAndReabstractedClosures: inout InstructionSet, _ context: FunctionPassContext) {
-  var rootClosurePossibleLifeRange = InstructionRange(begin: rootClosure, context)
+  var rootClosurePossibleLiveRange = InstructionRange(begin: rootClosure, context)
   defer {
-    rootClosurePossibleLifeRange.deinitialize()
+    rootClosurePossibleLiveRange.deinitialize()
   }
 
   var rootClosureApplies = OperandWorklist(context)                            
@@ -218,7 +218,7 @@ private func updateCallSites(for rootClosure: SingleValueInstruction, in callSit
 
   let (foundUnexpectedUse, haveUsedReabstraction) = 
     handleNonApplies(for: rootClosure, rootClosureApplies: &rootClosureApplies,
-                     rootClosurePossibleLifeRange: &rootClosurePossibleLifeRange, context);
+                     rootClosurePossibleLiveRange: &rootClosurePossibleLiveRange, context);
 
 
   if foundUnexpectedUse {
@@ -227,12 +227,12 @@ private func updateCallSites(for rootClosure: SingleValueInstruction, in callSit
 
   let intermediateClosureArgDescriptorData = 
     handleApplies(for: rootClosure, callSiteMap: &callSiteMap, rootClosureApplies: &rootClosureApplies, 
-                  rootClosurePossibleLifeRange: &rootClosurePossibleLifeRange, 
+                  rootClosurePossibleLiveRange: &rootClosurePossibleLiveRange, 
                   convertedAndReabstractedClosures: &convertedAndReabstractedClosures,
                   haveUsedReabstraction: haveUsedReabstraction, context)
 
   finalizeCallSites(for: rootClosure, in: &callSiteMap, 
-                    rootClosurePossibleLifeRange: rootClosurePossibleLifeRange,
+                    rootClosurePossibleLiveRange: rootClosurePossibleLiveRange,
                     intermediateClosureArgDescriptorData: intermediateClosureArgDescriptorData, context)
 }
 
@@ -244,7 +244,7 @@ private func updateCallSites(for rootClosure: SingleValueInstruction, in callSit
 ///                      how to handle. If true, then `rootClosure` should not be specialized against.
 private func handleNonApplies(for rootClosure: SingleValueInstruction, 
                               rootClosureApplies: inout OperandWorklist,
-                              rootClosurePossibleLifeRange: inout InstructionRange, 
+                              rootClosurePossibleLiveRange: inout InstructionRange, 
                               _ context: FunctionPassContext) 
   -> (foundUnexpectedUse: Bool, haveUsedReabstraction: Bool)
 {
@@ -295,12 +295,12 @@ private func handleNonApplies(for rootClosure: SingleValueInstruction,
     case let cfi as ConvertFunctionInst:
       rootClosureConversionsAndReabstractions.pushIfNotVisited(contentsOf: cfi.uses)
       possibleMarkDependenceBases.insert(cfi)
-      rootClosurePossibleLifeRange.insert(use.instruction)
+      rootClosurePossibleLiveRange.insert(use.instruction)
 
     case let cvt as ConvertEscapeToNoEscapeInst:
       rootClosureConversionsAndReabstractions.pushIfNotVisited(contentsOf: cvt.uses)
       possibleMarkDependenceBases.insert(cvt)
-      rootClosurePossibleLifeRange.insert(use.instruction)
+      rootClosurePossibleLiveRange.insert(use.instruction)
 
     case let pai as PartialApplyInst:
       if !pai.isPullbackInResultOfAutodiffVJP,
@@ -311,7 +311,7 @@ private func handleNonApplies(for rootClosure: SingleValueInstruction,
       {
         rootClosureConversionsAndReabstractions.pushIfNotVisited(contentsOf: pai.uses)
         possibleMarkDependenceBases.insert(pai)
-        rootClosurePossibleLifeRange.insert(use.instruction)
+        rootClosurePossibleLiveRange.insert(use.instruction)
         haveUsedReabstraction = true
       } else {
         rootClosureApplies.pushIfNotVisited(use)
@@ -320,15 +320,15 @@ private func handleNonApplies(for rootClosure: SingleValueInstruction,
     case let mv as MoveValueInst:
       rootClosureConversionsAndReabstractions.pushIfNotVisited(contentsOf: mv.uses)
       possibleMarkDependenceBases.insert(mv)
-      rootClosurePossibleLifeRange.insert(use.instruction)
+      rootClosurePossibleLiveRange.insert(use.instruction)
 
     // Uses of a copy of root-closure do not count as
     // uses of the root-closure
     case is CopyValueInst:
-      rootClosurePossibleLifeRange.insert(use.instruction)
+      rootClosurePossibleLiveRange.insert(use.instruction)
 
     case is DestroyValueInst:
-      rootClosurePossibleLifeRange.insert(use.instruction)
+      rootClosurePossibleLiveRange.insert(use.instruction)
 
     case let mdi as MarkDependenceInst:
       if possibleMarkDependenceBases.contains(mdi.base),  
@@ -337,7 +337,7 @@ private func handleNonApplies(for rootClosure: SingleValueInstruction,
           mdi.value.type.isThickFunction
       {
         rootClosureConversionsAndReabstractions.pushIfNotVisited(contentsOf: mdi.uses)
-        rootClosurePossibleLifeRange.insert(use.instruction)
+        rootClosurePossibleLiveRange.insert(use.instruction)
       }
 
     default:
@@ -354,14 +354,14 @@ private typealias IntermediateClosureArgDescriptorDatum = (applySite: SingleValu
 
 private func handleApplies(for rootClosure: SingleValueInstruction, callSiteMap: inout CallSiteMap, 
                            rootClosureApplies: inout OperandWorklist, 
-                           rootClosurePossibleLifeRange: inout InstructionRange, 
+                           rootClosurePossibleLiveRange: inout InstructionRange, 
                            convertedAndReabstractedClosures: inout InstructionSet, haveUsedReabstraction: Bool, 
                            _ context: FunctionPassContext) -> [IntermediateClosureArgDescriptorDatum] 
 {
   var intermediateClosureArgDescriptorData: [IntermediateClosureArgDescriptorDatum] = []
 
   while let use = rootClosureApplies.pop() {
-    rootClosurePossibleLifeRange.insert(use.instruction)
+    rootClosurePossibleLiveRange.insert(use.instruction)
 
     // TODO [extend to general swift]: Handle full apply sites
     guard let pai = use.instruction as? PartialApplyInst else {
@@ -479,11 +479,11 @@ private func handleApplies(for rootClosure: SingleValueInstruction, callSiteMap:
 /// Finalizes the call sites for a given root closure by adding a corresponding `ClosureArgDescriptor`
 /// to all call sites where the closure is ultimately passed as an argument.
 private func finalizeCallSites(for rootClosure: SingleValueInstruction, in callSiteMap: inout CallSiteMap, 
-                               rootClosurePossibleLifeRange: InstructionRange, 
+                               rootClosurePossibleLiveRange: InstructionRange, 
                                intermediateClosureArgDescriptorData: [IntermediateClosureArgDescriptorDatum], 
                                _ context: FunctionPassContext) 
 {
-  let closureInfo = ClosureInfo(closure: rootClosure, lifetimeFrontier: Array(rootClosurePossibleLifeRange.ends))
+  let closureInfo = ClosureInfo(closure: rootClosure, lifetimeFrontier: Array(rootClosurePossibleLiveRange.ends))
 
   for (applySite, closureArgumentIndex, parameterInfo) in intermediateClosureArgDescriptorData {
     guard var callSite = callSiteMap[applySite] else {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -161,38 +161,38 @@ private extension LoadInst {
     _ context: FunctionPassContext
   ) -> DataflowResult {
 
-    var liferange = Liferange(endBlock: self.parentBlock, context)
-    defer { liferange.deinitialize() }
-    liferange.pushPredecessors(of: self.parentBlock)
+    var liverange = Liverange(endBlock: self.parentBlock, context)
+    defer { liverange.deinitialize() }
+    liverange.pushPredecessors(of: self.parentBlock)
 
-    while let block = liferange.pop() {
+    while let block = liverange.pop() {
       switch scanner.scan(instructions: block.instructions.reversed(),
                           in: block,
                           complexityBudget: &complexityBudget)
       {
       case .overwritten:
         return DataflowResult(notRedundantWith: scanner.potentiallyRedundantSubpath)
       case .available:
-        liferange.add(beginBlock: block)
+        liverange.add(beginBlock: block)
       case .transparent:
-        liferange.pushPredecessors(of: block)
+        liverange.pushPredecessors(of: block)
       }
     }
-    if !self.canReplaceWithoutInsertingCopies(liferange: liferange, context) {
+    if !self.canReplaceWithoutInsertingCopies(liverange: liverange, context) {
       return DataflowResult(notRedundantWith: scanner.potentiallyRedundantSubpath)
     }
     return .redundant(scanner.availableValues)
   }
 
-  func canReplaceWithoutInsertingCopies(liferange: Liferange,_ context: FunctionPassContext) -> Bool {
+  func canReplaceWithoutInsertingCopies(liverange: Liverange,_ context: FunctionPassContext) -> Bool {
     switch self.loadOwnership {
     case .trivial, .unqualified:
       return true
 
     case .copy, .take:
       let deadEndBlocks = context.deadEndBlocks
 
-      // The liferange of the value has an "exit", i.e. a path which doesn't lead to the load,
+      // The liverange of the value has an "exit", i.e. a path which doesn't lead to the load,
       // it means that we would have to insert a destroy on that exit to satisfy ownership rules.
       // But an inserted destroy also means that we would need to insert copies of the value which
       // were not there originally. For example:
@@ -201,9 +201,9 @@ private extension LoadInst {
       //     cond_br bb1, bb2
       //   bb1:
       //     %2 = load [take] %addr
-      //   bb2:                      // liferange exit
+      //   bb2:                      // liverange exit
       //
-      // TODO: we could extend OSSA to transfer ownership to support liferange exits without copying. E.g.:
+      // TODO: we could extend OSSA to transfer ownership to support liverange exits without copying. E.g.:
       //
       //     %b = store_and_borrow %1 to [init] %addr   // %b is borrowed from %addr
       //     cond_br bb1, bb2
@@ -213,18 +213,18 @@ private extension LoadInst {
       //   bb2:
       //     end_borrow %b
       //
-      if liferange.hasExits(deadEndBlocks) {
+      if liverange.hasExits(deadEndBlocks) {
         return false
       }
 
-      // Handle a corner case: if the load is in an infinite loop, the liferange doesn't have an exit,
+      // Handle a corner case: if the load is in an infinite loop, the liverange doesn't have an exit,
       // but we still would need to insert a copy. For example:
       //
       //     store %1 to [init] %addr
       //     br bb1
       //   bb1:
       //     %2 = load [copy] %addr   // would need to insert a copy here
-      //    br bb1                    // no exit from the liferange
+      //    br bb1                    // no exit from the liverange
       //
       // For simplicity, we don't handle this in OSSA.
       if deadEndBlocks.isDeadEnd(parentBlock) {
@@ -508,8 +508,8 @@ private struct InstructionScanner {
       break
     }
     if load.loadOwnership == .take {
-      // In case of `take`, don't allow reading instructions in the liferange.
-      // Otherwise we cannot shrink the memory liferange afterwards.
+      // In case of `take`, don't allow reading instructions in the liverange.
+      // Otherwise we cannot shrink the memory liverange afterwards.
       if instruction.mayReadOrWrite(address: load.address, aliasAnalysis) {
         return .overwritten
       }
@@ -522,9 +522,9 @@ private struct InstructionScanner {
   }
 }
 
-/// Represents the liferange (in terms of basic blocks) of the loaded value.
+/// Represents the liverange (in terms of basic blocks) of the loaded value.
 ///
-/// In contrast to a BlockRange, this liferange has multiple begin blocks (containing the
+/// In contrast to a BlockRange, this liverange has multiple begin blocks (containing the
 /// available values) and a single end block (containing the original load). For example:
 ///
 ///   bb1:
@@ -536,7 +536,7 @@ private struct InstructionScanner {
 ///   bb3:
 ///     %3 = load %addr     // end block
 ///
-private struct Liferange {
+private struct Liverange {
   private var worklist: BasicBlockWorklist
   private var containingBlocks: Stack<BasicBlock> // doesn't include the end-block
   private var beginBlocks: BasicBlockSet