[Gardening] SIL: "Liferange" -> "Liverange"

Author: nate-chandler

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift

@@ -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 {
@@ -336,7 +336,7 @@ 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 liverange(InstructionRange)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -161,7 +161,7 @@ private extension LoadInst {
     _ context: FunctionPassContext
   ) -> DataflowResult {
 
-    var liverange = Liferange(endBlock: self.parentBlock, context)
+    var liverange = Liverange(endBlock: self.parentBlock, context)
     defer { liverange.deinitialize() }
     liverange.pushPredecessors(of: self.parentBlock)
 
@@ -184,7 +184,7 @@ private extension LoadInst {
     return .redundant(scanner.availableValues)
   }
 
-  func canReplaceWithoutInsertingCopies(liverange: Liferange,_ context: FunctionPassContext) -> Bool {
+  func canReplaceWithoutInsertingCopies(liverange: Liverange,_ context: FunctionPassContext) -> Bool {
     switch self.loadOwnership {
     case .trivial, .unqualified:
       return true
@@ -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

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StackPromotion.swift

@@ -146,7 +146,7 @@ private func tryPromoteAlloc(_ allocRef: AllocRefInstBase,
 
   // The "inner" liverange contains all use points which are dominated by the allocation block.
   // Note that this `visit` cannot fail because otherwise our initial `isEscaping` check would have failed already.
-  var innerRange = allocRef.visit(using: ComputeInnerLiferange(of: allocRef, domTree, context), context)!
+  var innerRange = allocRef.visit(using: ComputeInnerLiverange(of: allocRef, domTree, context), context)!
   defer { innerRange.deinitialize() }
 
   // The "outer" liverange contains all use points.
@@ -236,7 +236,7 @@ private func getDominatingBlockOfAllUsePoints(context: FunctionPassContext,
   return value.visit(using: FindDominatingBlock(result: value.parentBlock, domTree: domTree), context)!
 }
 
-private struct ComputeInnerLiferange : EscapeVisitorWithResult {
+private struct ComputeInnerLiverange : EscapeVisitorWithResult {
   var result: InstructionRange
   let domTree: DominatorTree
 

lib/SILOptimizer/Transforms/TempLValueOpt.cpp

@@ -128,7 +128,7 @@ void TempLValueOptPass::tempLValueOpt(CopyAddrInst *copyInst) {
   //
   //   alloc_stack %temp
   //   ...
-  //   first_use_of %temp // beginOfLiferange
+  //   first_use_of %temp // beginOfLiverange
   //   ... // no reads or writes from/to %destination
   //   copy_addr [take] %temp to %destination // copyInst
   //   ... // no further uses of %temp (copyInst is the end of %temp liverange)
@@ -186,8 +186,8 @@ void TempLValueOptPass::tempLValueOpt(CopyAddrInst *copyInst) {
 
   // Iterate over the liverange of the temporary and make some validity checks.
   AliasAnalysis *AA = nullptr;
-  SILInstruction *beginOfLiferange = nullptr;
-  bool endOfLiferangeReached = false;
+  SILInstruction *beginOfLiverange = nullptr;
+  bool endOfLiverangeReached = false;
   for (auto iter = temporary->getIterator(); iter != block->end(); ++iter) {
     SILInstruction *inst = &*iter;
     // The dealloc_stack is the last user of the temporary.
@@ -197,19 +197,19 @@ void TempLValueOptPass::tempLValueOpt(CopyAddrInst *copyInst) {
     if (users.contains(inst) != 0) {
       // Check if the copyInst is the last user of the temporary (beside the
       // dealloc_stack).
-      if (endOfLiferangeReached)
+      if (endOfLiverangeReached)
         return;
 
       // Find the first user of the temporary to get a more precise liverange.
       // It would be too conservative to treat the alloc_stack itself as the
       // begin of the liverange.
-      if (!beginOfLiferange)
-        beginOfLiferange = inst;
+      if (!beginOfLiverange)
+        beginOfLiverange = inst;
 
       if (inst == copyInst)
-        endOfLiferangeReached = true;
+        endOfLiverangeReached = true;
     }
-    if (beginOfLiferange && !endOfLiferangeReached) {
+    if (beginOfLiverange && !endOfLiverangeReached) {
       // If the root address of the destination is within the liverange of the
       // temporary, we cannot replace all uses of the temporary with the
       // destination (it would break the def-use dominance rule).
@@ -233,21 +233,21 @@ void TempLValueOptPass::tempLValueOpt(CopyAddrInst *copyInst) {
         return;
     }
   }
-  assert(endOfLiferangeReached);
+  assert(endOfLiverangeReached);
 
   // Move all projections of the destination address before the liverange of
   // the temporary.
-  for (auto iter = beginOfLiferange->getIterator();
+  for (auto iter = beginOfLiverange->getIterator();
        iter != copyInst->getIterator();) {
     SILInstruction *inst = &*iter++;
     if (projections.contains(inst))
-      inst->moveBefore(beginOfLiferange);
+      inst->moveBefore(beginOfLiverange);
   }
 
   if (!copyInst->isInitializationOfDest()) {
     // Make sure the destination is uninitialized before the liverange of
     // the temporary.
-    SILBuilderWithScope builder(beginOfLiferange);
+    SILBuilderWithScope builder(beginOfLiverange);
     builder.createDestroyAddr(copyInst->getLoc(), destination);
   }