Add some Swift SIL infrastructure

* In `ApplySite`: `argumentOperands` and `isCalleeOperand`
* In `ArgumentConvention`: `isIndirect`, `isIndirectIn` and `isGuaranteed`
* In `Function`: `isDefinition`, `numParameterArguments`, `numArguments`, `getArgumentConvention`, `effectAttribute`
* In `Type`: `isFunction` and `isCalleeConsumedFunction`
* In `Instruction`: `hasUnspecifiedSideEffects`
* New bridged instructions: `EndApplyInst` and `AbortApplyInst`
* `LoadInst.ownership`
* `BeginAccessInst.isStatic`
* make the `Allocation` protocol a `SingleValueInstruction` (instead of `AnyObject`)

Author: eeckstein

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -67,17 +67,30 @@ public protocol ApplySite : Instruction {
 extension ApplySite {
   public var callee: Value { operands[ApplyOperands.calleeOperandIndex].value }
 
-  public var arguments: LazyMapSequence<OperandArray, Value> {
+  /// Returns the subset of operands which are argument operands.
+  ///
+  /// This does not include the callee function operand.
+  public var argumentOperands: OperandArray {
     let numArgs = ApplySite_getNumArguments(bridged)
     let offset = ApplyOperands.firstArgumentIndex
-    let argOps = operands[offset..<(numArgs + offset)]
-    return argOps.lazy.map { $0.value }
+    return operands[offset..<(numArgs + offset)]
+  }
+
+  /// Returns the subset of operand values which are arguments.
+  ///
+  /// This does not include the callee function operand.
+  public var arguments: LazyMapSequence<OperandArray, Value> {
+    argumentOperands.lazy.map { $0.value }
   }
 
   public var substitutionMap: SubstitutionMap {
     SubstitutionMap(ApplySite_getSubstitutionMap(bridged))
   }
 
+  /// Returns the argument index of an operand.
+  ///
+  /// Returns nil if 'operand' is not an argument operand. This is the case if
+  /// it's the callee function operand.
   public func argumentIndex(of operand: Operand) -> Int? {
     let opIdx = operand.index
     if opIdx >= ApplyOperands.firstArgumentIndex &&
@@ -87,6 +100,11 @@ extension ApplySite {
     return nil
   }
 
+  /// Returns true if `operand` is the callee function operand and not am argument operand.
+  public func isCalleeOperand(_ operand: Operand) -> Bool {
+    return operand.index < ApplyOperands.firstArgumentIndex
+  }
+  
   public func getArgumentConvention(calleeArgIndex: Int) -> ArgumentConvention {
     return ApplySite_getArgumentConvention(bridged, calleeArgIndex).convention
   }

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -128,6 +128,36 @@ public enum ArgumentConvention {
   /// guarantees its validity for the entirety of the call.
   case directGuaranteed
 
+  public var isIndirect: Bool {
+    switch self {
+    case .indirectIn, .indirectInConstant, .indirectInGuaranteed,
+         .indirectInout, .indirectInoutAliasable, .indirectOut:
+      return true
+    case .directOwned, .directUnowned, .directGuaranteed:
+      return false
+    }
+  }
+
+  public var isIndirectIn: Bool {
+    switch self {
+    case .indirectIn, .indirectInConstant, .indirectInGuaranteed:
+      return true
+    case .directOwned, .directUnowned, .directGuaranteed,
+         .indirectInout, .indirectInoutAliasable, .indirectOut:
+      return false
+    }
+  }
+
+  public var isGuaranteed: Bool {
+    switch self {
+    case .indirectInGuaranteed, .directGuaranteed:
+      return true
+    case .indirectIn, .indirectInConstant, .directOwned, .directUnowned,
+         .indirectInout, .indirectInoutAliasable, .indirectOut:
+      return false
+    }
+  }
+
   public var isExclusiveIndirect: Bool {
     switch self {
     case .indirectIn,

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -33,6 +33,11 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
 
   public var hasOwnership: Bool { SILFunction_hasOwnership(bridged) != 0 }
 
+  /// Returns true if the function is a definition and not only an external declaration.
+  ///
+  /// This is the case if the functioun contains a body, i.e. some basic blocks.
+  public var isDefinition: Bool { blocks.first != nil }
+
   public var entryBlock: BasicBlock {
     SILFunction_firstBlock(bridged).block!
   }
@@ -50,9 +55,22 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     blocks.lazy.flatMap { $0.instructions }
   }
 
+  /// The number of indirect result arguments.
   public var numIndirectResultArguments: Int {
     SILFunction_numIndirectResultArguments(bridged)
   }
+  
+  /// The number of arguments which correspond to parameters (and not to indirect results).
+  public var numParameterArguments: Int {
+    SILFunction_numParameterArguments(bridged)
+  }
+
+  /// The total number of arguments.
+  ///
+  /// This is the sum of indirect result arguments and parameter arguments.
+  /// If the function is a definition (i.e. it has at least an entry block), this is the
+  /// number of arguments of the function's entry block.
+  public var numArguments: Int { numIndirectResultArguments + numParameterArguments }
 
   public var hasSelfArgument: Bool {
     SILFunction_getSelfArgumentIndex(bridged) >= 0
@@ -67,6 +85,13 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   public var argumentTypes: ArgumentTypeArray { ArgumentTypeArray(function: self) }
   public var resultType: Type { SILFunction_getSILResultType(bridged).type }
 
+  public func getArgumentConvention(for argumentIndex: Int) -> ArgumentConvention {
+    if argumentIndex < numIndirectResultArguments {
+      return .indirectOut
+    }
+    return SILFunction_getSILArgumentConvention(bridged, argumentIndex).convention
+  }
+
   public var returnInstruction: ReturnInst? {
     for block in blocks.reversed() {
       if let retInst = block.terminator as? ReturnInst { return retInst }
@@ -96,6 +121,60 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     }
   }
 
+  /// Kinds of effect attributes which can be defined for a Swift function.
+  public enum EffectAttribute {
+    /// No effect attribute is specified.
+    case none
+    
+    /// `[readnone]`
+    ///
+    /// A readnone function does not have any observable memory read or write operations.
+    /// This does not mean that the function cannot read or write at all. For example,
+    /// it’s allowed to allocate and write to local objects inside the function.
+    ///
+    /// A function can be marked as readnone if two calls of the same function with the
+    /// same parameters can be simplified to one call (e.g. by the CSE optimization).
+    /// Some conclusions:
+    /// * A readnone function must not return a newly allocated class instance.
+    /// * A readnone function can return a newly allocated copy-on-write object,
+    ///   like an Array, because COW data types conceptually behave like value types.
+    /// * A readnone function must not release any parameter or any object indirectly
+    ///   referenced from a parameter.
+    /// * Any kind of observable side-effects are not allowed, like `print`, file IO, etc.
+    case readNone
+    
+    /// `[readonly]`
+    ///
+    /// A readonly function does not have any observable memory write operations.
+    /// Similar to readnone, a readonly function is allowed to contain writes to e.g. local objects, etc.
+    ///
+    /// A function can be marked as readonly if it’s save to eliminate a call to such
+    /// a function if its return value is not used.
+    /// The same conclusions as for readnone also apply to readonly.
+    case readOnly
+    
+    /// `[releasenone]`
+    ///
+    /// A releasenone function must not perform any observable release-operation on an object.
+    /// This means, it must not do anything which might let the caller observe any decrement of
+    /// a reference count or any deallocations.
+    /// Note that it's allowed to release an object if the release is balancing a retain in the
+    /// same function. Also, it's allowed to release (and deallocate) local objects which were
+    /// allocated in the same function.
+    case releaseNone
+  }
+
+  /// The effect attribute which is specified in the source code (if any).
+  public var effectAttribute: EffectAttribute {
+    switch SILFunction_getEffectAttribute(bridged) {
+      case EffectKind_none: return .none
+      case EffectKind_readNone: return .readNone
+      case EffectKind_readOnly: return .readOnly
+      case EffectKind_releaseNone: return .releaseNone
+      default: fatalError()
+    }
+  }
+
   /// True, if the function runs with a swift 5.1 runtime.
   /// Note that this is function specific, because inlinable functions are de-serialized
   /// in a client module, which might be compiled with a different deployment target.

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -104,6 +104,10 @@ public class Instruction : ListNode, CustomStringConvertible, Hashable {
     return SILInstruction_mayRelease(bridged)
   }
 
+  public final var hasUnspecifiedSideEffects: Bool {
+    return SILInstruction_hasUnspecifiedSideEffects(bridged)
+  }
+
   public func visitReferencedFunctions(_ cl: (Function) -> ()) {
   }
 
@@ -273,6 +277,9 @@ final public class UnconditionalCheckedCastAddrInst : Instruction {
   public override var mayTrap: Bool { true }
 }
 
+final public class EndApplyInst : Instruction, UnaryInstruction {}
+final public class AbortApplyInst : Instruction, UnaryInstruction {}
+
 final public class SetDeallocatingInst : Instruction, UnaryInstruction {}
 
 final public class DeallocRefInst : Instruction, UnaryInstruction {}
@@ -312,7 +319,15 @@ final public class UnimplementedRefCountingInst : RefCountingInst {}
 final public class UnimplementedSingleValueInst : SingleValueInstruction {
 }
 
-final public class LoadInst : SingleValueInstruction, UnaryInstruction {}
+final public class LoadInst : SingleValueInstruction, UnaryInstruction {
+  // must match with enum class LoadOwnershipQualifier
+  public enum LoadOwnership: Int {
+    case unqualified = 0, take = 1, copy = 2, trivial = 3
+  }
+  public var ownership: LoadOwnership {
+    LoadOwnership(rawValue: LoadInst_getLoadOwnership(bridged))!
+  }
+}
 
 final public class LoadWeakInst : SingleValueInstruction, UnaryInstruction {}
 final public class LoadUnownedInst : SingleValueInstruction, UnaryInstruction {}
@@ -570,11 +585,20 @@ extension BridgedAccessKind {
 // TODO: add support for begin_unpaired_access
 final public class BeginAccessInst : SingleValueInstruction, UnaryInstruction {
   public var accessKind: AccessKind { BeginAccessInst_getAccessKind(bridged).kind }
+
+  public var isStatic: Bool { BeginAccessInst_isStatic(bridged) != 0 }
 }
 
+// An instruction that is always paired with a scope ending instruction
+// such as `begin_access` (ending with `end_access`) and `alloc_stack`
+// (ending with `dealloc_stack`).
 public protocol ScopedInstruction {
+  // The type of the ending instructions (while `IteratorProtocol` would be
+  // ideal, for performance reasons we allow the user to specify any type as return)
   associatedtype EndInstructions
 
+  // The instructions that end the scope of the instruction denoted
+  // by `self`.
   var endInstructions: EndInstructions { get }
 }
 
@@ -646,7 +670,7 @@ class MarkMustCheckInst : SingleValueInstruction, UnaryInstruction {}
 //                      single-value allocation instructions
 //===----------------------------------------------------------------------===//
 
-public protocol Allocation : AnyObject { }
+public protocol Allocation : SingleValueInstruction { }
 
 final public class AllocStackInst : SingleValueInstruction, Allocation {
 }

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -51,6 +51,8 @@ public func registerSILClasses() {
   register(DebugValueInst.self)
   register(UnconditionalCheckedCastAddrInst.self)
   register(SetDeallocatingInst.self)
+  register(EndApplyInst.self)
+  register(AbortApplyInst.self)
   register(DeallocRefInst.self)
   register(StrongRetainInst.self)
   register(RetainValueInst.self)

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -36,13 +36,16 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   public var isStruct: Bool { SILType_isStruct(bridged) != 0 }
   public var isTuple: Bool { SILType_isTuple(bridged) != 0 }
   public var isEnum: Bool { SILType_isEnum(bridged) != 0 }
+  public var isFunction: Bool { SILType_isFunction(bridged) }
 
   public var tupleElements: TupleElementArray { TupleElementArray(type: self) }
 
   public func getNominalFields(in function: Function) -> NominalFieldsArray {
     NominalFieldsArray(type: self, function: function)
   }
 
+  public var isCalleeConsumedFunction: Bool { SILType_isCalleeConsumedFunction(bridged) }
+  
   public func getIndexOfEnumCase(withName name: String) -> Int? {
     let idx = name._withStringRef {
       SILType_getCaseIdxOfEnumType(bridged, $0)

include/swift/SIL/SILBridging.h

@@ -175,6 +175,13 @@ typedef enum {
   MayHaveSideEffectsBehavior
 } BridgedMemoryBehavior;
 
+typedef enum {
+  EffectKind_none,
+  EffectKind_readNone,
+  EffectKind_readOnly,
+  EffectKind_releaseNone,
+} BridgedEffectAttributeKind;
+
 typedef enum {
   AccessKind_Init,
   AccessKind_Read,
@@ -249,15 +256,18 @@ SwiftInt SILFunction_hasOwnership(BridgedFunction function);
 OptionalBridgedBasicBlock SILFunction_firstBlock(BridgedFunction function);
 OptionalBridgedBasicBlock SILFunction_lastBlock(BridgedFunction function);
 SwiftInt SILFunction_numIndirectResultArguments(BridgedFunction function);
+SwiftInt SILFunction_numParameterArguments(BridgedFunction function);
 SwiftInt SILFunction_getSelfArgumentIndex(BridgedFunction function);
 SwiftInt SILFunction_getNumSILArguments(BridgedFunction function);
 BridgedType SILFunction_getSILArgumentType(BridgedFunction function, SwiftInt idx);
+BridgedArgumentConvention SILFunction_getSILArgumentConvention(BridgedFunction function, SwiftInt idx);
 BridgedType SILFunction_getSILResultType(BridgedFunction function);
 SwiftInt SILFunction_isSwift51RuntimeAvailable(BridgedFunction function);
 SwiftInt SILFunction_isPossiblyUsedExternally(BridgedFunction function);
 SwiftInt SILFunction_isAvailableExternally(BridgedFunction function);
 SwiftInt SILFunction_hasSemanticsAttr(BridgedFunction function,
                                       llvm::StringRef attrName);
+BridgedEffectAttributeKind SILFunction_getEffectAttribute(BridgedFunction function);
 SwiftInt SILFunction_needsStackProtection(BridgedFunction function);
 void SILFunction_setNeedStackProtection(BridgedFunction function,
                                         SwiftInt needSP);
@@ -316,6 +326,8 @@ SwiftInt SILType_isClass(BridgedType type);
 SwiftInt SILType_isStruct(BridgedType type);
 SwiftInt SILType_isTuple(BridgedType type);
 SwiftInt SILType_isEnum(BridgedType type);
+bool SILType_isFunction(BridgedType type);
+bool SILType_isCalleeConsumedFunction(BridgedType type);
 SwiftInt SILType_getNumTupleElements(BridgedType type);
 BridgedType SILType_getTupleElementType(BridgedType type, SwiftInt elementIdx);
 SwiftInt SILType_getNumNominalFields(BridgedType type);
@@ -342,6 +354,7 @@ void SILInstruction_setOperand(BridgedInstruction inst, SwiftInt index,
 swift::SILDebugLocation SILInstruction_getLocation(BridgedInstruction inst);
 BridgedMemoryBehavior SILInstruction_getMemBehavior(BridgedInstruction inst);
 bool SILInstruction_mayRelease(BridgedInstruction inst);
+bool SILInstruction_hasUnspecifiedSideEffects(BridgedInstruction inst);
 
 BridgedInstruction MultiValueInstResult_getParent(BridgedMultiValueResult result);
 SwiftInt MultiValueInstResult_getIndex(BridgedMultiValueResult result);
@@ -352,6 +365,7 @@ BridgedMultiValueResult
 BridgedArrayRef TermInst_getSuccessors(BridgedInstruction term);
 
 llvm::StringRef CondFailInst_getMessage(BridgedInstruction cfi);
+SwiftInt LoadInst_getLoadOwnership(BridgedInstruction load);
 BridgedBuiltinID BuiltinInst_getID(BridgedInstruction bi);
 SwiftInt AddressToPointerInst_needsStackProtection(BridgedInstruction atp);
 SwiftInt IndexAddrInst_needsStackProtection(BridgedInstruction ia);
@@ -384,6 +398,7 @@ SwiftInt SwitchEnumInst_getNumCases(BridgedInstruction se);
 SwiftInt SwitchEnumInst_getCaseIndex(BridgedInstruction se, SwiftInt idx);
 SwiftInt StoreInst_getStoreOwnership(BridgedInstruction store);
 BridgedAccessKind BeginAccessInst_getAccessKind(BridgedInstruction beginAccess);
+SwiftInt BeginAccessInst_isStatic(BridgedInstruction beginAccess);
 SwiftInt CopyAddrInst_isTakeOfSrc(BridgedInstruction copyAddr);
 SwiftInt CopyAddrInst_isInitializationOfDest(BridgedInstruction copyAddr);
 void RefCountingInst_setIsAtomic(BridgedInstruction rc, bool isAtomic);