Optimizer: add SingleValueInstruction.replace(with:) and use it throughout the optimizer

It replaces all uses and then erases the instruction.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift

@@ -250,8 +250,7 @@ private func createOutlinedGlobal(
   let globalAddr = builder.createGlobalAddr(global: outlinedGlobal, dependencyToken: nil)
   let rawVectorPointer = builder.createAddressToPointer(address: globalAddr, pointerType: allocVectorBuiltin.type,
                                                         needStackProtection: false)
-  allocVectorBuiltin.uses.replaceAll(with: rawVectorPointer, context)
-  context.erase(instruction: allocVectorBuiltin)
+  allocVectorBuiltin.replace(with: rawVectorPointer, context)
 }
 
 private func createStackAllocatedVector(
@@ -266,8 +265,7 @@ private func createStackAllocatedVector(
   let rawVectorPointer = builder.createAddressToPointer(address: allocVec, pointerType: allocVectorBuiltin.type,
                                                         needStackProtection: true)
 
-  allocVectorBuiltin.uses.replaceAll(with: rawVectorPointer, context)
-  context.erase(instruction: allocVectorBuiltin)
+  allocVectorBuiltin.replace(with: rawVectorPointer, context)
 
   for endInst in liverange.ends {
     let builder = Builder(after: endInst, context)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ClosureSpecialization.swift

@@ -301,8 +301,7 @@ private func rewriteApplyInstruction(using specializedCallee: Function, callSite
     }
   }
 
-  oldApply.uses.replaceAll(with: newApply, context)
-  context.erase(instruction: oldApply)
+  oldApply.replace(with: newApply, context)
 }
 
 // ===================== Utility functions and extensions ===================== //
@@ -1381,4 +1380,4 @@ let rewrittenCallerBodyTest = FunctionTest("closure_specialize_rewritten_caller_
     print("Rewritten caller body for: \(function.name):")
     print("\(function)\n")
   }
-}
+}

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CopyToBorrowOptimization.swift

@@ -260,8 +260,7 @@ private extension LoadInst {
 private func remove(copy: CopyValueInst, collectedUses: Uses, liverange: InstructionRange) {
   let context = collectedUses.context
   replaceMoveWithBorrow(of: copy, replacedBy: copy.fromValue, liverange: liverange, collectedUses: collectedUses)
-  copy.uses.replaceAll(with: copy.fromValue, context)
-  context.erase(instruction: copy)
+  copy.replace(with: copy.fromValue, context)
 
   for forwardingUse in collectedUses.forwardingUses {
     forwardingUse.changeOwnership(from: .owned, to: .guaranteed, context)
@@ -301,8 +300,7 @@ private func replaceMoveWithBorrow(
                                       isLexical: moveInst.isLexical,
                                       hasPointerEscape: moveInst.hasPointerEscape,
                                       isFromVarDecl: moveInst.isFromVarDecl)
-  moveInst.uses.replaceAll(with: bbi, context)
-  context.erase(instruction: moveInst)
+  moveInst.replace(with: bbi, context)
   createEndBorrows(for: bbi, atEndOf: liverange, collectedUses: collectedUses)
 }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -152,8 +152,7 @@ private func optimizeNonOptionalBridging(_ apply: ApplyInst,
     let replacement = builder.createUncheckedEnumData(enum: optionalReplacement,
                                                       caseIndex: someCase,
                                                       resultType: bridgeToObjcCall.type)
-    bridgeToObjcCall.uses.replaceAll(with: replacement, context)
-    context.erase(instruction: bridgeToObjcCall)
+    bridgeToObjcCall.replace(with: replacement, context)
     return true
   }
 
@@ -219,8 +218,7 @@ private func optimizeNonOptionalBridging(_ apply: ApplyInst,
 
   // Now replace the bridged value with the original value in the destination block.
   let replacement = s.makeAvailable(in: bridgeToObjcCall.parentBlock, context)
-  bridgeToObjcCall.uses.replaceAll(with: replacement, context)
-  context.erase(instruction: bridgeToObjcCall)
+  bridgeToObjcCall.replace(with: replacement, context)
   return true
 }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -413,8 +413,7 @@ private func replace(object allocRef: AllocRefInstBase,
   }
 
   rewriteUses(of: allocRef, context)
-  allocRef.uses.replaceAll(with: globalValue, context)
-  context.erase(instruction: allocRef)
+  allocRef.replace(with: globalValue, context)
   return globalValue
 }
 
@@ -431,13 +430,11 @@ private func rewriteUses(of startValue: Value, _ context: FunctionPassContext) {
       if !beginDealloc.parentFunction.hasOwnership {
         builder.createStrongRelease(operand: beginDealloc.reference)
       }
-      beginDealloc.uses.replaceAll(with: beginDealloc.reference, context)
-      context.erase(instruction: beginDealloc)
+      beginDealloc.replace(with: beginDealloc.reference, context)
     case is EndCOWMutationInst, is EndInitLetRefInst, is MoveValueInst:
       let svi = inst as! SingleValueInstruction
       worklist.pushIfNotVisited(usersOf: svi)
-      svi.uses.replaceAll(with: svi.operands[0].value, context)
-      context.erase(instruction: svi)
+      svi.replace(with: svi.operands[0].value, context)
     case let upCast as UpcastInst:
       worklist.pushIfNotVisited(usersOf: upCast)
     case let refCast as UncheckedRefCastInst:
@@ -571,8 +568,7 @@ private func replace(findStringCall: ApplyInst,
                                                 findStringCall.arguments[1],
                                                 cacheAddr])
 
-  findStringCall.uses.replaceAll(with: newCall, context)
-  context.erase(instruction: findStringCall)
+  findStringCall.replace(with: newCall, context)
 }
 
 private extension GlobalValueInst {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -279,8 +279,7 @@ private func replace(load: LoadInst, with availableValues: [AvailableValue], _ c
     //
     newValue = ssaUpdater.getValue(inMiddleOf: load.parentBlock)
   }
-  load.uses.replaceAll(with: newValue, context)
-  context.erase(instruction: load)
+  load.replace(with: newValue, context)
 }
 
 private func provideValue(

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyApply.swift

@@ -56,8 +56,7 @@ private func tryTransformThickToThinCallee(of apply: ApplyInst, _ context: Simpl
                                        isNonThrowing: apply.isNonThrowing,
                                        isNonAsync: apply.isNonAsync,
                                        specializationInfo: apply.specializationInfo)
-    apply.uses.replaceAll(with: newApply, context)
-    context.erase(instruction: apply)
+    apply.replace(with: newApply, context)
     return true
   }
   return false

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginAndLoadBorrow.swift

@@ -59,9 +59,8 @@ extension LoadBorrowInst : Simplifyable, SILCombineSimplifyable {
     }
     let builder = Builder(before: self, context)
     let loadCopy = builder.createLoad(fromAddress: address, ownership: .copy)
-    let forwardedOwnedValue = replace(guaranteedValue: self, withOwnedValue: loadCopy, context)
-    copy.uses.replaceAll(with: forwardedOwnedValue, context)
-    context.erase(instruction: copy)
+    let forwardedOwnedValue = replaceGuaranteed(value: self, withOwnedValue: loadCopy, context)
+    copy.replace(with: forwardedOwnedValue, context)
     context.erase(instructionIncludingAllUsers: self)
   }
 }
@@ -118,9 +117,8 @@ private func tryReplaceCopy(
   }
   let builder = Builder(before: beginBorrow, context)
   let copiedOperand = builder.createCopyValue(operand: beginBorrow.borrowedValue)
-  let forwardedOwnedValue = replace(guaranteedValue: beginBorrow, withOwnedValue: copiedOperand, context)
-  copy.uses.replaceAll(with: forwardedOwnedValue, context)
-  context.erase(instruction: copy)
+  let forwardedOwnedValue = replaceGuaranteed(value: beginBorrow, withOwnedValue: copiedOperand, context)
+  copy.replace(with: forwardedOwnedValue, context)
   context.erase(instructionIncludingAllUsers: beginBorrow)
   return true
 }
@@ -140,7 +138,7 @@ private func tryReplaceCopy(
 ///   destroy_value %2
 /// ```
 private func convertAllUsesToOwned(of beginBorrow: BeginBorrowInst, _ context: SimplifyContext) {
-  let forwardedOwnedValue = replace(guaranteedValue: beginBorrow, withOwnedValue: beginBorrow.borrowedValue, context)
+  let forwardedOwnedValue = replaceGuaranteed(value: beginBorrow, withOwnedValue: beginBorrow.borrowedValue, context)
   beginBorrow.borrowedValue.replaceAllDestroys(with: forwardedOwnedValue, context)
   context.erase(instructionIncludingAllUsers: beginBorrow)
 }
@@ -216,29 +214,29 @@ private extension ForwardingInstruction {
 ///
 /// Returns the last owned value in a forwarding-chain or `ownedValue` if `guaranteedValue` has
 /// no forwarding uses.
-private func replace(guaranteedValue: Value, withOwnedValue ownedValue: Value, _ context: SimplifyContext) -> Value {
+private func replaceGuaranteed(value: Value, withOwnedValue ownedValue: Value, _ context: SimplifyContext) -> Value {
   var result = ownedValue
   var numForwardingUses = 0
-  for use in guaranteedValue.uses {
+  for use in value.uses {
 
     switch use.instruction {
     case let tei as TupleExtractInst:
       numForwardingUses += 1
       let dti = Builder(before: tei, context).createDestructureTuple(tuple: ownedValue)
-      result = replace(guaranteedValue: tei, withOwnedValue: dti.results[tei.fieldIndex], context)
+      result = replaceGuaranteed(value: tei, withOwnedValue: dti.results[tei.fieldIndex], context)
       context.erase(instruction: tei)
     case let sei as StructExtractInst:
       numForwardingUses += 1
       let dsi = Builder(before: sei, context).createDestructureStruct(struct: ownedValue)
-      result = replace(guaranteedValue: sei, withOwnedValue: dsi.results[sei.fieldIndex], context)
+      result = replaceGuaranteed(value: sei, withOwnedValue: dsi.results[sei.fieldIndex], context)
       context.erase(instruction: sei)
     case let fwdInst as (SingleValueInstruction & ForwardingInstruction) where
          fwdInst.isSingleForwardedOperand(use):
       // Other forwarding instructions beside tuple_extract and struct_extract
       numForwardingUses += 1
       use.set(to: ownedValue, context)
       fwdInst.setForwardingOwnership(to: .owned, context)
-      result = replace(guaranteedValue: fwdInst, withOwnedValue: fwdInst, context)
+      result = replaceGuaranteed(value: fwdInst, withOwnedValue: fwdInst, context)
     case is EndBorrowInst:
       break
     default:

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginCOWMutation.swift

@@ -86,8 +86,7 @@ private extension BeginCOWMutationInst {
 
     for use in buffer.uses.ignoreDebugUses {
       let endCOW = use.instruction as! EndCOWMutationInst
-      endCOW.uses.replaceAll(with: instance, context)
-      context.erase(instruction: endCOW)
+      endCOW.replace(with: instance, context)
     }
     context.erase(instructionIncludingDebugUses: self)
     return true

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBranch.swift

@@ -53,8 +53,7 @@ private extension BranchInst {
       if let phi = Phi(arg),
          let bfi = phi.borrowedFrom
       {
-        bfi.uses.replaceAll(with: op.value, context)
-        context.erase(instruction: bfi)
+        bfi.replace(with: op.value, context)
       } else {
         arg.uses.replaceAll(with: op.value, context)
       }