Swift SIL: add ApplySite.substitutionMap and ApplySite.getArgumentConvention()

Author: eeckstein

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -10,16 +10,20 @@
 //
 //===----------------------------------------------------------------------===//
 
+import SILBridging
+
 public struct ApplyOperands {
   public static let calleeOperandIndex: Int = 0
   public static let firstArgumentIndex = 1
 }
 
-public protocol ApplySite : AnyObject {
+public protocol ApplySite : Instruction {
   var operands: OperandArray { get }
   var numArguments: Int { get }
+  var substitutionMap: SubstitutionMap { get }
   func calleeArgIndex(callerArgIndex: Int) -> Int
   func callerArgIndex(calleeArgIndex: Int) -> Int?
+  func getArgumentConvention(calleeArgIndex: Int) -> ArgumentConvention
 }
 
 extension ApplySite {
@@ -29,6 +33,10 @@ extension ApplySite {
     operands[1..<operands.count].lazy.map { $0.value }
   }
 
+  public var substitutionMap: SubstitutionMap {
+    SubstitutionMap(ApplySite_getSubstitutionMap(bridged))
+  }
+
   public func argumentIndex(of operand: Operand) -> Int? {
     let opIdx = operand.index
     if opIdx >= ApplyOperands.firstArgumentIndex &&
@@ -38,6 +46,10 @@ extension ApplySite {
     return nil
   }
 
+  public func getArgumentConvention(calleeArgIndex: Int) -> ArgumentConvention {
+    return ApplySite_getArgumentConvention(bridged, calleeArgIndex).convention
+  }
+  
   public var referencedFunction: Function? {
     if let fri = callee as? FunctionRefInst {
       return fri.referencedFunction

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -185,6 +185,56 @@ 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 {
@@ -194,3 +244,21 @@ 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

@@ -147,6 +147,18 @@ typedef enum {
   Ownership_None
 } BridgedOwnership;
 
+typedef enum {
+  ArgumentConvention_Indirect_In,
+  ArgumentConvention_Indirect_In_Constant,
+  ArgumentConvention_Indirect_In_Guaranteed,
+  ArgumentConvention_Indirect_Inout,
+  ArgumentConvention_Indirect_InoutAliasable,
+  ArgumentConvention_Indirect_Out,
+  ArgumentConvention_Direct_Owned,
+  ArgumentConvention_Direct_Unowned,
+  ArgumentConvention_Direct_Guaranteed,
+} BridgedArgumentConvention;
+
 // AST bridging
 
 typedef struct {
@@ -313,6 +325,10 @@ void RefCountingInst_setIsAtomic(BridgedInstruction rc, bool isAtomic);
 bool RefCountingInst_getIsAtomic(BridgedInstruction rc);
 SwiftInt CondBranchInst_getNumTrueArgs(BridgedInstruction cbr);
 
+BridgedSubstitutionMap ApplySite_getSubstitutionMap(BridgedInstruction inst);
+BridgedArgumentConvention
+ApplySite_getArgumentConvention(BridgedInstruction inst, SwiftInt calleeArgIdx);
+
 BridgedInstruction SILBuilder_createBuiltinBinaryFunction(
           BridgedBuilder builder, BridgedStringRef name,
           BridgedType operandType, BridgedType resultType,

lib/SIL/Utils/SILBridging.cpp

@@ -746,6 +746,37 @@ SwiftInt CondBranchInst_getNumTrueArgs(BridgedInstruction cbr) {
   return castToInst<CondBranchInst>(cbr)->getNumTrueArgs();
 }
 
+BridgedSubstitutionMap ApplySite_getSubstitutionMap(BridgedInstruction inst) {
+  auto as = ApplySite(castToInst(inst));
+  return {as.getSubstitutionMap().getOpaqueValue()};
+}
+
+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;
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                                SILBuilder
 //===----------------------------------------------------------------------===//