Merge pull request #70535 from atrick/function-conventions

Migrate SwiftCompilerSources to FunctionConvention

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -188,10 +188,8 @@ private struct SideEffectsVisitor : EscapeVisitorWithResult {
       return .ignore
     }
     if user == apply {
-      if let argIdx = apply.argumentIndex(of: operand) {
-        let e = calleeAnalysis.getSideEffects(of: apply, forArgument: argIdx, path: path.projectionPath)
-        result.merge(with: e)
-      }
+      let e = calleeAnalysis.getSideEffects(of: apply, operand: operand, path: path.projectionPath)
+      result.merge(with: e)
     }
     return .continueWalk
   }
@@ -246,7 +244,7 @@ private struct IsIndirectResultWalker: AddressDefUseWalker {
 
   mutating func leafUse(address: Operand, path: UnusedWalkingPath) -> WalkResult {
     if address.instruction == apply,
-       let argIdx = apply.argumentIndex(of: address),
+       let argIdx = apply.calleeArgumentIndex(of: address),
        argIdx < apply.numIndirectResultArguments {
       return .abortWalk
     }

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -78,16 +78,18 @@ public struct CalleeAnalysis {
   }
 
   /// Returns the argument specific side effects of an apply.
-  public func getSideEffects(of apply: ApplySite, forArgument argumentIdx: Int, path: SmallProjectionPath) -> SideEffects.GlobalEffects {
-    let calleeArgIdx = apply.calleeArgIndex(callerArgIndex: argumentIdx)
-    let convention = apply.getArgumentConvention(calleeArgIndex: calleeArgIdx)
-    let argument = apply.arguments[argumentIdx].at(path)
+  public func getSideEffects(of apply: ApplySite, operand: Operand, path: SmallProjectionPath) -> SideEffects.GlobalEffects {
+    var result = SideEffects.GlobalEffects()
+    guard let calleeArgIdx = apply.calleeArgumentIndex(of: operand) else {
+      return result
+    }
+    let convention = apply.convention(of: operand)!
+    let argument = operand.value.at(path)
 
     guard let callees = getCallees(callee: apply.callee) else {
       return .worstEffects.restrictedTo(argument: argument, withConvention: convention)
     }
 
-    var result = SideEffects.GlobalEffects()
     for callee in callees {
       let calleeEffects = callee.getSideEffects(forArgument: argument,
                                                 atIndex: calleeArgIdx,

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -139,7 +139,7 @@ private func isOperandOfRecursiveCall(_ op: Operand) -> Bool {
   if let applySite = inst as? FullApplySite,
      let callee = applySite.referencedFunction,
      callee == inst.parentFunction,
-     let argIdx = applySite.argumentIndex(of: op),
+     let argIdx = applySite.calleeArgumentIndex(of: op),
      op.value == callee.arguments[argIdx] {
     return true
   }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -239,9 +239,9 @@ private struct CollectedEffects {
 
   private mutating func handleApply(_ apply: ApplySite) {
     let callees = calleeAnalysis.getCallees(callee: apply.callee)
-    let args = apply.arguments.enumerated().lazy.map {
-      (calleeArgumentIndex: apply.calleeArgIndex(callerArgIndex: $0.0),
-       callerArgument: $0.1)
+    let args = apply.argumentOperands.lazy.map {
+      (calleeArgumentIndex: apply.calleeArgumentIndex(of: $0)!,
+       callerArgument: $0.value)
     }
     addEffects(ofFunctions: callees, withArguments: args)
   }
@@ -316,7 +316,7 @@ private struct CollectedEffects {
           if let calleePath = calleeEffect.copy    { addEffects(.copy,    to: argument, fromInitialPath: calleePath) }
           if let calleePath = calleeEffect.destroy { addEffects(.destroy, to: argument, fromInitialPath: calleePath) }
         } else {
-          let convention = callee.getArgumentConvention(for: calleeArgIdx)
+          let convention = callee.argumentConventions[calleeArgIdx]
           let wholeArgument = argument.at(defaultPath(for: argument))
           let calleeEffects = callee.getSideEffects(forArgument: wholeArgument,
                                                     atIndex: calleeArgIdx,
@@ -444,7 +444,7 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
       return .continueWalk
 
     case let apply as ApplySite:
-      if apply.isCalleeOperand(value) {
+      if apply.isCallee(operand: value) {
         // `CollectedEffects.handleApply` only handles argument operands of an apply, but not the callee operand.
         return .abortWalk
       }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -350,7 +350,7 @@ func isBridgeToSwiftCall(_ value: Value) -> ApplyInst? {
     return nil
   }
   guard bridgingCall.arguments.count == 2,
-        bridgingCall.getArgumentConvention(calleeArgIndex: 0) == .directGuaranteed else {
+        bridgingCall.calleeArgumentConventions[0] == .directGuaranteed else {
     return nil
   }
   return bridgingCall
@@ -362,7 +362,7 @@ func isBridgeToObjcCall(_ value: Value) -> ApplyInst? {
         let bridgingFunc = bridgingCall.referencedFunction,
         bridgingFunc.hasSemanticsAttribute("convertToObjectiveC"),
         bridgingCall.arguments.count == 1,
-        bridgingCall.getArgumentConvention(calleeArgIndex: 0) == .directGuaranteed else {
+        bridgingCall.calleeArgumentConventions[0] == .directGuaranteed else {
     return nil
   }
   return bridgingCall

SwiftCompilerSources/Sources/Optimizer/ModulePasses/ReadOnlyGlobalVariables.swift

@@ -59,9 +59,8 @@ private struct FindWrites : AddressDefUseWalker {
       return address == ca.sourceOperand ? .continueWalk : .abortWalk
 
     case let apply as FullApplySite:
-      if let callerArgIdx = apply.argumentIndex(of: address) {
-        let calleeArgIdx = apply.calleeArgIndex(callerArgIndex: callerArgIdx)
-        let convention = apply.getArgumentConvention(calleeArgIndex: calleeArgIdx)
+      if let calleeArgIdx = apply.calleeArgumentIndex(of: address) {
+        let convention = apply.calleeArgumentConventions[calleeArgIdx]
         if convention.isIndirectIn {
           return .continueWalk
         }

SwiftCompilerSources/Sources/Optimizer/ModulePasses/StackProtection.swift

@@ -260,13 +260,13 @@ private struct StackProtectionOptimization {
 
         for functionRefUse in fri.uses {
           guard let apply = functionRefUse.instruction as? ApplySite,
-                let callerArgIdx = apply.callerArgIndex(calleeArgIndex: arg.index) else {
+                let callerArgOp = apply.operand(forCalleeArgumentIndex: arg.index) else {
             if enableMoveInout {
               return NeedInsertMoves.yes
             }
             continue
           }
-          let callerArg = apply.arguments[callerArgIdx]
+          let callerArg = callerArgOp.value
           if callerArg.type.isAddress {
             // It's an indirect argument.
             switch callerArg.accessBase.isStackAllocated {

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -491,7 +491,7 @@ extension Operand {
 
 extension Instruction {
   func setOperand(at index : Int, to value: Value, _ context: some MutatingContext) {
-    if self is FullApplySite && index == ApplyOperands.calleeOperandIndex {
+    if let apply = self as? FullApplySite, apply.isCallee(operand: operands[index]) {
       context.notifyCallsChanged()
     }
     context.notifyInstructionsChanged()

SwiftCompilerSources/Sources/Optimizer/Utilities/Devirtualization.swift

@@ -107,7 +107,7 @@ extension DestroyValueInst : DevirtualizableDestroy {
     let builder = Builder(before: self, context)
     let subs = context.getContextSubstitutionMap(for: type)
     let deinitRef = builder.createFunctionRef(deinitializer)
-    if deinitializer.getArgumentConvention(for: deinitializer.selfArgumentIndex).isIndirect {
+    if deinitializer.argumentConventions[deinitializer.selfArgumentIndex].isIndirect {
       let allocStack = builder.createAllocStack(type)
       builder.createStore(source: destroyedValue, destination: allocStack, ownership: .initialize)
       builder.createApply(function: deinitRef, subs, arguments: [allocStack])
@@ -175,7 +175,7 @@ extension DestroyAddrInst : DevirtualizableDestroy {
     let builder = Builder(before: self, context)
     let subs = context.getContextSubstitutionMap(for: destroyedAddress.type)
     let deinitRef = builder.createFunctionRef(deinitializer)
-    if !deinitializer.getArgumentConvention(for: deinitializer.selfArgumentIndex).isIndirect {
+    if !deinitializer.argumentConventions[deinitializer.selfArgumentIndex].isIndirect {
       let value = builder.createLoad(fromAddress: destroyedAddress, ownership: .take)
       builder.createApply(function: deinitRef, subs, arguments: [value])
     } else {

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -555,7 +555,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   /// Handle an apply (full or partial) during the walk-down.
   private mutating
   func walkDownCallee(argOp: Operand, apply: ApplySite, path: Path) -> WalkResult {
-    guard let argIdx = apply.argumentIndex(of: argOp) else {
+    guard let calleeArgIdx = apply.calleeArgumentIndex(of: argOp) else {
       // The callee or a type dependent operand of the apply does not let escape anything.
       return .continueWalk
     }
@@ -591,8 +591,6 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       return isEscaping
     }
 
-    let calleeArgIdx = apply.calleeArgIndex(callerArgIndex: argIdx)
-
     for callee in callees {
       let effects = callee.effects
       if !effects.escapeEffects.canEscape(argumentIndex: calleeArgIdx,
@@ -617,12 +615,12 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       case .escapingToArgument(let toArgIdx, let toPath):
         // Note: exclusive argument -> argument effects cannot appear, so we don't need to handle them here.
         if effect.matches(calleeArgIdx, argPath.projectionPath) {
-          guard let callerToIdx = apply.callerArgIndex(calleeArgIndex: toArgIdx) else {
+          guard let argOp = apply.operand(forCalleeArgumentIndex: toArgIdx) else {
             return isEscaping
           }
 
           // Continue at the destination of an arg-to-arg escape.
-          let arg = apply.arguments[callerToIdx]
+          let arg = argOp.value
 
           let p = Path(projectionPath: toPath, followStores: false, knownType: nil)
           if walkUp(addressOrValue: arg, path: p) == .abortWalk {
@@ -778,10 +776,10 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
         switch effect.kind {
         case .escapingToReturn(let toPath, let exclusive):
           if exclusive && path.projectionPath.matches(pattern: toPath) {
-            guard let callerArgIdx = apply.callerArgIndex(calleeArgIndex: effect.argumentIndex) else {
+            guard let argOp = apply.operand(forCalleeArgumentIndex: effect.argumentIndex) else {
               return .abortWalk
             }
-            let arg = apply.arguments[callerArgIdx]
+            let arg = argOp.value
 
             let p = Path(projectionPath: effect.pathPattern, followStores: path.followStores, knownType: nil)
             if walkUp(addressOrValue: arg, path: p) == .abortWalk {