Swift SIL: add var FunctionArgument.convention

Also:
* move the `ArgumentConvention` enum from Function.swift to Argument.swift.
* `FunctionArgument.isExclusiveIndirectParameter` -> `ArgumentConvention.isExclusiveIndirect`
* add `ArgumentConvention.isInout`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/AccessUtils.swift

@@ -174,7 +174,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
     }
 
     func argIsDistinct(_ arg: FunctionArgument, from other: AccessBase) -> Bool {
-      if arg.isExclusiveIndirectParameter {
+      if arg.convention.isExclusiveIndirect {
         // Exclusive indirect arguments cannot alias with an address for which we know that it
         // is not derived from that argument (which might be the case for `pointer` and `yield`).
         return other.hasKnownStorageKind
@@ -199,7 +199,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
     case (.tail(let rta), .tail(let otherRta)):
       return isDifferentAllocation(rta.operand, otherRta.operand)
     case (.argument(let arg), .argument(let otherArg)):
-      return (arg.isExclusiveIndirectParameter || otherArg.isExclusiveIndirectParameter) && arg != otherArg
+      return (arg.convention.isExclusiveIndirect || otherArg.convention.isExclusiveIndirect) && arg != otherArg
 
     // Handle arguments vs non-arguments
     case (.argument(let arg), _):

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeInfo.swift

@@ -734,7 +734,7 @@ fileprivate struct EscapeInfoWalker<V: EscapeInfoVisitor> : ValueDefUseWalker,
     case is AllocStackInst:
       return cachedWalkDown(addressOrValue: def, path: path.with(knownType: nil))
     case let arg as FunctionArgument:
-      if canIgnoreForLoadOrArgument(path) && arg.isExclusiveIndirectParameter && !path.followStores {
+      if canIgnoreForLoadOrArgument(path) && arg.convention.isExclusiveIndirect && !path.followStores {
         return cachedWalkDown(addressOrValue: def, path: path.with(knownType: nil))
       } else {
         return isEscaping

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -40,8 +40,8 @@ public class Argument : Value, Hashable {
 }
 
 final public class FunctionArgument : Argument {
-  public var isExclusiveIndirectParameter: Bool {
-    SILArgument_isExclusiveIndirectParameter(bridged) != 0
+  public var convention: ArgumentConvention {
+    SILArgument_getConvention(bridged).convention
   }
 }
 
@@ -79,10 +79,112 @@ final public class BlockArgument : Argument {
   }
 }
 
+public enum ArgumentConvention {
+  /// This argument is passed indirectly, i.e. by directly passing the address
+  /// of an object in memory.  The callee is responsible for destroying the
+  /// object.  The callee may assume that the address does not alias any valid
+  /// object.
+  case indirectIn
+
+  /// This argument is passed indirectly, i.e. by directly passing the address
+  /// of an object in memory.  The callee must treat the object as read-only
+  /// The callee may assume that the address does not alias any valid object.
+  case indirectInConstant
+
+  /// This argument is passed indirectly, i.e. by directly passing the address
+  /// of an object in memory.  The callee may not modify and does not destroy
+  /// the object.
+  case indirectInGuaranteed
+
+  /// This argument is passed indirectly, i.e. by directly passing the address
+  /// of an object in memory.  The object is always valid, but the callee may
+  /// assume that the address does not alias any valid object and reorder loads
+  /// stores to the parameter as long as the whole object remains valid. Invalid
+  /// single-threaded aliasing may produce inconsistent results, but should
+  /// remain memory safe.
+  case indirectInout
+
+  /// This argument is passed indirectly, i.e. by directly passing the address
+  /// of an object in memory. The object is allowed to be aliased by other
+  /// well-typed references, but is not allowed to be escaped. This is the
+  /// convention used by mutable captures in @noescape closures.
+  case indirectInoutAliasable
+
+  /// This argument represents an indirect return value address. The callee stores
+  /// the returned value to this argument. At the time when the function is called,
+  /// the memory location referenced by the argument is uninitialized.
+  case indirectOut
+
+  /// This argument is passed directly.  Its type is non-trivial, and the callee
+  /// is responsible for destroying it.
+  case directOwned
+
+  /// This argument is passed directly.  Its type may be trivial, or it may
+  /// simply be that the callee is not responsible for destroying it. Its
+  /// validity is guaranteed only at the instant the call begins.
+  case directUnowned
+
+  /// This argument is passed directly.  Its type is non-trivial, and the caller
+  /// guarantees its validity for the entirety of the call.
+  case directGuaranteed
+
+  public var isExclusiveIndirect: Bool {
+    switch self {
+    case .indirectIn,
+         .indirectInConstant,
+         .indirectOut,
+         .indirectInGuaranteed,
+         .indirectInout:
+      return true
+
+    case .indirectInoutAliasable,
+         .directUnowned,
+         .directGuaranteed,
+         .directOwned:
+      return false
+    }
+  }
+
+  public var isInout: Bool {
+    switch self {
+    case .indirectInout,
+         .indirectInoutAliasable:
+      return true
+
+    case .indirectIn,
+         .indirectInConstant,
+         .indirectOut,
+         .indirectInGuaranteed,
+         .directUnowned,
+         .directGuaranteed,
+         .directOwned:
+      return false
+    }
+  }
+}
+
 // Bridging utilities
 
 extension BridgedArgument {
   public var argument: Argument { obj.getAs(Argument.self) }
   public var blockArgument: BlockArgument { obj.getAs(BlockArgument.self) }
   public var functionArgument: FunctionArgument { obj.getAs(FunctionArgument.self) }
 }
+
+extension BridgedArgumentConvention {
+  var convention: ArgumentConvention {
+    switch self {
+      case ArgumentConvention_Indirect_In:             return .indirectIn
+      case ArgumentConvention_Indirect_In_Constant:    return .indirectInConstant
+      case ArgumentConvention_Indirect_In_Guaranteed:  return .indirectInGuaranteed
+      case ArgumentConvention_Indirect_Inout:          return .indirectInout
+      case ArgumentConvention_Indirect_InoutAliasable: return .indirectInoutAliasable
+      case ArgumentConvention_Indirect_Out:            return .indirectOut
+      case ArgumentConvention_Direct_Owned:            return .directOwned
+      case ArgumentConvention_Direct_Unowned:          return .directUnowned
+      case ArgumentConvention_Direct_Guaranteed:       return .directGuaranteed
+      default:
+        fatalError("unsupported argument convention")
+    }
+  }
+}

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -210,56 +210,6 @@ public struct ArgumentTypeArray : RandomAccessCollection, FormattedLikeArray {
   }
 }
 
-public enum ArgumentConvention {
-  /// This argument is passed indirectly, i.e. by directly passing the address
-  /// of an object in memory.  The callee is responsible for destroying the
-  /// object.  The callee may assume that the address does not alias any valid
-  /// object.
-  case indirectIn
-
-  /// This argument is passed indirectly, i.e. by directly passing the address
-  /// of an object in memory.  The callee must treat the object as read-only
-  /// The callee may assume that the address does not alias any valid object.
-  case indirectInConstant
-
-  /// This argument is passed indirectly, i.e. by directly passing the address
-  /// of an object in memory.  The callee may not modify and does not destroy
-  /// the object.
-  case indirectInGuaranteed
-
-  /// This argument is passed indirectly, i.e. by directly passing the address
-  /// of an object in memory.  The object is always valid, but the callee may
-  /// assume that the address does not alias any valid object and reorder loads
-  /// stores to the parameter as long as the whole object remains valid. Invalid
-  /// single-threaded aliasing may produce inconsistent results, but should
-  /// remain memory safe.
-  case indirectInout
-
-  /// This argument is passed indirectly, i.e. by directly passing the address
-  /// of an object in memory. The object is allowed to be aliased by other
-  /// well-typed references, but is not allowed to be escaped. This is the
-  /// convention used by mutable captures in @noescape closures.
-  case indirectInoutAliasable
-
-  /// This argument represents an indirect return value address. The callee stores
-  /// the returned value to this argument. At the time when the function is called,
-  /// the memory location referenced by the argument is uninitialized.
-  case indirectOut
-
-  /// This argument is passed directly.  Its type is non-trivial, and the callee
-  /// is responsible for destroying it.
-  case directOwned
-
-  /// This argument is passed directly.  Its type may be trivial, or it may
-  /// simply be that the callee is not responsible for destroying it. Its
-  /// validity is guaranteed only at the instant the call begins.
-  case directUnowned
-
-  /// This argument is passed directly.  Its type is non-trivial, and the caller
-  /// guarantees its validity for the entirety of the call.
-  case directGuaranteed
-}
-
 // Bridging utilities
 
 extension BridgedFunction {
@@ -269,21 +219,3 @@ extension BridgedFunction {
 extension OptionalBridgedFunction {
   public var function: Function? { obj.getAs(Function.self) }
 }
-
-extension BridgedArgumentConvention {
-  var convention: ArgumentConvention {
-    switch self {
-      case ArgumentConvention_Indirect_In:             return .indirectIn
-      case ArgumentConvention_Indirect_In_Constant:    return .indirectInConstant
-      case ArgumentConvention_Indirect_In_Guaranteed:  return .indirectInGuaranteed
-      case ArgumentConvention_Indirect_Inout:          return .indirectInout
-      case ArgumentConvention_Indirect_InoutAliasable: return .indirectInoutAliasable
-      case ArgumentConvention_Indirect_Out:            return .indirectOut
-      case ArgumentConvention_Direct_Owned:            return .directOwned
-      case ArgumentConvention_Direct_Unowned:          return .directUnowned
-      case ArgumentConvention_Direct_Guaranteed:       return .directGuaranteed
-      default:
-        fatalError("unsupported argument convention")
-    }
-  }
-}

include/swift/SIL/SILBridging.h

@@ -337,7 +337,7 @@ BridgedSubstitutionMap SubstitutionMap_getEmpty();
 BridgedLocation SILLocation_getAutogeneratedLocation();
 
 BridgedBasicBlock SILArgument_getParent(BridgedArgument argument);
-SwiftInt SILArgument_isExclusiveIndirectParameter(BridgedArgument argument);
+BridgedArgumentConvention SILArgument_getConvention(BridgedArgument argument);
 
 OptionalBridgedInstruction SILInstruction_next(BridgedInstruction inst);
 OptionalBridgedInstruction SILInstruction_previous(BridgedInstruction inst);

lib/SIL/Utils/SILBridging.cpp

@@ -327,9 +327,32 @@ BridgedBasicBlock SILArgument_getParent(BridgedArgument argument) {
   return {castToArgument(argument)->getParent()};
 }
 
-SwiftInt SILArgument_isExclusiveIndirectParameter(BridgedArgument argument) {
+static BridgedArgumentConvention bridgeArgumentConvention(SILArgumentConvention convention) {
+  switch (convention) {
+    case SILArgumentConvention::Indirect_Inout:
+      return ArgumentConvention_Indirect_Inout;
+    case SILArgumentConvention::Indirect_InoutAliasable:
+      return ArgumentConvention_Indirect_InoutAliasable;
+    case SILArgumentConvention::Indirect_In_Guaranteed:
+      return ArgumentConvention_Indirect_In_Guaranteed;
+    case SILArgumentConvention::Indirect_In:
+      return ArgumentConvention_Indirect_In;
+    case SILArgumentConvention::Indirect_In_Constant:
+      return ArgumentConvention_Indirect_In_Constant;
+    case SILArgumentConvention::Indirect_Out:
+      return ArgumentConvention_Indirect_Out;
+    case SILArgumentConvention::Direct_Unowned:
+      return ArgumentConvention_Direct_Unowned;
+    case SILArgumentConvention::Direct_Owned:
+      return ArgumentConvention_Direct_Owned;
+    case SILArgumentConvention::Direct_Guaranteed:
+      return ArgumentConvention_Direct_Guaranteed;
+  }
+}
+
+BridgedArgumentConvention SILArgument_getConvention(BridgedArgument argument) {
   auto *arg = castToArgument<SILFunctionArgument>(argument);
-  return arg->getArgumentConvention().isExclusiveIndirectParameter();
+  return bridgeArgumentConvention(arg->getArgumentConvention());
 }
 
 //===----------------------------------------------------------------------===//
@@ -914,26 +937,7 @@ BridgedArgumentConvention
 ApplySite_getArgumentConvention(BridgedInstruction inst, SwiftInt calleeArgIdx) {
   auto as = ApplySite(castToInst(inst));
   auto conv = as.getSubstCalleeConv().getSILArgumentConvention(calleeArgIdx);
-  switch (conv.Value) {
-    case SILArgumentConvention::Indirect_Inout:
-      return ArgumentConvention_Indirect_In;
-    case SILArgumentConvention::Indirect_InoutAliasable:
-      return ArgumentConvention_Indirect_In_Constant;
-    case SILArgumentConvention::Indirect_In_Guaranteed:
-      return ArgumentConvention_Indirect_In_Guaranteed;
-    case SILArgumentConvention::Indirect_In:
-      return ArgumentConvention_Indirect_Inout;
-    case SILArgumentConvention::Indirect_In_Constant:
-      return ArgumentConvention_Indirect_InoutAliasable;
-    case SILArgumentConvention::Indirect_Out:
-      return ArgumentConvention_Indirect_Out;
-    case SILArgumentConvention::Direct_Unowned:
-      return ArgumentConvention_Direct_Owned;
-    case SILArgumentConvention::Direct_Owned:
-      return ArgumentConvention_Direct_Unowned;
-    case SILArgumentConvention::Direct_Guaranteed:
-      return ArgumentConvention_Direct_Guaranteed;
-  }
+  return bridgeArgumentConvention(conv.Value);
 }
 
 SwiftInt ApplySite_getNumArguments(BridgedInstruction inst) {