Swift SIL: support ownership

* add the `Ownership` enum and the `Value.ownership` getter
* add `Function.hasOwnership`

Author: eeckstein

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -27,6 +27,8 @@ final public class Function : CustomStringConvertible, HasShortDescription {
 
   public var shortDescription: String { name.string }
 
+  public var hasOwnership: Bool { SILFunction_hasOwnership(bridged) != 0 }
+
   public var entryBlock: BasicBlock {
     SILFunction_firstBlock(bridged).block!
   }

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -16,9 +16,60 @@ import SILBridging
 public protocol Value : AnyObject, CustomStringConvertible {
   var uses: UseList { get }
   var type: Type { get }
+  var ownership: Ownership { get }
   var definingInstruction: Instruction? { get }
 }
 
+public enum Ownership {
+  /// A Value with `unowned` ownership kind is an independent value that
+  /// has a lifetime that is only guaranteed to last until the next program
+  /// visible side-effect. To maintain the lifetime of an unowned value, it
+  /// must be converted to an owned representation via a copy_value.
+  ///
+  /// Unowned ownership kind occurs mainly along method/function boundaries in
+  /// between Swift and Objective-C code.
+  case unowned
+  
+  /// A Value with `owned` ownership kind is an independent value that has
+  /// an ownership independent of any other ownership imbued within it. The
+  /// Value must be paired with a consuming operation that ends the SSA
+  /// value's lifetime exactly once along all paths through the program.
+  case owned
+  
+  /// A Value with `guaranteed` ownership kind is an independent value that
+  /// is guaranteed to be live over a specific region of the program. This
+  /// region can come in several forms:
+  ///
+  /// 1. @guaranteed function argument. This guarantees that a value will
+  /// outlive a function.
+  ///
+  /// 2. A shared borrow region. This is a region denoted by a
+  /// begin_borrow/load_borrow instruction and an end_borrow instruction. The
+  /// SSA value must not be destroyed or taken inside the borrowed region.
+  ///
+  /// Any value with guaranteed ownership must be paired with an end_borrow
+  /// instruction exactly once along any path through the program.
+  case guaranteed
+  
+  /// A Value with `none` ownership kind is an independent value outside of
+  /// the ownership system. It is used to model values that are statically
+  /// determined to be trivial. This includes trivially typed values as well
+  /// as trivial cases of non-trivial enums. Naturally `none` can be merged with
+  /// any ownership, allowing us to naturally model merge and branch
+  /// points in the SSA graph, where more information about the value is
+  /// statically available on some control flow paths.
+  case none
+  
+  public var _bridged: BridgedOwnership {
+    switch self {
+      case .unowned:    return Ownership_Unowned
+      case .owned:      return Ownership_Owned
+      case .guaranteed: return Ownership_Guaranteed
+      case .none:       return Ownership_None
+    }
+  }
+}
+
 extension Value {
   public var description: String {
     var s = SILNode_debugDescription(bridgedNode)
@@ -55,6 +106,7 @@ extension Value {
     }
     return nil
   }
+  public var ownership: Ownership { SILValue_getOwnership(bridged).ownership }
 
   public var hashable: HashableValue { ObjectIdentifier(self) }
 
@@ -111,3 +163,16 @@ final class PlaceholderValue : Value {
 extension OptionalBridgedValue {
   var value: Value? { obj.getAs(AnyObject.self) as? Value }
 }
+
+extension BridgedOwnership {
+  var ownership: Ownership {
+    switch self {
+      case Ownership_Unowned:    return .unowned
+      case Ownership_Owned:      return .owned
+      case Ownership_Guaranteed: return .guaranteed
+      case Ownership_None:       return .none
+      default:
+        fatalError("unsupported ownership")
+    }
+  }
+}

include/swift/SIL/SILBridging.h

@@ -134,6 +134,13 @@ typedef enum {
   MayHaveSideEffectsBehavior
 } BridgedMemoryBehavior;
 
+typedef enum {
+  Ownership_Unowned,
+  Ownership_Owned,
+  Ownership_Guaranteed,
+  Ownership_None
+} BridgedOwnership;
+
 // AST bridging
 
 typedef struct {
@@ -179,6 +186,7 @@ void PassContext_eraseInstruction(BridgedPassContext passContext,
 
 BridgedStringRef SILFunction_getName(BridgedFunction function);
 std::string SILFunction_debugDescription(BridgedFunction function);
+SwiftInt SILFunction_hasOwnership(BridgedFunction function);
 OptionalBridgedBasicBlock SILFunction_firstBlock(BridgedFunction function);
 OptionalBridgedBasicBlock SILFunction_lastBlock(BridgedFunction function);
 SwiftInt SILFunction_numIndirectResultArguments(BridgedFunction function);
@@ -213,6 +221,7 @@ std::string SILNode_debugDescription(BridgedNode node);
 BridgedFunction SILNode_getFunction(BridgedNode node);
 OptionalBridgedOperand SILValue_firstUse(BridgedValue value);
 BridgedType SILValue_getType(BridgedValue value);
+BridgedOwnership SILValue_getOwnership(BridgedValue value);
 
 BridgedStringRef SILType_debugDescription(BridgedType);
 SwiftInt SILType_isAddress(BridgedType);

include/swift/SIL/SILBridgingUtils.h

@@ -80,6 +80,15 @@ inline SILGlobalVariable *castToGlobal(BridgedGlobalVar global) {
   return static_cast<SILGlobalVariable *>(global.obj);
 }
 
+inline ValueOwnershipKind castToOwnership(BridgedOwnership ownership) {
+  switch (ownership) {
+    case Ownership_Unowned:    return OwnershipKind::Unowned;
+    case Ownership_Owned:      return OwnershipKind::Owned;
+    case Ownership_Guaranteed: return OwnershipKind::Guaranteed;
+    case Ownership_None:       return OwnershipKind::None;
+  }
+}
+
 ArrayRef<SILValue> getSILValues(BridgedValueArray values,
                                 SmallVectorImpl<SILValue> &storage);
 

lib/SIL/Utils/SILBridging.cpp

@@ -158,6 +158,10 @@ std::string SILFunction_debugDescription(BridgedFunction function) {
   return str;
 }
 
+SwiftInt SILFunction_hasOwnership(BridgedFunction function) {
+  return castToFunction(function)->hasOwnership() ? 1 : 0;
+}
+
 OptionalBridgedBasicBlock SILFunction_firstBlock(BridgedFunction function) {
   SILFunction *f = castToFunction(function);
   if (f->empty())
@@ -351,6 +355,17 @@ BridgedType SILValue_getType(BridgedValue value) {
   return { castToSILValue(value)->getType().getOpaqueValue() };
 }
 
+BridgedOwnership SILValue_getOwnership(BridgedValue value) {
+  switch (castToSILValue(value)->getOwnershipKind()) {
+    case OwnershipKind::Any:
+      llvm_unreachable("Invalid ownership for value");
+    case OwnershipKind::Unowned:    return Ownership_Unowned;
+    case OwnershipKind::Owned:      return Ownership_Owned;
+    case OwnershipKind::Guaranteed: return Ownership_Guaranteed;
+    case OwnershipKind::None:       return Ownership_None;
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                            SILType
 //===----------------------------------------------------------------------===//