Merge pull request swiftlang#81286 from eeckstein/temprvalue-opt

TempRValueElimination: re-implement the pass in swift

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -262,8 +262,8 @@ struct AliasAnalysis {
     case let copy as SourceDestAddrInstruction:
       let mayRead = memLoc.mayAlias(with: copy.source, self)
       let mayWrite = memLoc.mayAlias(with: copy.destination, self)
-      var effects = SideEffects.Memory(read: mayRead, write: mayWrite || (mayRead && copy.isTakeOfSrc))
-      if !copy.isInitializationOfDest {
+      var effects = SideEffects.Memory(read: mayRead, write: mayWrite || (mayRead && copy.isTakeOfSource))
+      if !copy.isInitializationOfDestination {
         effects.merge(with: defaultEffects(of: copy, on: memLoc))
       }
       return effects

SwiftCompilerSources/Sources/Optimizer/DataStructures/Set.swift

@@ -177,7 +177,44 @@ struct SpecificInstructionSet<InstType: Instruction> : IntrusiveSet {
   }
 }
 
+/// An `InstructionSet` which also provides a `count` property.
+struct SpecificInstructionSetWithCount<InstType: Instruction> : IntrusiveSet {
+  private(set) var count = 0
+  private var underlyingSet: SpecificInstructionSet<InstType>
+
+  init(_ context: some Context) {
+    self.underlyingSet = SpecificInstructionSet(context)
+  }
+
+  func contains(_ inst: InstType) -> Bool { underlyingSet.contains(inst) }
+
+  var isEmpty: Bool { count == 0 }
+
+  /// Returns true if `inst` was not contained in the set before inserting.
+  @discardableResult
+  mutating func insert(_ inst: InstType) -> Bool {
+    if underlyingSet.insert(inst) {
+      count += 1
+      return true
+    }
+    return false
+  }
+
+  mutating func erase(_ inst: InstType) {
+    if underlyingSet.contains(inst) {
+      count -= 1
+      assert(count >= 0)
+    }
+    underlyingSet.erase(inst)
+  }
+
+  var description: String { underlyingSet.description }
+
+  mutating func deinitialize() { underlyingSet.deinitialize() }
+}
+
 typealias InstructionSet = SpecificInstructionSet<Instruction>
+typealias InstructionSetWithCount = SpecificInstructionSetWithCount<Instruction>
 
 /// A set of operands.
 ///

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -33,4 +33,5 @@ swift_compiler_sources(Optimizer
   SimplificationPasses.swift
   StackPromotion.swift
   StripObjectHeaders.swift
+  TempRValueElimination.swift
 )

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -108,10 +108,10 @@ private struct CollectedEffects {
       addEffects(.read, to: copy.source)
       addEffects(.write, to: copy.destination)
 
-      if !copy.isTakeOfSrc {
+      if !copy.isTakeOfSource {
         addEffects(.copy, to: copy.source)
       }
-      if !copy.isInitializationOfDest {
+      if !copy.isInitializationOfDestination {
         addDestroyEffects(ofAddress: copy.destination)
       }
 
@@ -494,7 +494,7 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
     case let copy as CopyAddrInst:
       if address == copy.sourceOperand &&
           !address.value.hasTrivialType &&
-          (!function.hasOwnership || copy.isTakeOfSrc) {
+          (!function.hasOwnership || copy.isTakeOfSource) {
         foundTakingLoad = true
       }
       return .continueWalk

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LetPropertyLowering.swift

@@ -153,7 +153,7 @@ private func constructLetInitRegion(
 
     case let copy as CopyAddrInst
          where copy.destination.isLetFieldAddress(of: markUninitialized):
-      assert(copy.isInitializationOfDest)
+      assert(copy.isInitializationOfDestination)
       initRegion.insert(inst)
 
     case let beginAccess as BeginAccessInst

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/NamedReturnValueOptimization.swift

@@ -78,7 +78,7 @@ private func findCopyForNRVO(for outArg: FunctionArgument) -> CopyAddrInst? {
   //     %local = alloc_stack $T
   //     store %in to %local : $*T
   //     copy_addr %local to [init] %out : $*T
-  if !copyToArg.isTakeOfSrc {
+  if !copyToArg.isTakeOfSource {
     return nil
   }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -158,7 +158,7 @@ extension CopyAddrInst : LoadingInstruction {
       return false
     }
     if !parentFunction.hasOwnership {
-      if !isTakeOfSrc || !isInitializationOfDest {
+      if !isTakeOfSource || !isInitializationOfDestination {
         // For simplicity, bail if we would have to insert compensating retains and releases.
         return false
       }