[NFC] LifetimeDependenceDefUseWalker.inoutDependence entry point

Handle cases where there's no relevant operand.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -557,9 +557,9 @@ extension DiagnoseDependenceWalker : LifetimeDependenceDefUseWalker {
  return .abortWalk
  }
 
- mutating func inoutDependence(argument: FunctionArgument, on operand: Operand) -> WalkResult {
+ mutating func inoutDependence(argument: FunctionArgument, functionExit: Instruction) -> WalkResult {
  if diagnostics.checkInoutResult(argument: argument) == .abortWalk {
- diagnostics.reportEscaping(operand: operand)
+ diagnostics.reportEscaping(value: argument, user: functionExit)
  return .abortWalk
  }
  return .continueWalk

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -685,7 +685,7 @@ extension ScopeExtension {
  do {
  // The innermost scope that must be extended must dominate all uses.
  var walker = LifetimeDependentUseWalker(function, localReachabilityCache, context) {
- inRangeUses.append($0.instruction)
+ inRangeUses.append($0)
  return .continueWalk
  }
  defer {walker.deinitialize()}
@@ -1064,15 +1064,15 @@ private extension BeginApplyInst {
 private struct LifetimeDependentUseWalker : LifetimeDependenceDefUseWalker {
  let function: Function
  let context: Context
- let visitor: (Operand) -> WalkResult
+ let visitor: (Instruction) -> WalkResult
  let localReachabilityCache: LocalVariableReachabilityCache
  var visitedValues: ValueSet
 
  /// Set to true if the dependence is returned from the current function.
  var dependsOnCaller = false
 
  init(_ function: Function, _ localReachabilityCache: LocalVariableReachabilityCache, _ context: Context,
- visitor: @escaping (Operand) -> WalkResult) {
+ visitor: @escaping (Instruction) -> WalkResult) {
  self.function = function
  self.context = context
  self.visitor = visitor
@@ -1091,42 +1091,42 @@ private struct LifetimeDependentUseWalker : LifetimeDependenceDefUseWalker {
  mutating func deadValue(_ value: Value, using operand: Operand?)
  -> WalkResult {
  if let operand {
- return visitor(operand)
+ return visitor(operand.instruction)
  }
  return .continueWalk
  }
 
  mutating func leafUse(of operand: Operand) -> WalkResult {
- return visitor(operand)
+ return visitor(operand.instruction)
  }
 
  mutating func escapingDependence(on operand: Operand) -> WalkResult {
  log(">>> Escaping dependence: \(operand)")
- _ = visitor(operand)
+ _ = visitor(operand.instruction)
  // Make a best-effort attempt to extend the access scope regardless of escapes. It is possible that some mandatory
  // pass between scope fixup and diagnostics will make it possible for the LifetimeDependenceDefUseWalker to analyze
  // this use.
  return .continueWalk
  }
 
- mutating func inoutDependence(argument: FunctionArgument, on operand: Operand) -> WalkResult {
+ mutating func inoutDependence(argument: FunctionArgument, functionExit: Instruction) -> WalkResult {
  dependsOnCaller = true
- return visitor(operand)
+ return visitor(functionExit)
  }
 
  mutating func returnedDependence(result operand: Operand) -> WalkResult {
  dependsOnCaller = true
- return visitor(operand)
+ return visitor(operand.instruction)
  }
 
  mutating func returnedDependence(address: FunctionArgument,
  on operand: Operand) -> WalkResult {
  dependsOnCaller = true
- return visitor(operand)
+ return visitor(operand.instruction)
  }
 
  mutating func yieldedDependence(result: Operand) -> WalkResult {
- return visitor(result)
+ return visitor(result.instruction)
  }
 
  mutating func storeToYieldDependence(address: Value, of operand: Operand) -> WalkResult {

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -614,7 +614,7 @@ extension LifetimeDependence.Scope {
 /// leafUse(of: Operand) -> WalkResult
 /// deadValue(_ value: Value, using operand: Operand?) -> WalkResult
 /// escapingDependence(on operand: Operand) -> WalkResult
-/// inoutDependence(argument: FunctionArgument, on: Operand) -> WalkResult
+/// inoutDependence(argument: FunctionArgument, functionExit: Instruction) -> WalkResult
 /// returnedDependence(result: Operand) -> WalkResult
 /// returnedDependence(address: FunctionArgument, on: Operand) -> WalkResult
 /// yieldedDependence(result: Operand) -> WalkResult
@@ -634,9 +634,9 @@ protocol LifetimeDependenceDefUseWalker : ForwardingDefUseWalker,
 
  mutating func escapingDependence(on operand: Operand) -> WalkResult
 
- // Assignment to an inout argument. This does not include the indirect out result, which is considered a return
+ // Assignment to an inout argument. This does not include the @out result, which is considered a return
  // value.
- mutating func inoutDependence(argument: FunctionArgument, on: Operand) -> WalkResult
+ mutating func inoutDependence(argument: FunctionArgument, functionExit: Instruction) -> WalkResult
 
  mutating func returnedDependence(result: Operand) -> WalkResult
 
@@ -1025,15 +1025,12 @@ extension LifetimeDependenceDefUseWalker {
  if !localReachability.gatherAllReachableUses(of: storeAccess, in: &accessStack) {
  return escapingDependence(on: storedOperand)
  }
- for localAccess in accessStack {
- if visitLocalAccess(allocation: allocation, localAccess: localAccess, initialValue: storedOperand) == .abortWalk {
- return .abortWalk
- }
+ return accessStack.walk { localAccess in
+ visitLocalAccess(allocation: allocation, localAccess: localAccess)
  }
- return .continueWalk
  }
 
- private mutating func visitLocalAccess(allocation: Value, localAccess: LocalVariableAccess, initialValue: Operand)
+ private mutating func visitLocalAccess(allocation: Value, localAccess: LocalVariableAccess)
  -> WalkResult {
  switch localAccess.kind {
  case .beginAccess:
@@ -1080,7 +1077,7 @@ extension LifetimeDependenceDefUseWalker {
  case .outgoingArgument:
  let arg = allocation as! FunctionArgument
  assert(arg.type.isAddress, "returned local must be allocated with an indirect argument")
- return inoutDependence(argument: arg, on: initialValue)
+ return inoutDependence(argument: arg, functionExit: localAccess.instruction!)
  case .inoutYield:
  return yieldedDependence(result: localAccess.operand!)
  case .incomingArgument:
@@ -1180,8 +1177,8 @@ private struct LifetimeDependenceUsePrinter : LifetimeDependenceDefUseWalker {
  return .continueWalk
  }
 
- mutating func inoutDependence(argument: FunctionArgument, on operand: Operand) -> WalkResult {
- print("Out use: \(operand) in: \(argument)")
+ mutating func inoutDependence(argument: FunctionArgument, functionExit: Instruction) -> WalkResult {
+ print("Returned inout: \(argument) exit: \(functionExit)")
  return .continueWalk
  }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/LocalVariableUtils.swift

@@ -857,6 +857,7 @@ extension LocalVariableReachableAccess {
  break
  }
  if block.terminator.isFunctionExiting {
+ // Record any reachable function exit as .outgoingArgument.
  accessStack.push(LocalVariableAccess(.outgoingArgument, block.terminator))
  } else if block.successors.isEmpty {
  accessStack.push(LocalVariableAccess(.deadEnd, block.terminator))