Move ObjC-compatible unowned references to the new runtime

functions.

Take the code for the old, broken reference-counting
implementation and delete it with prejudice.

Author: rjmccall

Diff for: include/swift/AST/DiagnosticsParse.def

@@ -453,6 +453,9 @@ ERROR(sil_invalid_instr_operands,decl_parsing,none,
       "invalid instruction operands", ())
 ERROR(sil_operand_not_address,decl_parsing,none,
       "%0 operand of '%1' must have address type", (StringRef, StringRef))
+ERROR(sil_operand_not_unowned_address,decl_parsing,none,
+      "%0 operand of '%1' must have address of [unowned] type",
+      (StringRef, StringRef))
 ERROR(sil_operand_not_weak_address,decl_parsing,none,
       "%0 operand of '%1' must have address of [weak] type",
       (StringRef, StringRef))

Diff for: include/swift/AST/Types.h

@@ -47,6 +47,7 @@ namespace swift {
   class GenericParamList;
   class GenericSignature;
   class Identifier;
+  enum class ResilienceExpansion : unsigned;
   class SILModule;
   class SILType;
   class TypeAliasDecl;
@@ -632,6 +633,10 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// unknown-released.
   bool hasRetainablePointerRepresentation();
 
+  /// \brief Given that this type is a reference type, is it known to use
+  /// Swift-native reference counting?
+  bool usesNativeReferenceCounting(ResilienceExpansion resilience);
+
   /// Determines whether this type has a bridgable object
   /// representation, i.e., whether it is always represented as a single
   /// (non-nil) pointer that can be unknown-retained and
@@ -4003,7 +4008,7 @@ BEGIN_CAN_TYPE_WRAPPER(ReferenceStorageType, Type)
   PROXY_CAN_TYPE_SIMPLE_GETTER(getReferentType)
 END_CAN_TYPE_WRAPPER(ReferenceStorageType, Type)
 
-/// \brief The storage type of a variable with [unowned] ownership semantics.
+/// \brief The storage type of a variable with @unowned ownership semantics.
 class UnownedStorageType : public ReferenceStorageType {
   friend class ReferenceStorageType;
   UnownedStorageType(Type referent, const ASTContext *C,
@@ -4016,6 +4021,10 @@ class UnownedStorageType : public ReferenceStorageType {
                  ReferenceStorageType::get(referent, Ownership::Unowned, C));
   }
 
+  /// Is this unowned storage type known to be loadable within the given
+  /// resilience scope?
+  bool isLoadable(ResilienceExpansion resilience) const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::UnownedStorage;

Diff for: include/swift/Runtime/HeapObject.h

@@ -743,50 +743,6 @@ static inline void swift_unknownWeakTakeAssign(WeakReference *dest, WeakReferenc
 /************************ UNKNOWN UNOWNED REFERENCES *************************/
 /*****************************************************************************/
 
-// TODO: these first three functions cannot be correctly supported.
-
-#if SWIFT_OBJC_INTEROP
-  
-/// Increment the strong retain count of an object which may have been
-/// deallocated and which might not be a native Swift object.
-extern "C" void swift_unknownUnownedRetainStrong(void *value);
-
-#else
-
-static inline void swift_unknownUnownedRetainStrong(void *value) {
-  swift_unownedRetain(static_cast<HeapObject *>(value));
-}
-
-#endif /* SWIFT_OBJC_INTEROP */
-
-#if SWIFT_OBJC_INTEROP
-
-/// Increment the weak/unowned reference count of an object that might
-/// not be a native Swift object.
-extern "C" void swift_unknownUnownedRetain(void *value);
-
-#else
-
-static inline void swift_unknownUnownedRetain(void *value) {
-  swift_unownedRetain(static_cast<HeapObject *>(value));
-}
-
-#endif /* SWIFT_OBJC_INTEROP */
-
-#if SWIFT_OBJC_INTEROP
-
-/// Decrement the weak/unowned reference count of an object that might not be
-/// a native Swift object.
-extern "C" void swift_unknownUnownedRelease(void *value);
-
-#else
-
-static inline void swift_unknownUnownedRelease(void *value) {
-  swift_unownedRelease(static_cast<HeapObject *>(value));
-}
-
-#endif /* SWIFT_OBJC_INTEROP */
-
 #if SWIFT_OBJC_INTEROP
 
 /// Initialize an unowned reference to an object with unknown reference

Diff for: include/swift/SIL/SILBuilder.h

@@ -457,6 +457,20 @@ class SILBuilder {
                                                     value, dest, isInit));
   }
 
+  LoadUnownedInst *createLoadUnowned(SILLocation loc, SILValue src,
+                                     IsTake_t isTake) {
+    return insert(new (F.getModule())
+                    LoadUnownedInst(createSILDebugLocation(loc), src, isTake));
+  }
+
+  StoreUnownedInst *createStoreUnowned(SILLocation loc, SILValue value,
+                                       SILValue dest,
+                                       IsInitialization_t isInit) {
+    return insert(new (F.getModule())
+                    StoreUnownedInst(createSILDebugLocation(loc),
+                                     value, dest, isInit));
+  }
+
   CopyAddrInst *createCopyAddr(SILLocation Loc, SILValue srcAddr,
                                SILValue destAddr, IsTake_t isTake,
                                IsInitialization_t isInitialize) {

Diff for: include/swift/SIL/SILCloner.h

@@ -690,6 +690,27 @@ SILCloner<ImplClass>::visitDebugValueAddrInst(DebugValueAddrInst *Inst) {
 }
 
 
+template<typename ImplClass>
+void
+SILCloner<ImplClass>::visitLoadUnownedInst(LoadUnownedInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  doPostProcess(Inst,
+    getBuilder().createLoadUnowned(getOpLocation(Inst->getLoc()),
+                                   getOpValue(Inst->getOperand()),
+                                   Inst->isTake()));
+}
+
+template<typename ImplClass>
+void
+SILCloner<ImplClass>::visitStoreUnownedInst(StoreUnownedInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  doPostProcess(Inst,
+    getBuilder().createStoreUnowned(getOpLocation(Inst->getLoc()),
+                                    getOpValue(Inst->getSrc()),
+                                    getOpValue(Inst->getDest()),
+                                    Inst->isInitializationOfDest()));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitLoadWeakInst(LoadWeakInst *Inst) {

Diff for: include/swift/SIL/SILInstruction.h

@@ -1401,13 +1401,9 @@ class DebugValueAddrInst
 };
 
 
-
-/// Represents a load from a @weak memory location.
-class LoadWeakInst
-  : public UnaryInstructionBase<ValueKind::LoadWeakInst>
-{
-  friend class SILBuilder;
-
+/// An abstract class representing a load from some kind of reference storage.
+template <ValueKind K>
+class LoadReferenceInstBase : public UnaryInstructionBase<K> {
   static SILType getResultType(SILType operandTy) {
     assert(operandTy.isAddress() && "loading from non-address operand?");
     auto refType = cast<ReferenceStorageType>(operandTy.getSwiftRValueType());
@@ -1416,26 +1412,28 @@ class LoadWeakInst
 
   unsigned IsTake : 1; // FIXME: pack this somewhere
 
-  /// \param DebugLoc The location of the expression that caused the load.
-  /// \param lvalue The SILValue representing the address to
-  ///        use for the load.
-  LoadWeakInst(SILDebugLocation *DebugLoc, SILValue lvalue, IsTake_t isTake)
-      : UnaryInstructionBase(DebugLoc, lvalue, getResultType(lvalue.getType())),
-        IsTake(unsigned(isTake)) {}
+protected:
+  LoadReferenceInstBase(SILDebugLocation *loc, SILValue lvalue, IsTake_t isTake)
+    : UnaryInstructionBase<K>(loc, lvalue, getResultType(lvalue.getType())),
+      IsTake(unsigned(isTake)) {
+  }
 
 public:
   IsTake_t isTake() const { return IsTake_t(IsTake); }
 };
 
-/// Represents a store to a @weak memory location.
-class StoreWeakInst : public SILInstruction {
-  friend class SILBuilder;
-
+/// An abstract class representing a store to some kind of reference storage.
+template <ValueKind K>
+class StoreReferenceInstBase : public SILInstruction {
   enum { Src, Dest };
   FixedOperandList<2> Operands;
   unsigned IsInitializationOfDest : 1; // FIXME: pack this somewhere
-  StoreWeakInst(SILDebugLocation *DebugLoc, SILValue src, SILValue dest,
-                IsInitialization_t isInit);
+protected:
+  StoreReferenceInstBase(SILDebugLocation *loc, SILValue src, SILValue dest,
+                         IsInitialization_t isInit)
+    : SILInstruction(K, loc), Operands(this, src, dest),
+      IsInitializationOfDest(unsigned(isInit)) {
+  }
 
 public:
   SILValue getSrc() const { return Operands[Src].get(); }
@@ -1452,10 +1450,64 @@ class StoreWeakInst : public SILInstruction {
   MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
 
   static bool classof(const ValueBase *V) {
-    return V->getKind() == ValueKind::StoreWeakInst;
+    return V->getKind() == K;
   }
 };
 
+/// Represents a load from a @weak memory location.
+class LoadWeakInst
+  : public LoadReferenceInstBase<ValueKind::LoadWeakInst>
+{
+  friend class SILBuilder;
+
+  /// \param loc The location of the expression that caused the load.
+  /// \param lvalue The SILValue representing the address to
+  ///        use for the load.
+  LoadWeakInst(SILDebugLocation *loc, SILValue lvalue, IsTake_t isTake)
+    : LoadReferenceInstBase(loc, lvalue, isTake) {}
+};
+
+/// Represents a store to a @weak memory location.
+class StoreWeakInst
+  : public StoreReferenceInstBase<ValueKind::StoreWeakInst>
+{
+  friend class SILBuilder;
+
+  StoreWeakInst(SILDebugLocation *loc, SILValue src, SILValue dest,
+                IsInitialization_t isInit)
+    : StoreReferenceInstBase(loc, src, dest, isInit) {}
+};
+
+/// Represents a load from an @unowned memory location.
+///
+/// This is only required for address-only unowned references; for loadable
+/// unowned references, it's better to use a load and a strong_retain_unowned.
+class LoadUnownedInst
+  : public LoadReferenceInstBase<ValueKind::LoadUnownedInst>
+{
+  friend class SILBuilder;
+
+  /// \param loc The location of the expression that caused the load.
+  /// \param lvalue The SILValue representing the address to
+  ///        use for the load.
+  LoadUnownedInst(SILDebugLocation *loc, SILValue lvalue, IsTake_t isTake)
+    : LoadReferenceInstBase(loc, lvalue, isTake) {}
+};
+
+/// Represents a store to an @unowned memory location.
+///
+/// This is only required for address-only unowned references; for loadable
+/// unowned references, it's better to use a ref_to_unowned and a store.
+class StoreUnownedInst
+  : public StoreReferenceInstBase<ValueKind::StoreUnownedInst>
+{
+  friend class SILBuilder;
+
+  StoreUnownedInst(SILDebugLocation *loc, SILValue src, SILValue dest,
+                   IsInitialization_t isInit)
+    : StoreReferenceInstBase(loc, src, dest, isInit) {}
+};
+
 /// CopyAddrInst - Represents a copy from one memory location to another. This
 /// is similar to:
 ///   %1 = load %src

Diff for: include/swift/SIL/SILNodes.def

@@ -91,13 +91,15 @@ ABSTRACT_VALUE(SILInstruction, ValueBase)
 
   // Accessing memory
   INST(LoadInst, SILInstruction, MayRead, DoesNotRelease)
+  INST(LoadUnownedInst, SILInstruction, MayRead, DoesNotRelease)
   INST(LoadWeakInst, SILInstruction, MayRead, DoesNotRelease)
   INST(StoreInst, SILInstruction, MayWrite, DoesNotRelease)
   INST(AssignInst, SILInstruction, MayWrite, DoesNotRelease)
   INST(MarkUninitializedInst, SILInstruction, None, DoesNotRelease)
   INST(MarkFunctionEscapeInst, SILInstruction, None, DoesNotRelease)
   INST(DebugValueInst, SILInstruction, None, DoesNotRelease)
   INST(DebugValueAddrInst, SILInstruction, None, DoesNotRelease)
+  INST(StoreUnownedInst, SILInstruction, MayWrite, DoesNotRelease)
   INST(StoreWeakInst, SILInstruction, MayWrite, DoesNotRelease)
   INST(CopyAddrInst, SILInstruction, MayHaveSideEffects, MayRelease)
   INST(DestroyAddrInst, SILInstruction, MayHaveSideEffects, MayRelease)

Diff for: lib/AST/Type.cpp

@@ -3137,3 +3137,99 @@ bool Type::isPrivateStdlibType(bool whitelistProtocols) const {
 
   return false;
 }
+
+bool UnownedStorageType::isLoadable(ResilienceExpansion resilience) const {
+  return getReferentType()->usesNativeReferenceCounting(resilience);
+}
+
+static bool doesOpaqueClassUseNativeReferenceCounting(const ASTContext &ctx) {
+  return !ctx.LangOpts.EnableObjCInterop;
+}
+
+static bool usesNativeReferenceCounting(ClassDecl *theClass,
+                                        ResilienceExpansion resilience) {
+  // NOTE: if you change this, change irgen::getReferenceCountingForClass.
+  // TODO: Resilience? there might be some legal avenue of changing this.
+  while (Type supertype = theClass->getSuperclass()) {
+    theClass = supertype->getClassOrBoundGenericClass();
+    assert(theClass);
+  }
+  return !theClass->hasClangNode();
+}
+
+bool TypeBase::usesNativeReferenceCounting(ResilienceExpansion resilience) {
+  assert(allowsOwnership());
+
+  CanType type = getCanonicalType();
+  switch (type->getKind()) {
+#define SUGARED_TYPE(id, parent) case TypeKind::id:
+#define TYPE(id, parent)
+#include "swift/AST/TypeNodes.def"
+    llvm_unreachable("sugared canonical type?");
+
+  case TypeKind::BuiltinNativeObject:
+  case TypeKind::SILBox:
+    return true;
+
+  case TypeKind::BuiltinUnknownObject:
+  case TypeKind::BuiltinBridgeObject:
+    return ::doesOpaqueClassUseNativeReferenceCounting(type->getASTContext());
+
+  case TypeKind::Class:
+    return ::usesNativeReferenceCounting(cast<ClassType>(type)->getDecl(),
+                                         resilience);
+  case TypeKind::BoundGenericClass:
+    return ::usesNativeReferenceCounting(
+                                  cast<BoundGenericClassType>(type)->getDecl(),
+                                         resilience);
+
+  case TypeKind::DynamicSelf:
+    return cast<DynamicSelfType>(type).getSelfType()
+             ->usesNativeReferenceCounting(resilience);
+
+  case TypeKind::Archetype: {
+    auto archetype = cast<ArchetypeType>(type);
+    assert(archetype->requiresClass());
+    if (auto supertype = archetype->getSuperclass())
+      return supertype->usesNativeReferenceCounting(resilience);
+    return ::doesOpaqueClassUseNativeReferenceCounting(type->getASTContext());
+  }
+
+  case TypeKind::Protocol:
+  case TypeKind::ProtocolComposition:
+    return ::doesOpaqueClassUseNativeReferenceCounting(type->getASTContext());
+
+  case TypeKind::UnboundGeneric:
+  case TypeKind::Function:
+  case TypeKind::PolymorphicFunction:
+  case TypeKind::GenericFunction:
+  case TypeKind::SILFunction:
+  case TypeKind::SILBlockStorage:
+  case TypeKind::Error:
+  case TypeKind::Unresolved:
+  case TypeKind::BuiltinInteger:
+  case TypeKind::BuiltinFloat:
+  case TypeKind::BuiltinRawPointer:
+  case TypeKind::BuiltinUnsafeValueBuffer:
+  case TypeKind::BuiltinVector:
+  case TypeKind::Tuple:
+  case TypeKind::Enum:
+  case TypeKind::Struct:
+  case TypeKind::Metatype:
+  case TypeKind::ExistentialMetatype:
+  case TypeKind::Module:
+  case TypeKind::LValue:
+  case TypeKind::InOut:
+  case TypeKind::TypeVariable:
+  case TypeKind::BoundGenericEnum:
+  case TypeKind::BoundGenericStruct:
+  case TypeKind::UnownedStorage:
+  case TypeKind::UnmanagedStorage:
+  case TypeKind::WeakStorage:
+  case TypeKind::GenericTypeParam:
+  case TypeKind::DependentMember:
+    llvm_unreachable("type is not a class reference");
+  }
+
+  llvm_unreachable("Unhandled type kind!");
+}

Diff for: lib/IRGen/GenArchetype.cpp

@@ -46,7 +46,6 @@
 #include "ProtocolInfo.h"
 #include "ResilientTypeInfo.h"
 #include "TypeInfo.h"
-#include "UnownedTypeInfo.h"
 #include "WeakTypeInfo.h"
 
 using namespace swift;