Merge pull request #4879 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEffects.swift

@@ -12,8 +12,6 @@
 
 import SIL
 
-fileprivate typealias Selection = ArgumentEffect.Selection
-
 /// Computes effects for function arguments.
 ///
 /// For example, if an argument does not escape, adds a non-escaping effect,
@@ -50,17 +48,16 @@ let computeEffects = FunctionPass(name: "compute-effects", {
 
     // First check: is the argument (or a projected value of it) escaping at all?
     if !escapeInfo.isEscapingWhenWalkingDown(object: arg, path: SmallProjectionPath(.anything)) {
-      let selectedArg = Selection(arg, pathPattern: SmallProjectionPath(.anything))
-      newEffects.push(ArgumentEffect(.notEscaping, selectedArg: selectedArg))
+      newEffects.push(ArgumentEffect(.notEscaping, argumentIndex: arg.index, pathPattern: SmallProjectionPath(.anything)))
       continue
     }
 
     // Now compute effects for two important cases:
     //   * the argument itself + any value projections, and...
-    if addArgEffects(context: context, arg, argPath: SmallProjectionPath(), to: &newEffects, returnInst) {
+    if addArgEffects(arg, argPath: SmallProjectionPath(), to: &newEffects, returnInst, context) {
       //   * single class indirections
-      _ = addArgEffects(context: context, arg, argPath: SmallProjectionPath(.anyValueFields).push(.anyClassField),
-                        to: &newEffects, returnInst)
+      _ = addArgEffects(arg, argPath: SmallProjectionPath(.anyValueFields).push(.anyClassField),
+                        to: &newEffects, returnInst, context)
     }
   }
 
@@ -74,34 +71,35 @@ let computeEffects = FunctionPass(name: "compute-effects", {
 
 /// Returns true if an argument effect was added.
 private
-func addArgEffects(context: PassContext, _ arg: FunctionArgument, argPath ap: SmallProjectionPath,
+func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
                    to newEffects: inout Stack<ArgumentEffect>,
-                   _ returnInst: ReturnInst?) -> Bool {
+                   _ returnInst: ReturnInst?, _ context: PassContext) -> Bool {
   // Correct the path if the argument is not a class reference itself, but a value type
   // containing one or more references.
   let argPath = arg.type.isClass ? ap : ap.push(.anyValueFields)
 
   struct ArgEffectsVisitor : EscapeInfoVisitor {
-    init(toSelection: Selection?, returnInst: ReturnInst?) {
-      self.toSelection = toSelection
-      self.returnInst = returnInst
+    enum EscapeDestination {
+      case notSet
+      case toReturn(SmallProjectionPath)
+      case toArgument(Int, SmallProjectionPath) // argument index, path
     }
-    
-    var toSelection: Selection?
-    var returnInst: ReturnInst?
+    var result = EscapeDestination.notSet
 
     mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
-      if operand.instruction == returnInst {
+      if operand.instruction is ReturnInst {
         // The argument escapes to the function return
         if path.followStores {
           // The escaping path must not introduce a followStores.
           return .abort
         }
-        if let ta = toSelection {
-          if ta.value != .returnValue { return .abort }
-          toSelection = Selection(.returnValue, pathPattern: path.projectionPath.merge(with: ta.pathPattern))
-        } else {
-          toSelection = Selection(.returnValue, pathPattern: path.projectionPath)
+        switch result {
+          case .notSet:
+            result = .toReturn(path.projectionPath)
+          case .toReturn(let oldPath):
+            result = .toReturn(oldPath.merge(with: path.projectionPath))
+          case .toArgument:
+            return .abort
         }
         return .ignore
       }
@@ -121,37 +119,44 @@ func addArgEffects(context: PassContext, _ arg: FunctionArgument, argPath ap: Sm
         return .abort
       }
       let argIdx = destArg.index
-      if let ta = toSelection {
-        if ta.value != .argument(argIdx) { return .abort }
-        toSelection = Selection(.argument(argIdx), pathPattern: path.projectionPath.merge(with: ta.pathPattern))
-      } else {
-        toSelection = Selection(.argument(argIdx), pathPattern: path.projectionPath)
+      switch result {
+        case .notSet:
+          result = .toArgument(argIdx, path.projectionPath)
+        case .toArgument(let oldArgIdx, let oldPath) where oldArgIdx == argIdx:
+          result = .toArgument(argIdx, oldPath.merge(with: path.projectionPath))
+        default:
+          return .abort
       }
       return .walkDown
     }
   }
 
-  var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: ArgEffectsVisitor(toSelection: nil, returnInst: returnInst))
+  var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: ArgEffectsVisitor())
   if walker.isEscapingWhenWalkingDown(object: arg, path: argPath) {
     return false
   }
 
-  let toSelection = walker.visitor.toSelection
-  let fromSelection = Selection(arg, pathPattern: argPath)
-
-  guard let toSelection = toSelection else {
-    newEffects.push(ArgumentEffect(.notEscaping, selectedArg: fromSelection))
-    return true
-  }
-  
   // If the function never returns, the argument can not escape to another arg/return.
-  guard let returnInst = returnInst else {
+  guard let returnInst = arg.function.returnInstruction else {
     return false
   }
 
-  let exclusive = isExclusiveEscape(context: context, fromArgument: arg, fromPath: argPath, to: toSelection, returnInst)
-
-  newEffects.push(ArgumentEffect(.escaping(toSelection, exclusive), selectedArg: fromSelection))
+  let effect: ArgumentEffect
+  switch walker.visitor.result {
+  case .notSet:
+    effect = ArgumentEffect(.notEscaping, argumentIndex: arg.index, pathPattern: argPath)
+  case .toReturn(let toPath):
+    let exclusive = isExclusiveEscapeToReturn(fromArgument: arg, fromPath: argPath,
+                                              toPath: toPath, returnInst: returnInst, context)
+    effect = ArgumentEffect(.escapingToReturn(toPath, exclusive),
+                            argumentIndex: arg.index, pathPattern: argPath)
+  case .toArgument(let toArgIdx, let toPath):
+    let exclusive = isExclusiveEscapeToArgument(fromArgument: arg, fromPath: argPath,
+                                                toArgumentIndex: toArgIdx, toPath: toPath, context)
+    effect = ArgumentEffect(.escapingToArgument(toArgIdx, toPath, exclusive),
+                            argumentIndex: arg.index, pathPattern: argPath)
+  }
+  newEffects.push(effect)
   return true
 }
 
@@ -162,17 +167,13 @@ private func getArgIndicesWithDefinedEffects(of function: Function) -> Set<Int>
   for effect in function.effects.argumentEffects {
     if effect.isDerived { continue }
 
-    if case .argument(let argIdx) = effect.selectedArg.value {
-      argsWithDefinedEffects.insert(argIdx)
-    }
+    argsWithDefinedEffects.insert(effect.argumentIndex)
 
     switch effect.kind {
-    case .notEscaping:
+    case .notEscaping, .escapingToReturn:
       break
-    case .escaping(let to, _):
-      if case .argument(let toArgIdx) = to.value {
-        argsWithDefinedEffects.insert(toArgIdx)
-      }
+    case .escapingToArgument(let toArgIdx, _, _):
+      argsWithDefinedEffects.insert(toArgIdx)
     }
   }
   return argsWithDefinedEffects
@@ -196,70 +197,64 @@ private func isOperandOfRecursiveCall(_ op: Operand) -> Bool {
 /// there are no other arguments or escape points than `fromArgument`. Also, the
 /// path at the `fromArgument` must match with `fromPath`.
 private
-func isExclusiveEscape(context: PassContext, fromArgument: Argument, fromPath: SmallProjectionPath, to toSelection: Selection,
-                       _ returnInst: ReturnInst) -> Bool {
-  switch toSelection.value {
-  
-  // argument -> return
-  case .returnValue:
-    struct IsExclusiveReturnEscapeVisitor : EscapeInfoVisitor {
-      let fromArgument: Argument
-      let toSelection: Selection
-      let returnInst: ReturnInst
-      let fromPath: SmallProjectionPath
-      
-      mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
-        if operand.instruction == returnInst {
-          if path.followStores { return .abort }
-          if path.projectionPath.matches(pattern: toSelection.pathPattern) {
-            return .ignore
-          }
-          return .abort
-        }
-        return .continueWalk
-      }
-      
-      mutating func visitDef(def: Value, path: EscapePath) -> DefResult {
-        guard let arg = def as? FunctionArgument else {
-          return .continueWalkUp
-        }
+func isExclusiveEscapeToReturn(fromArgument: Argument, fromPath: SmallProjectionPath,
+                               toPath: SmallProjectionPath,
+                               returnInst: ReturnInst, _ context: PassContext) -> Bool {
+  struct IsExclusiveReturnEscapeVisitor : EscapeInfoVisitor {
+    let fromArgument: Argument
+    let fromPath: SmallProjectionPath
+    let toPath: SmallProjectionPath
+    
+    mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
+      if operand.instruction is ReturnInst {
         if path.followStores { return .abort }
-        if arg == fromArgument && path.projectionPath.matches(pattern: fromPath) {
-          return .walkDown
+        if path.projectionPath.matches(pattern: toPath) {
+          return .ignore
         }
         return .abort
       }
+      return .continueWalk
     }
-    let visitor = IsExclusiveReturnEscapeVisitor(fromArgument: fromArgument, toSelection: toSelection, returnInst: returnInst, fromPath: fromPath)
-    var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: visitor)
-    if walker.isEscaping(object: returnInst.operand, path: toSelection.pathPattern) {
-      return false
-    }
-  // argument -> argument
-  case .argument(let toArgIdx):
-    struct IsExclusiveArgumentEscapeVisitor : EscapeInfoVisitor {
-      let fromArgument: Argument
-      let fromPath: SmallProjectionPath
-      let toSelection: Selection
-      let toArg: FunctionArgument
-      
-      mutating func visitDef(def: Value, path: EscapePath) -> DefResult {
-        guard let arg = def as? FunctionArgument else {
-          return .continueWalkUp
-        }
-        if path.followStores { return .abort }
-        if arg == fromArgument && path.projectionPath.matches(pattern: fromPath) { return .walkDown }
-        if arg == toArg && path.projectionPath.matches(pattern: toSelection.pathPattern) { return .walkDown }
-        return .abort
+    
+    mutating func visitDef(def: Value, path: EscapePath) -> DefResult {
+      guard let arg = def as? FunctionArgument else {
+        return .continueWalkUp
+      }
+      if path.followStores { return .abort }
+      if arg == fromArgument && path.projectionPath.matches(pattern: fromPath) {
+        return .walkDown
       }
+      return .abort
     }
-    let toArg = returnInst.function.arguments[toArgIdx]
-    let visitor = IsExclusiveArgumentEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath, toSelection: toSelection, toArg: toArg)
-    var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: visitor)
-    if walker.isEscaping(object: toArg, path: toSelection.pathPattern) {
-      return false
+  }
+  let visitor = IsExclusiveReturnEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath, toPath: toPath)
+  var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: visitor)
+  return !walker.isEscaping(object: returnInst.operand, path: toPath)
+}
+
+private
+func isExclusiveEscapeToArgument(fromArgument: Argument, fromPath: SmallProjectionPath,
+                                 toArgumentIndex: Int, toPath: SmallProjectionPath, _ context: PassContext) -> Bool {
+  struct IsExclusiveArgumentEscapeVisitor : EscapeInfoVisitor {
+    let fromArgument: Argument
+    let fromPath: SmallProjectionPath
+    let toArgumentIndex: Int
+    let toPath: SmallProjectionPath
+    
+    mutating func visitDef(def: Value, path: EscapePath) -> DefResult {
+      guard let arg = def as? FunctionArgument else {
+        return .continueWalkUp
+      }
+      if path.followStores { return .abort }
+      if arg == fromArgument && path.projectionPath.matches(pattern: fromPath) { return .walkDown }
+      if arg.index == toArgumentIndex && path.projectionPath.matches(pattern: toPath) { return .walkDown }
+      return .abort
     }
   }
-  return true
+  let visitor = IsExclusiveArgumentEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath,
+                                                 toArgumentIndex: toArgumentIndex, toPath: toPath)
+  var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: visitor)
+  let toArg = fromArgument.function.arguments[toArgumentIndex]
+  return !walker.isEscaping(object: toArg, path: toPath)
 }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeInfo.swift

@@ -601,52 +601,51 @@ fileprivate struct EscapeInfoWalker<V: EscapeInfoVisitor> : ValueDefUseWalker,
                         apply: ApplySite, effects: FunctionEffects) -> WalkResult {
     var matched = false
     for effect in effects.argumentEffects {
-      guard case .escaping(let to, let exclusive) = effect.kind else {
-        continue
-      }
-      if effect.selectedArg.matches(.argument(calleeArgIdx), argPath.projectionPath) {
-        matched = true
-
-        switch to.value {
-        case .returnValue:
-          guard let fas = apply as? FullApplySite, let result = fas.singleDirectResult else { return isEscaping }
-          
-          let p = Path(projectionPath: to.pathPattern, followStores: false, knownType: exclusive ? argPath.knownType : nil)
-          
-          if walkDownUses(ofValue: result, path: p) == .abortWalk {
-            return .abortWalk
-          }
-        case .argument(let toArgIdx):
+      switch effect.kind {
+      case .escapingToArgument(let toArgIdx, let toPath, let exclusive):
+        if effect.matches(calleeArgIdx, argPath.projectionPath) {
           guard let callerToIdx = apply.callerArgIndex(calleeArgIndex: toArgIdx) else {
             return isEscaping
           }
 
           // Continue at the destination of an arg-to-arg escape.
           let arg = apply.arguments[callerToIdx]
 
-          let p = Path(projectionPath: to.pathPattern, followStores: false, knownType: nil)
+          let p = Path(projectionPath: toPath, followStores: false, knownType: nil)
           if walkUp(addressOrValue: arg, path: p) == .abortWalk {
             return .abortWalk
           }
-        }
-        continue
-      }
-      // Handle the reverse direction of an arg-to-arg escape.
-      if to.matches(.argument(calleeArgIdx), argPath.projectionPath) {
-        guard let callerArgIdx = apply.callerArgIndex(calleeArgIndex: effect.selectedArg.argumentIndex) else {
-          return isEscaping
-        }
-        if !exclusive { return isEscaping }
+          matched = true
+        } else if toArgIdx == calleeArgIdx && argPath.projectionPath.matches(pattern: toPath) {
+          // Handle the reverse direction of an arg-to-arg escape.
+          guard let callerArgIdx = apply.callerArgIndex(calleeArgIndex: effect.argumentIndex) else {
+            return isEscaping
+          }
+          if !exclusive { return isEscaping }
 
-        matched = true
-        
-        let arg = apply.arguments[callerArgIdx]
-        let p = Path(projectionPath: effect.selectedArg.pathPattern, followStores: false, knownType: nil)
+          let arg = apply.arguments[callerArgIdx]
+          let p = Path(projectionPath: effect.pathPattern, followStores: false, knownType: nil)
 
-        if walkUp(addressOrValue: arg, path: p) == .abortWalk {
-          return .abortWalk
+          if walkUp(addressOrValue: arg, path: p) == .abortWalk {
+            return .abortWalk
+          }
+          matched = true
         }
-        continue
+      case .escapingToReturn(let toPath, let exclusive):
+        if effect.matches(calleeArgIdx, argPath.projectionPath) {
+          guard let fas = apply as? FullApplySite, let result = fas.singleDirectResult else {
+            return isEscaping
+          }
+
+          let p = Path(projectionPath: toPath, followStores: false, knownType: exclusive ? argPath.knownType : nil)
+          
+          if walkDownUses(ofValue: result, path: p) == .abortWalk {
+            return .abortWalk
+          }
+          matched = true
+        }
+      default:
+        break
       }
     }
     if !matched { return isEscaping }
@@ -765,17 +764,17 @@ fileprivate struct EscapeInfoWalker<V: EscapeInfoVisitor> : ValueDefUseWalker,
       var matched = false
       for effect in callee.effects.argumentEffects {
         switch effect.kind {
-        case .notEscaping:
+        case .notEscaping, .escapingToArgument:
           break
-        case .escaping(let toSelectedArg, let exclusive):
-          if exclusive && toSelectedArg.matches(.returnValue, path.projectionPath) {
-            matched = true
-            let arg = apply.arguments[effect.selectedArg.argumentIndex]
+        case .escapingToReturn(let toPath, let exclusive):
+          if exclusive && path.projectionPath.matches(pattern: toPath) {
+            let arg = apply.arguments[effect.argumentIndex]
 
-            let p = Path(projectionPath: effect.selectedArg.pathPattern, followStores: path.followStores, knownType: nil)
+            let p = Path(projectionPath: effect.pathPattern, followStores: path.followStores, knownType: nil)
             if walkUp(addressOrValue: arg, path: p) == .abortWalk {
               return .abortWalk
             }
+            matched = true
           }
         }
       }