[SIL] Added unowned_copy_value.

Author: nate-chandler

docs/SIL.rst

@@ -5285,8 +5285,8 @@ positive.  Otherwise, traps.
 
 This operation must be atomic with respect to the final ``strong_release`` on
 the operand (source) heap object.  It need not be atomic with respect to
-``store_unowned`` or ``load_unowned``/``strong_copy_unowned_value`` operations
-on the same address.
+``store_unowned``/``unowned_copy_value`` or
+``load_unowned``/``strong_copy_unowned_value`` operations on the same address.
 
 store_unowned
 `````````````
@@ -5306,9 +5306,30 @@ The storage must be initialized iff ``[init]`` is not specified.
 
 This operation must be atomic with respect to the final ``strong_release`` on
 the operand (source) heap object.  It need not be atomic with respect to
-``store_unowned`` or ``load_unowned``/``strong_copy_unowned_value`` operations
-on the same address.
+``store_unowned``/``unowned_copy_value`` or
+``load_unowned``/``strong_copy_unowned_value`` operations on the same address.
 
+unowned_copy_value
+``````````````````
+::
+
+  sil-instruction ::= 'unowned_copy_value' sil-operand
+
+  %1 = unowned_copy_value %0 : $T
+  // %1 will be an @owned value of type $@sil_unowned T.
+  // $T must be a reference type
+  // $@sil_unowned T must be address-only
+
+Only valid in opaque values mode.  Lowered by AddressLowering to store_unowned.
+
+Increments the unowned reference count of the object at ``%0``.
+
+Wraps the operand in an instance of ``@sil_unowned``.
+
+This operation must be atomic with respect to the final ``strong_release`` on
+the operand (source) heap object.  It need not be atomic with respect to
+``store_unowned``/``unowned_copy_value`` or
+``load_unowned``/``strong_copy_unowned_value`` operations on the same address.
 
 fix_lifetime
 ````````````

include/swift/SIL/SILBuilder.h

@@ -1061,6 +1061,17 @@ class SILBuilder {
         getSILDebugLocation(Loc), ArgumentsSpecification, getModule()));
   }
 
+  UnownedCopyValueInst *createUnownedCopyValue(SILLocation Loc,
+                                               SILValue operand) {
+    assert(!getFunction().getModule().useLoweredAddresses());
+    auto type = operand->getType()
+                    .getReferenceStorageType(getFunction().getASTContext(),
+                                             ReferenceOwnership::Unowned)
+                    .getObjectType();
+    return insert(new (getModule()) UnownedCopyValueInst(
+        getSILDebugLocation(Loc), operand, type));
+  }
+
   WeakCopyValueInst *createWeakCopyValue(SILLocation Loc, SILValue operand) {
     assert(!getFunction().getModule().useLoweredAddresses());
     auto type = operand->getType()

include/swift/SIL/SILCloner.h

@@ -1407,6 +1407,15 @@ SILCloner<ImplClass>::visitDebugStepInst(DebugStepInst *Inst) {
   recordClonedInstruction(Inst, getBuilder().createDebugStep(Inst->getLoc()));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitUnownedCopyValueInst(
+    UnownedCopyValueInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst, getBuilder().createUnownedCopyValue(
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand())));
+}
+
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitWeakCopyValueInst(WeakCopyValueInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));

include/swift/SIL/SILInstruction.h

@@ -8109,6 +8109,18 @@ class WeakCopyValueInst
   }
 };
 
+class UnownedCopyValueInst
+    : public UnaryInstructionBase<SILInstructionKind::UnownedCopyValueInst,
+                                  SingleValueInstruction> {
+  friend class SILBuilder;
+  UnownedCopyValueInst(SILDebugLocation DebugLoc, SILValue operand,
+                       SILType type)
+      : UnaryInstructionBase(DebugLoc, operand, type) {
+    assert(type.getReferenceStorageOwnership() == ReferenceOwnership::Unowned);
+    assert(type.getReferenceStorageReferentType() == operand->getType());
+  }
+};
+
 #define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, ...)                          \
   class StrongCopy##Name##ValueInst                                            \
       : public UnaryInstructionBase<                                           \

include/swift/SIL/SILNodes.def

@@ -453,6 +453,9 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   // alone by OSSA optimizations.
   SINGLE_VALUE_INST(ExplicitCopyValueInst, explicit_copy_value,
                     SingleValueInstruction, None, DoesNotRelease)
+  // Produce a @sil_unowned value from the specified value of reference type.
+  SINGLE_VALUE_INST(UnownedCopyValueInst, unowned_copy_value,
+                    SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
   SINGLE_VALUE_INST(WeakCopyValueInst, weak_copy_value,
                     SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
 #define REF_STORAGE(Name, name, ...) \

lib/IRGen/IRGenSIL.cpp

@@ -1504,6 +1504,7 @@ class IRGenSILFunction :
   void visitHasSymbolInst(HasSymbolInst *i);
 
   void visitWeakCopyValueInst(swift::WeakCopyValueInst *i);
+  void visitUnownedCopyValueInst(swift::UnownedCopyValueInst *i);
 #define LOADABLE_REF_STORAGE_HELPER(Name)                                      \
   void visitRefTo##Name##Inst(RefTo##Name##Inst *i);                           \
   void visit##Name##ToRefInst(Name##ToRefInst *i);
@@ -5361,6 +5362,12 @@ void IRGenSILFunction::visitWeakCopyValueInst(swift::WeakCopyValueInst *i) {
   llvm::report_fatal_error("weak_copy_value not lowered by AddressLowering!?");
 }
 
+void IRGenSILFunction::visitUnownedCopyValueInst(
+    swift::UnownedCopyValueInst *i) {
+  llvm::report_fatal_error(
+      "unowned_copy_value not lowered by AddressLowering!?");
+}
+
 #define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \
   void IRGenSILFunction::visitLoad##Name##Inst(swift::Load##Name##Inst *i) { \
     Address source = getLoweredAddress(i->getOperand()); \

lib/SIL/IR/OperandOwnership.cpp

@@ -220,6 +220,7 @@ OPERAND_OWNERSHIP(InstantaneousUse, ClassMethod)
 OPERAND_OWNERSHIP(InstantaneousUse, SuperMethod)
 OPERAND_OWNERSHIP(InstantaneousUse, ClassifyBridgeObject)
 OPERAND_OWNERSHIP(InstantaneousUse, SetDeallocating)
+OPERAND_OWNERSHIP(InstantaneousUse, UnownedCopyValue)
 OPERAND_OWNERSHIP(InstantaneousUse, WeakCopyValue)
 #define REF_STORAGE(Name, ...)                                                 \
   OPERAND_OWNERSHIP(InstantaneousUse, StrongCopy##Name##Value)

lib/SIL/IR/SILPrinter.cpp

@@ -2141,6 +2141,10 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << getIDAndType(I->getOperand());
   }
 
+  void visitUnownedCopyValueInst(UnownedCopyValueInst *I) {
+    *this << getIDAndType(I->getOperand());
+  }
+
   void visitWeakCopyValueInst(WeakCopyValueInst *I) {
     *this << getIDAndType(I->getOperand());
   }

lib/SIL/IR/ValueOwnership.cpp

@@ -49,6 +49,7 @@ class ValueOwnershipKindClassifier
     return OwnershipKind::OWNERSHIP;                                           \
   }
 
+CONSTANT_OWNERSHIP_INST(Owned, UnownedCopyValue)
 CONSTANT_OWNERSHIP_INST(Owned, WeakCopyValue)
 #define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, ...)                          \
   CONSTANT_OWNERSHIP_INST(Owned, StrongCopy##Name##Value)                      \

lib/SIL/Parser/ParseSIL.cpp

@@ -3646,6 +3646,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     REFCOUNTING_INSTRUCTION(RetainValue)
     REFCOUNTING_INSTRUCTION(ReleaseValueAddr)
     REFCOUNTING_INSTRUCTION(RetainValueAddr)
+    UNARY_INSTRUCTION(UnownedCopyValue)
     UNARY_INSTRUCTION(WeakCopyValue)
 #define UNCHECKED_REF_STORAGE(Name, ...)                                       \
   UNARY_INSTRUCTION(StrongCopy##Name##Value)

lib/SIL/Utils/InstructionUtils.cpp

@@ -848,6 +848,7 @@ RuntimeEffect swift::getRuntimeEffect(SILInstruction *inst, SILType &impactType)
 #include "swift/AST/ReferenceStorage.def"
 #undef ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
 
+  case SILInstructionKind::UnownedCopyValueInst:
   case SILInstructionKind::WeakCopyValueInst:
     return RuntimeEffect::RefCounting;
 #define REF_STORAGE(Name, ...)                                                 \

lib/SIL/Verifier/SILVerifier.cpp

@@ -2983,6 +2983,13 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             "'MoveOnly' types can only be copied in Raw SIL?!");
   }
 
+  void checkUnownedCopyValueInst(UnownedCopyValueInst *I) {
+    require(!F.getModule().useLoweredAddresses(),
+            "unowned_copy_value is only valid in opaque values");
+    require(I->getType().isAddressOnly(F),
+            "unowned_copy_value must produce an address-only value");
+  }
+
   void checkWeakCopyValueInst(WeakCopyValueInst *I) {
     require(!F.getModule().useLoweredAddresses(),
             "weak_copy_value is only valid in opaque values");

lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp

@@ -210,6 +210,7 @@ static bool hasOpaqueArchetype(TypeExpansionContext context,
   case SILInstructionKind::MarkUnresolvedReferenceBindingInst:
   case SILInstructionKind::CopyableToMoveOnlyWrapperValueInst:
   case SILInstructionKind::MoveOnlyWrapperToCopyableValueInst:
+  case SILInstructionKind::UnownedCopyValueInst:
   case SILInstructionKind::WeakCopyValueInst:
 #define REF_STORAGE(Name, ...)                                                 \
   case SILInstructionKind::StrongCopy##Name##ValueInst:

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -1122,6 +1122,7 @@ InlineCost swift::instructionInlineCost(SILInstruction &I) {
   case SILInstructionKind::HopToExecutorInst:
   case SILInstructionKind::ExtractExecutorInst:
   case SILInstructionKind::HasSymbolInst:
+  case SILInstructionKind::UnownedCopyValueInst:
   case SILInstructionKind::WeakCopyValueInst:
 #define COMMON_ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name)          \
   case SILInstructionKind::Name##ToRefInst:                                    \

lib/Serialization/DeserializeSIL.cpp

@@ -2082,6 +2082,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
         (Atomicity)Attr);                                                      \
     break;
 
+    UNARY_INSTRUCTION(UnownedCopyValue)
     UNARY_INSTRUCTION(WeakCopyValue)
 #define UNCHECKED_REF_STORAGE(Name, ...)                                       \
   UNARY_INSTRUCTION(StrongCopy##Name##Value)

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 799; // added weak_copy_value
+const uint16_t SWIFTMODULE_VERSION_MINOR = 800; // added unowned_copy_value
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

lib/Serialization/SerializeSIL.cpp

@@ -1442,6 +1442,7 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
         ListOfValues);
     break;
   }
+  case SILInstructionKind::UnownedCopyValueInst:
   case SILInstructionKind::WeakCopyValueInst:
 #define UNCHECKED_REF_STORAGE(Name, ...)                                       \
   case SILInstructionKind::StrongCopy##Name##ValueInst:

test/SIL/Parser/opaque_values_parse_objc.sil

@@ -0,0 +1,22 @@
+// RUN: %target-sil-opt -enable-sil-opaque-values -enable-sil-verify-all -emit-sorted-sil %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Builtin
+import Swift
+
+struct UnownedBox<T : AnyObject> {
+  unowned var value: T
+}
+
+// CHECK-LABEL: sil [ossa] @test_unowned_copy_value : {{.*}} {
+// CHECK:       bb0([[VALUE:%[^,]+]] :
+// CHECK:         unowned_copy_value [[VALUE]]
+// CHECK-LABEL: } // end sil function 'test_unowned_copy_value'
+sil [ossa] @test_unowned_copy_value : $@convention(thin) <T where T : AnyObject> (@owned T) -> @out UnownedBox<T> {
+bb0(%owned_value : @owned $T):
+  %unowned_value = unowned_copy_value %owned_value : $T
+  destroy_value %owned_value : $T
+  %instance = struct $UnownedBox<T> (%unowned_value : $@sil_unowned T)
+  return %instance : $UnownedBox<T>
+}

test/SIL/Serialization/opaque_values_serialize_objc.sil

@@ -0,0 +1,30 @@
+// First parse this and then emit a *.sib. Then read in the *.sib, then recreate
+// RUN: %empty-directory(%t)
+// FIXME: <rdar://problem/29281364> sil-opt -verify is broken
+// RUN: %target-sil-opt %s -enable-sil-opaque-values -emit-sib -o %t/tmp.sib -module-name opaqueval
+// RUN: %target-sil-opt %t/tmp.sib -enable-sil-opaque-values -verify -o %t/tmp.2.sib -module-name opaqueval
+// RUN: %target-sil-opt %t/tmp.2.sib -enable-sil-opaque-values -emit-sorted-sil -verify -module-name opaqueval | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+sil_stage raw
+
+import Builtin
+import Swift
+
+struct UnownedBox<T : AnyObject> {
+  unowned var value: T
+}
+
+// CHECK-LABEL: sil [ossa] @test_unowned_copy_value : {{.*}} {
+// CHECK:       bb0([[VALUE:%[^,]+]] :
+// CHECK:         unowned_copy_value [[VALUE]]
+// CHECK-LABEL: } // end sil function 'test_unowned_copy_value'
+sil [ossa] @test_unowned_copy_value : $@convention(thin) <T where T : AnyObject> (@owned T) -> @out UnownedBox<T> {
+bb0(%owned_value : @owned $T):
+  %unowned_value = unowned_copy_value %owned_value : $T
+  destroy_value %owned_value : $T
+  %instance = struct $UnownedBox<T> (%unowned_value : $@sil_unowned T)
+  return %instance : $UnownedBox<T>
+}
+

test/SIL/cloning_opaque_values.sil

@@ -8,7 +8,6 @@ struct WeakBox<T : AnyObject> {
   weak var t: T?
 }
 
-
 // CHECK-LABEL: sil [ossa] @strong_copy_weak_value_caller : {{.*}} {
 // CHECK:       bb0([[INSTANCE:%[^,]+]] :
 // CHECK:         [[WEAK_OPTIONAL:%[^,]+]] = struct_extract [[INSTANCE]]

test/SIL/cloning_opaque_values_objc.sil

@@ -0,0 +1,33 @@
+// RUN: %target-sil-opt -enable-sil-verify-all -enable-sil-opaque-values -inline %s | %FileCheck %s
+
+// Check cloning of instructions that are only legal in opaque values mode.
+
+// REQUIRES: objc_interop
+
+import Swift
+
+struct UnownedBox<T : AnyObject> {
+  unowned var value: T
+}
+
+// CHECK-LABEL: sil [ossa] @unowned_copy_value_caller : {{.*}} {
+// CHECK:       bb0([[STRONG:%[^,]+]] :
+// CHECK:         [[UNOWNED:%[^,]+]] = unowned_copy_value [[STRONG]]
+// CHECK:         destroy_value [[STRONG]]
+// CHECK:         [[RETVAL:%[^,]+]] = struct $UnownedBox<T> ([[UNOWNED]] :
+// CHECK:         return [[RETVAL]]
+// CHECK-LABEL: } // end sil function 'unowned_copy_value_caller'
+sil [ossa] @unowned_copy_value_caller : $@convention(thin) <T where T : AnyObject> (@owned T) -> @out UnownedBox<T> {
+bb0(%value : @owned $T):
+  %callee = function_ref @unowned_copy_value : $@convention(thin) <T where T : AnyObject> (@owned T) -> @out UnownedBox<T>
+  %retval = apply %callee<T>(%value) : $@convention(thin) <T where T : AnyObject> (@owned T) -> @out UnownedBox<T>
+  return %retval : $UnownedBox<T>
+}
+
+sil [always_inline] [ossa] @unowned_copy_value : $@convention(thin) <T where T : AnyObject> (@owned T) -> @out UnownedBox<T> {
+bb0(%owned_value : @owned $T):
+  %unowned_value = unowned_copy_value %owned_value : $T
+  destroy_value %owned_value : $T
+  %instance = struct $UnownedBox<T> (%unowned_value : $@sil_unowned T)
+  return %instance : $UnownedBox<T>
+}