Merge pull request #11950 from aschwaighofer/runtime_return_dest_2

runtime: Also return the destination argument of the unknownWeak- and…

include/swift/Runtime/HeapObject.h

@@ -889,13 +889,15 @@ static inline void swift_nonatomic_unknownRelease_n(void *value, int n)
 ///
 /// \param ref - never null
 /// \param value - not necessarily a native Swift object; can be null
+/// \return ref
 SWIFT_RUNTIME_EXPORT
-void swift_unknownWeakInit(WeakReference *ref, void *value);
+WeakReference *swift_unknownWeakInit(WeakReference *ref, void *value);
 
 #else
 
-static inline void swift_unknownWeakInit(WeakReference *ref, void *value) {
+static inline WeakReference *swift_unknownWeakInit(WeakReference *ref,
-  swift_weakInit(ref, static_cast<HeapObject *>(value));
+                                                   void *value) {
+  return swift_weakInit(ref, static_cast<HeapObject *>(value));
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -906,13 +908,15 @@ static inline void swift_unknownWeakInit(WeakReference *ref, void *value) {
 ///
 /// \param ref - never null
 /// \param value - not necessarily a native Swift object; can be null
+/// \return ref
 SWIFT_RUNTIME_EXPORT
-void swift_unknownWeakAssign(WeakReference *ref, void *value);
+WeakReference *swift_unknownWeakAssign(WeakReference *ref, void *value);
 
 #else
 
-static inline void swift_unknownWeakAssign(WeakReference *ref, void *value) {
+static inline WeakReference *swift_unknownWeakAssign(WeakReference *ref,
-  swift_weakAssign(ref, static_cast<HeapObject *>(value));
+                                                     void *value) {
+  return swift_weakAssign(ref, static_cast<HeapObject *>(value));
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -973,15 +977,16 @@ static inline void swift_unknownWeakDestroy(WeakReference *object) {
 
 /// Copy-initialize a weak reference variable from one that might not
 /// refer to a native Swift object.
+/// \return dest
 SWIFT_RUNTIME_EXPORT
-void swift_unknownWeakCopyInit(WeakReference *dest,
+WeakReference *swift_unknownWeakCopyInit(WeakReference *dest,
-                               WeakReference *src);
+                                         WeakReference *src);
 
 #else
 
-static inline void swift_unknownWeakCopyInit(WeakReference *dest,
+static inline WeakReference *swift_unknownWeakCopyInit(WeakReference *dest,
-                                             WeakReference *src) {
+                                                       WeakReference *src) {
-  swift_weakCopyInit(dest, src);
+  return swift_weakCopyInit(dest, src);
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -990,15 +995,16 @@ static inline void swift_unknownWeakCopyInit(WeakReference *dest,
 
 /// Take-initialize a weak reference variable from one that might not
 /// refer to a native Swift object.
+/// \return dest
 SWIFT_RUNTIME_EXPORT
-void swift_unknownWeakTakeInit(WeakReference *dest,
+WeakReference *swift_unknownWeakTakeInit(WeakReference *dest,
-                               WeakReference *src);
+                                         WeakReference *src);
 
 #else
 
-static inline void swift_unknownWeakTakeInit(WeakReference *dest,
+static inline WeakReference *swift_unknownWeakTakeInit(WeakReference *dest,
-                                             WeakReference *src) {
+                                                       WeakReference *src) {
-  swift_weakTakeInit(dest, src);
+  return swift_weakTakeInit(dest, src);
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -1007,15 +1013,16 @@ static inline void swift_unknownWeakTakeInit(WeakReference *dest,
 
 /// Copy-assign a weak reference variable from another when either
 /// or both variables might not refer to a native Swift object.
+/// \return dest
 SWIFT_RUNTIME_EXPORT
-void swift_unknownWeakCopyAssign(WeakReference *dest,
+WeakReference *swift_unknownWeakCopyAssign(WeakReference *dest,
-                                 WeakReference *src);
+                                           WeakReference *src);
 
 #else
 
-static inline void swift_unknownWeakCopyAssign(WeakReference *dest,
+static inline WeakReference *swift_unknownWeakCopyAssign(WeakReference *dest,
-                                               WeakReference *src) {
+                                                         WeakReference *src) {
-  swift_weakCopyAssign(dest, src);
+  return swift_weakCopyAssign(dest, src);
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -1024,15 +1031,16 @@ static inline void swift_unknownWeakCopyAssign(WeakReference *dest,
 
 /// Take-assign a weak reference variable from another when either
 /// or both variables might not refer to a native Swift object.
+/// \return dest
 SWIFT_RUNTIME_EXPORT
-void swift_unknownWeakTakeAssign(WeakReference *dest,
+WeakReference *swift_unknownWeakTakeAssign(WeakReference *dest,
-                                 WeakReference *src);
+                                           WeakReference *src);
 
 #else
 
-static inline void swift_unknownWeakTakeAssign(WeakReference *dest,
+static inline WeakReference *swift_unknownWeakTakeAssign(WeakReference *dest,
-                                               WeakReference *src) {
+                                                         WeakReference *src) {
-  swift_weakTakeAssign(dest, src);
+  return swift_weakTakeAssign(dest, src);
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -1045,14 +1053,16 @@ static inline void swift_unknownWeakTakeAssign(WeakReference *dest,
 
 /// Initialize an unowned reference to an object with unknown reference
 /// counting.
+/// \return ref
 SWIFT_RUNTIME_EXPORT
-void swift_unknownUnownedInit(UnownedReference *ref, void *value);
+UnownedReference *swift_unknownUnownedInit(UnownedReference *ref, void *value);
 
 #else
 
-static inline void swift_unknownUnownedInit(UnownedReference *ref,
+static inline UnownedReference *swift_unknownUnownedInit(UnownedReference *ref,
-                                            void *value) {
+                                                         void *value) {
   swift_unownedInit(ref, static_cast<HeapObject*>(value));
+  return ref;
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -1061,14 +1071,17 @@ static inline void swift_unknownUnownedInit(UnownedReference *ref,
 
 /// Assign to an unowned reference holding an object with unknown reference
 /// counting.
+/// \return ref
 SWIFT_RUNTIME_EXPORT
-void swift_unknownUnownedAssign(UnownedReference *ref, void *value);
+UnownedReference *swift_unknownUnownedAssign(UnownedReference *ref,
+                                             void *value);
 
 #else
 
-static inline void swift_unknownUnownedAssign(UnownedReference *ref,
+static inline UnownedReference *
-                                              void *value) {
+swift_unknownUnownedAssign(UnownedReference *ref, void *value) {
   swift_unownedAssign(ref, static_cast<HeapObject*>(value));
+  return ref;
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -1121,15 +1134,17 @@ static inline void swift_unknownUnownedDestroy(UnownedReference *ref) {
 
 /// Copy-initialize an unowned reference variable from one that might not
 /// refer to a native Swift object.
+/// \return dest
 SWIFT_RUNTIME_EXPORT
-void swift_unknownUnownedCopyInit(UnownedReference *dest,
+UnownedReference *swift_unknownUnownedCopyInit(UnownedReference *dest,
-                                  UnownedReference *src);
+                                               UnownedReference *src);
 
 #else
 
-static inline void swift_unknownUnownedCopyInit(UnownedReference *dest,
+static inline UnownedReference *
-                                                UnownedReference *src) {
+swift_unknownUnownedCopyInit(UnownedReference *dest, UnownedReference *src) {
   swift_unownedCopyInit(dest, src);
+  return dest;
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -1139,14 +1154,15 @@ static inline void swift_unknownUnownedCopyInit(UnownedReference *dest,
 /// Take-initialize an unowned reference variable from one that might not
 /// refer to a native Swift object.
 SWIFT_RUNTIME_EXPORT
-void swift_unknownUnownedTakeInit(UnownedReference *dest,
+UnownedReference *swift_unknownUnownedTakeInit(UnownedReference *dest,
-                                             UnownedReference *src);
+                                               UnownedReference *src);
 
 #else
 
-static inline void swift_unknownUnownedTakeInit(UnownedReference *dest,
+static inline UnownedReference *
-                                                UnownedReference *src) {
+swift_unknownUnownedTakeInit(UnownedReference *dest, UnownedReference *src) {
   swift_unownedTakeInit(dest, src);
+  return dest;
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -1155,15 +1171,17 @@ static inline void swift_unknownUnownedTakeInit(UnownedReference *dest,
 
 /// Copy-assign an unowned reference variable from another when either
 /// or both variables might not refer to a native Swift object.
+/// \return dest
 SWIFT_RUNTIME_EXPORT
-void swift_unknownUnownedCopyAssign(UnownedReference *dest,
+UnownedReference *swift_unknownUnownedCopyAssign(UnownedReference *dest,
-                                               UnownedReference *src);
+                                                 UnownedReference *src);
 
 #else
 
-static inline void swift_unknownUnownedCopyAssign(UnownedReference *dest,
+static inline UnownedReference *
-                                                  UnownedReference *src) {
+swift_unknownUnownedCopyAssign(UnownedReference *dest, UnownedReference *src) {
   swift_unownedCopyAssign(dest, src);
+  return dest;
 }
 
 #endif /* SWIFT_OBJC_INTEROP */
@@ -1172,15 +1190,17 @@ static inline void swift_unknownUnownedCopyAssign(UnownedReference *dest,
 
 /// Take-assign an unowned reference variable from another when either
 /// or both variables might not refer to a native Swift object.
+/// \return dest
 SWIFT_RUNTIME_EXPORT
-void swift_unknownUnownedTakeAssign(UnownedReference *dest,
+UnownedReference *swift_unknownUnownedTakeAssign(UnownedReference *dest,
-                                               UnownedReference *src);
+                                                 UnownedReference *src);
 
 #else
 
-static inline void swift_unknownUnownedTakeAssign(UnownedReference *dest,
+static inline UnownedReference *
-                                                  UnownedReference *src) {
+swift_unknownUnownedTakeAssign(UnownedReference *dest, UnownedReference *src) {
   swift_unownedTakeAssign(dest, src);
+  return dest;
 }
 
 #endif /* SWIFT_OBJC_INTEROP */

include/swift/Runtime/RuntimeFunctions.def

@@ -520,15 +520,15 @@ FUNCTION(UnknownWeakDestroy, swift_unknownWeakDestroy, DefaultCC,
 
 // void swift_unknownWeakInit(WeakReference *object, void *value);
 FUNCTION(UnknownWeakInit, swift_unknownWeakInit, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(WeakReferencePtrTy),
          ARGS(WeakReferencePtrTy, UnknownRefCountedPtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
-// void swift_unknownWeakAssign(WeakReference *object, void *value);
+// WeakReference *swift_unknownWeakAssign(WeakReference *object, void *value);
 FUNCTION(UnknownWeakAssign, swift_unknownWeakAssign, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(WeakReferencePtrTy),
          ARGS(WeakReferencePtrTy, UnknownRefCountedPtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
 // void *swift_unknownWeakLoad(WeakReference *object);
 FUNCTION(UnknownWeakLoadStrong, swift_unknownWeakLoadStrong,DefaultCC,
@@ -542,29 +542,29 @@ FUNCTION(UnknownWeakTakeStrong, swift_unknownWeakTakeStrong,DefaultCC,
          ARGS(WeakReferencePtrTy),
          ATTRS(NoUnwind))
 
-// void swift_unknownWeakCopyInit(WeakReference *dest, WeakReference *src);
+// WeakReference *swift_unknownWeakCopyInit(WeakReference *dest, WeakReference *src);
 FUNCTION(UnknownWeakCopyInit, swift_unknownWeakCopyInit, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(WeakReferencePtrTy),
          ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
-// void swift_unknownWeakTakeInit(WeakReference *dest, WeakReference *src);
+// void *swift_unknownWeakTakeInit(WeakReference *dest, WeakReference *src);
 FUNCTION(UnknownWeakTakeInit, swift_unknownWeakTakeInit, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(WeakReferencePtrTy),
          ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
-// void swift_unknownWeakCopyAssign(WeakReference *dest, WeakReference *src);
+// WeakReference *swift_unknownWeakCopyAssign(WeakReference *dest, WeakReference *src);
 FUNCTION(UnknownWeakCopyAssign, swift_unknownWeakCopyAssign, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(WeakReferencePtrTy),
          ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
-// void swift_unknownWeakTakeAssign(WeakReference *dest, WeakReference *src);
+// WeakReference *swift_unknownWeakTakeAssign(WeakReference *dest, WeakReference *src);
 FUNCTION(UnknownWeakTakeAssign, swift_unknownWeakTakeAssign, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(WeakReferencePtrTy),
          ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
 // void swift_unknownUnownedDestroy(UnownedReference *object);
 FUNCTION(UnknownUnownedDestroy, swift_unknownUnownedDestroy, DefaultCC,
@@ -572,17 +572,17 @@ FUNCTION(UnknownUnownedDestroy, swift_unknownUnownedDestroy, DefaultCC,
          ARGS(UnownedReferencePtrTy),
          ATTRS(NoUnwind))
 
-// void swift_unknownUnownedInit(UnownedReference *object, void *value);
+// UnownedReference *swift_unknownUnownedInit(UnownedReference *object, void *value);
 FUNCTION(UnknownUnownedInit, swift_unknownUnownedInit, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(UnownedReferencePtrTy),
          ARGS(UnownedReferencePtrTy, UnknownRefCountedPtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
-// void swift_unknownUnownedAssign(UnownedReference *object, void *value);
+// UnownedReference *swift_unknownUnownedAssign(UnownedReference *object, void *value);
 FUNCTION(UnknownUnownedAssign, swift_unknownUnownedAssign, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(UnownedReferencePtrTy),
          ARGS(UnownedReferencePtrTy, UnknownRefCountedPtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
 // void *swift_unknownUnownedLoad(UnownedReference *object);
 FUNCTION(UnknownUnownedLoadStrong, swift_unknownUnownedLoadStrong, DefaultCC,
@@ -596,29 +596,29 @@ FUNCTION(UnknownUnownedTakeStrong, swift_unknownUnownedTakeStrong, DefaultCC,
          ARGS(UnownedReferencePtrTy),
          ATTRS(NoUnwind))
 
-// void swift_unknownUnownedCopyInit(UnownedReference *dest, UnownedReference *src);
+// UnownedReference *swift_unknownUnownedCopyInit(UnownedReference *dest, UnownedReference *src);
 FUNCTION(UnknownUnownedCopyInit, swift_unknownUnownedCopyInit, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(UnownedReferencePtrTy),
          ARGS(UnownedReferencePtrTy, UnownedReferencePtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
-// void swift_unknownUnownedTakeInit(UnownedReference *dest, UnownedReference *src);
+// UnownedReference *swift_unknownUnownedTakeInit(UnownedReference *dest, UnownedReference *src);
 FUNCTION(UnknownUnownedTakeInit, swift_unknownUnownedTakeInit, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(UnownedReferencePtrTy),
          ARGS(UnownedReferencePtrTy, UnownedReferencePtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
-// void swift_unknownUnownedCopyAssign(UnownedReference *dest, UnownedReference *src);
+// UnownedReference *swift_unknownUnownedCopyAssign(UnownedReference *dest, UnownedReference *src);
 FUNCTION(UnknownUnownedCopyAssign, swift_unknownUnownedCopyAssign, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(UnownedReferencePtrTy),
          ARGS(UnownedReferencePtrTy, UnownedReferencePtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
-// void swift_unknownUnownedTakeAssign(UnownedReference *dest, UnownedReference *src);
+// UnownedReference *swift_unknownUnownedTakeAssign(UnownedReference *dest, UnownedReference *src);
 FUNCTION(UnknownUnownedTakeAssign, swift_unknownUnownedTakeAssign, DefaultCC,
-         RETURNS(VoidTy),
+         RETURNS(UnownedReferencePtrTy),
          ARGS(UnownedReferencePtrTy, UnownedReferencePtrTy),
-         ATTRS(NoUnwind))
+         ATTRS(NoUnwind, FirstParamReturned))
 
 // bool swift_isUniquelyReferencedNonObjC(const void *);
 FUNCTION(IsUniquelyReferencedNonObjC, swift_isUniquelyReferencedNonObjC,

stdlib/public/runtime/SwiftObject.mm

@@ -869,7 +869,8 @@ static bool isObjCForUnownedReference(void *value) {
           !objectUsesNativeSwiftReferenceCounting(value));
 }
 
-void swift::swift_unknownUnownedInit(UnownedReference *dest, void *value) {
+UnownedReference *swift::swift_unknownUnownedInit(UnownedReference *dest,
+                                                  void *value) {
   if (!value) {
     dest->Value = nullptr;
   } else if (isObjCForUnownedReference(value)) {
@@ -877,9 +878,11 @@ void swift::swift_unknownUnownedInit(UnownedReference *dest, void *value) {
   } else {
     swift_unownedInit(dest, (HeapObject*) value);
   }
+  return dest;
 }
 
-void swift::swift_unknownUnownedAssign(UnownedReference *dest, void *value) {
+UnownedReference *swift::swift_unknownUnownedAssign(UnownedReference *dest,
+                                                    void *value) {
   if (!value) {
     swift_unknownUnownedDestroy(dest);
     dest->Value = nullptr;
@@ -898,6 +901,7 @@ void swift::swift_unknownUnownedAssign(UnownedReference *dest, void *value) {
       swift_unownedAssign(dest, (HeapObject*) value);
     }
   }
+  return dest;
 }
 
 void *swift::swift_unknownUnownedLoadStrong(UnownedReference *ref) {
@@ -941,8 +945,8 @@ void swift::swift_unknownUnownedDestroy(UnownedReference *ref) {
   }
 }
 
-void swift::swift_unknownUnownedCopyInit(UnownedReference *dest,
+UnownedReference *swift::swift_unknownUnownedCopyInit(UnownedReference *dest,
-                                         UnownedReference *src) {
+                                                      UnownedReference *src) {
   assert(dest != src);
   if (!src->Value) {
     dest->Value = nullptr;
@@ -951,17 +955,19 @@ void swift::swift_unknownUnownedCopyInit(UnownedReference *dest,
   } else {
     swift_unownedCopyInit(dest, src);
   }
+  return dest;
 }
 
-void swift::swift_unknownUnownedTakeInit(UnownedReference *dest,
+UnownedReference *swift::swift_unknownUnownedTakeInit(UnownedReference *dest,
-                                         UnownedReference *src) {
+                                                      UnownedReference *src) {
   assert(dest != src);
   dest->Value = src->Value;
+  return dest;
 }
 
-void swift::swift_unknownUnownedCopyAssign(UnownedReference *dest,
+UnownedReference *swift::swift_unknownUnownedCopyAssign(UnownedReference *dest,
-                                           UnownedReference *src) {
+                                                        UnownedReference *src) {
-  if (dest == src) return;
+  if (dest == src) return dest;
 
   if (auto objcSrc = dyn_cast<ObjCUnownedReference>(src)) {
     if (auto objcDest = dyn_cast<ObjCUnownedReference>(dest)) {
@@ -969,7 +975,7 @@ void swift::swift_unknownUnownedCopyAssign(UnownedReference *dest,
       objc_destroyWeak(&objcDest->storage()->WeakRef);
       objc_copyWeak(&objcDest->storage()->WeakRef,
                     &objcSrc->storage()->WeakRef);
-      return;
+      return dest;
     }
 
     swift_unownedDestroy(dest);
@@ -982,15 +988,17 @@ void swift::swift_unknownUnownedCopyAssign(UnownedReference *dest,
       swift_unownedCopyAssign(dest, src);
     }
   }
+  return dest;
 }
 
-void swift::swift_unknownUnownedTakeAssign(UnownedReference *dest,
+UnownedReference *swift::swift_unknownUnownedTakeAssign(UnownedReference *dest,
-                                           UnownedReference *src) {
+                                                        UnownedReference *src) {
   assert(dest != src);
 
   // There's not really anything more efficient to do here than this.
   swift_unknownUnownedDestroy(dest);
   dest->Value = src->Value;
+  return dest;
 }
 
 bool swift::swift_unknownUnownedIsEqual(UnownedReference *ref, void *value) {
@@ -1012,12 +1020,14 @@ bool swift::swift_unknownUnownedIsEqual(UnownedReference *ref, void *value) {
 /************************** UNKNOWN WEAK REFERENCES **************************/
 /*****************************************************************************/
 
-void swift::swift_unknownWeakInit(WeakReference *ref, void *value) {
+WeakReference *swift::swift_unknownWeakInit(WeakReference *ref, void *value) {
-  return ref->unknownInit(value);
+  ref->unknownInit(value);
+  return ref;
 }
 
-void swift::swift_unknownWeakAssign(WeakReference *ref, void *value) {
+WeakReference *swift::swift_unknownWeakAssign(WeakReference *ref, void *value) {
-  return ref->unknownAssign(value);
+  ref->unknownAssign(value);
+  return ref;
 }
 
 void *swift::swift_unknownWeakLoadStrong(WeakReference *ref) {
@@ -1032,19 +1042,25 @@ void swift::swift_unknownWeakDestroy(WeakReference *ref) {
   ref->unknownDestroy();
 }
 
-void swift::swift_unknownWeakCopyInit(WeakReference *dest, WeakReference *src) {
+WeakReference *swift::swift_unknownWeakCopyInit(WeakReference *dest,
+                                                WeakReference *src) {
   dest->unknownCopyInit(src);
+  return dest;
 }
-void swift::swift_unknownWeakTakeInit(WeakReference *dest, WeakReference *src) {
+WeakReference *swift::swift_unknownWeakTakeInit(WeakReference *dest,
+                                                WeakReference *src) {
   dest->unknownTakeInit(src);
+  return dest;
 }
-void swift::swift_unknownWeakCopyAssign(WeakReference *dest,
+WeakReference *swift::swift_unknownWeakCopyAssign(WeakReference *dest,
-                                        WeakReference *src) {
+                                                  WeakReference *src) {
   dest->unknownCopyAssign(src);
+  return dest;
 }
-void swift::swift_unknownWeakTakeAssign(WeakReference *dest,
+WeakReference *swift::swift_unknownWeakTakeAssign(WeakReference *dest,
-                                        WeakReference *src) {
+                                                  WeakReference *src) {
   dest->unknownTakeAssign(src);
+  return dest;
 }
 
 // SWIFT_OBJC_INTEROP

test/IRGen/existentials_objc.sil

@@ -80,7 +80,7 @@ entry(%s : $CP):
   // CHECK: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[U1]], i32 0, i32 1
   // CHECK: store i8** %1, i8*** [[T0]], align 8
   // CHECK: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[U1]], i32 0, i32 0
-  // CHECK: call void @swift_unknownUnownedInit(%swift.unowned* [[T0]], %objc_object* %0)
+  // CHECK: call %swift.unowned* @swift_unknownUnownedInit(%swift.unowned* [[T0]], %objc_object* %0)
 
   // CHECK: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[U1]], i32 0, i32 0
   // CHECK: [[T1:%.*]] = call %objc_object* @swift_unknownUnownedLoadStrong(%swift.unowned* [[T0]])
@@ -112,7 +112,7 @@ entry(%w : $*@sil_weak CP?, %a : $CP?):
   // CHECK: [[DEST_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 1
   // CHECK: store i8** [[SRC_WITNESS]], i8*** [[DEST_WITNESS_ADDR]]
   // CHECK: [[DEST_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 0
-  // CHECK: call void @swift_unknownWeakInit(%swift.weak* [[DEST_REF_ADDR]], %objc_object* [[SRC_REF]])
+  // CHECK: call %swift.weak* @swift_unknownWeakInit(%swift.weak* [[DEST_REF_ADDR]], %objc_object* [[SRC_REF]])
   store_weak %a to [initialization] %w : $*@sil_weak CP?
 
   // CHECK: [[SRC_REF:%.*]] = inttoptr {{.*}} %objc_object*
@@ -120,7 +120,7 @@ entry(%w : $*@sil_weak CP?, %a : $CP?):
   // CHECK: [[DEST_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 1
   // CHECK: store i8** [[SRC_WITNESS]], i8*** [[DEST_WITNESS_ADDR]]
   // CHECK: [[DEST_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 0
-  // CHECK: call void @swift_unknownWeakAssign(%swift.weak* [[DEST_REF_ADDR]], %objc_object* [[SRC_REF]])
+  // CHECK: call %swift.weak* @swift_unknownWeakAssign(%swift.weak* [[DEST_REF_ADDR]], %objc_object* [[SRC_REF]])
   store_weak %a to                  %w : $*@sil_weak CP?
 
   // CHECK: [[SRC_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 0
@@ -137,7 +137,7 @@ entry(%w : $*@sil_weak CP?, %a : $CP?):
 
   // CHECK: [[DEST_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* [[V]], i32 0, i32 0
   // CHECK: [[SRC_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 0
-  // CHECK: call void @swift_unknownWeakTakeInit(%swift.weak* [[DEST_REF_ADDR]], %swift.weak* [[SRC_REF_ADDR]])
+  // CHECK: call %swift.weak* @swift_unknownWeakTakeInit(%swift.weak* [[DEST_REF_ADDR]], %swift.weak* [[SRC_REF_ADDR]])
   // CHECK: [[SRC_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 1
   // CHECK: [[WITNESS:%.*]] = load i8**, i8*** [[SRC_WITNESS_ADDR]], align 8
   // CHECK: [[DEST_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* [[V]], i32 0, i32 1
@@ -146,7 +146,7 @@ entry(%w : $*@sil_weak CP?, %a : $CP?):
 
   // CHECK: [[DEST_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* [[V]], i32 0, i32 0
   // CHECK: [[SRC_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 0
-  // CHECK: call void @swift_unknownWeakTakeAssign(%swift.weak* [[DEST_REF_ADDR]], %swift.weak* [[SRC_REF_ADDR]])
+  // CHECK: call %swift.weak* @swift_unknownWeakTakeAssign(%swift.weak* [[DEST_REF_ADDR]], %swift.weak* [[SRC_REF_ADDR]])
   // CHECK: [[SRC_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 1
   // CHECK: [[WITNESS:%.*]] = load i8**, i8*** [[SRC_WITNESS_ADDR]], align 8
   // CHECK: [[DEST_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* [[V]], i32 0, i32 1
@@ -155,7 +155,7 @@ entry(%w : $*@sil_weak CP?, %a : $CP?):
 
   // CHECK: [[DEST_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* [[V]], i32 0, i32 0
   // CHECK: [[SRC_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 0
-  // CHECK: call void @swift_unknownWeakCopyInit(%swift.weak* [[DEST_REF_ADDR]], %swift.weak* [[SRC_REF_ADDR]])
+  // CHECK: call %swift.weak* @swift_unknownWeakCopyInit(%swift.weak* [[DEST_REF_ADDR]], %swift.weak* [[SRC_REF_ADDR]])
   // CHECK: [[SRC_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 1
   // CHECK: [[WITNESS:%.*]] = load i8**, i8*** [[SRC_WITNESS_ADDR]], align 8
   // CHECK: [[DEST_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* [[V]], i32 0, i32 1
@@ -164,7 +164,7 @@ entry(%w : $*@sil_weak CP?, %a : $CP?):
 
   // CHECK: [[DEST_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* [[V]], i32 0, i32 0
   // CHECK: [[SRC_REF_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 0
-  // CHECK: call void @swift_unknownWeakCopyAssign(%swift.weak* [[DEST_REF_ADDR]], %swift.weak* [[SRC_REF_ADDR]])
+  // CHECK: call %swift.weak* @swift_unknownWeakCopyAssign(%swift.weak* [[DEST_REF_ADDR]], %swift.weak* [[SRC_REF_ADDR]])
   // CHECK: [[SRC_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 1
   // CHECK: [[WITNESS:%.*]] = load i8**, i8*** [[SRC_WITNESS_ADDR]], align 8
   // CHECK: [[DEST_WITNESS_ADDR:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* [[V]], i32 0, i32 1

test/IRGen/unowned_objc.sil

@@ -58,12 +58,12 @@ bb0(%p : $P, %q : $P):
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 1
   // CHECK-NEXT: store i8** [[PP:%1]], i8*** [[T0]], align 8
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 0
-  // CHECK-NEXT: call void @swift_unknownUnownedInit(%swift.unowned* [[T0]], [[UNKNOWN]]* [[PV:%0]])
+  // CHECK-NEXT: call %swift.unowned* @swift_unknownUnownedInit(%swift.unowned* [[T0]], [[UNKNOWN]]* [[PV:%0]])
   store_unowned %p to [initialization] %x : $*@sil_unowned P
 
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 0
   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 0
-  // CHECK-NEXT: call void @swift_unknownUnownedCopyInit(%swift.unowned* [[T0]], %swift.unowned* [[T1]])
+  // CHECK-NEXT: call %swift.unowned* @swift_unknownUnownedCopyInit(%swift.unowned* [[T0]], %swift.unowned* [[T1]])
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 1
   // CHECK-NEXT: [[WT:%.*]] = load i8**, i8*** [[T0]], align 8
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 1
@@ -81,7 +81,7 @@ bb0(%p : $P, %q : $P):
 
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 0
   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 0
-  // CHECK-NEXT: call void @swift_unknownUnownedCopyAssign(%swift.unowned* [[T0]], %swift.unowned* [[T1]])
+  // CHECK-NEXT: call %swift.unowned* @swift_unknownUnownedCopyAssign(%swift.unowned* [[T0]], %swift.unowned* [[T1]])
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 1
   // CHECK-NEXT: [[WT:%.*]] = load i8**, i8*** [[T0]], align 8
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 1
@@ -91,12 +91,12 @@ bb0(%p : $P, %q : $P):
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 1
   // CHECK-NEXT: store i8** [[QP:%3]], i8*** [[T0]], align 8
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 0
-  // CHECK-NEXT: call void @swift_unknownUnownedAssign(%swift.unowned* [[T0]], [[UNKNOWN]]* [[QV:%2]])
+  // CHECK-NEXT: call %swift.unowned* @swift_unknownUnownedAssign(%swift.unowned* [[T0]], [[UNKNOWN]]* [[QV:%2]])
   store_unowned %q to %y : $*@sil_unowned P
 
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 0
   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 0
-  // CHECK-NEXT: call void @swift_unknownUnownedTakeAssign(%swift.unowned* [[T0]], %swift.unowned* [[T1]])
+  // CHECK-NEXT: call %swift.unowned* @swift_unknownUnownedTakeAssign(%swift.unowned* [[T0]], %swift.unowned* [[T1]])
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 1
   // CHECK-NEXT: [[WT:%.*]] = load i8**, i8*** [[T0]], align 8
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 1
@@ -105,7 +105,7 @@ bb0(%p : $P, %q : $P):
 
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 0
   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 0
-  // CHECK-NEXT: call void @swift_unknownUnownedTakeInit(%swift.unowned* [[T0]], %swift.unowned* [[T1]])
+  // CHECK-NEXT: call %swift.unowned* @swift_unknownUnownedTakeInit(%swift.unowned* [[T0]], %swift.unowned* [[T1]])
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[Y]], i32 0, i32 1
   // CHECK-NEXT: [[WT:%.*]] = load i8**, i8*** [[T0]], align 8
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 1
@@ -121,7 +121,7 @@ bb0(%p : $P, %q : $P):
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 1
   // CHECK-NEXT: store i8** [[TP]], i8*** [[T0]], align 8
   // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[UREF]], [[UREF]]* [[X]], i32 0, i32 0
-  // CHECK-NEXT: call void @swift_unknownUnownedInit(%swift.unowned* [[T0]], [[UNKNOWN]]* [[TV]])
+  // CHECK-NEXT: call %swift.unowned* @swift_unknownUnownedInit(%swift.unowned* [[T0]], [[UNKNOWN]]* [[TV]])
   store_unowned %t1 to [initialization] %x : $*@sil_unowned P
 
   // CHECK-NEXT: call void @swift_unknownRelease([[UNKNOWN]]* [[TV]])

test/IRGen/weak.sil

@@ -76,7 +76,7 @@ bb0(%0 : $*B, %1 : $Optional<P>):
 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds { [[WEAK]], i8** }, { [[WEAK]], i8** }* [[X]], i32 0, i32 1
 // CHECK-NEXT: store i8** [[TMPTAB]], i8*** [[T0]], align 8
 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds { [[WEAK]], i8** }, { [[WEAK]], i8** }* [[X]], i32 0, i32 0
-// CHECK-NEXT: call void @swift_unknownWeakAssign([[WEAK]]* [[T0]], [[UNKNOWN]]* [[TMPOBJ]])
+// CHECK-NEXT: call [[WEAK]]* @swift_unknownWeakAssign([[WEAK]]* [[T0]], [[UNKNOWN]]* [[TMPOBJ]])
 // CHECK: call void @_T0SqWe
 
 sil @test_weak_alloc_stack : $@convention(thin) (Optional<P>) -> () {
@@ -95,7 +95,7 @@ bb0(%0 : $Optional<P>):
 // CHECK: [[T0:%.*]] = getelementptr inbounds { [[WEAK]], i8** }, { [[WEAK]], i8** }* [[X]], i32 0, i32 1
 // CHECK-NEXT: store i8** [[TMPTAB:%.*]], i8*** [[T0]], align 8
 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds { [[WEAK]], i8** }, { [[WEAK]], i8** }* [[X]], i32 0, i32 0
-// CHECK-NEXT: call void @swift_unknownWeakInit([[WEAK]]* [[T0]], [[UNKNOWN]]* [[TMPOBJ:%.*]])
+// CHECK-NEXT: call [[WEAK]]* @swift_unknownWeakInit([[WEAK]]* [[T0]], [[UNKNOWN]]* [[TMPOBJ:%.*]])
 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds { [[WEAK]], i8** }, { [[WEAK]], i8** }* [[X]], i32 0, i32 0
 // CHECK-NEXT: call void @swift_unknownWeakDestroy([[WEAK]]* [[T0]])
 // CHECK-NEXT: bitcast

test/IRGen/weak_class_protocol.sil

@@ -14,7 +14,7 @@ protocol Foo: class { }
 // CHECK:         [[WTABLE_SLOT:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 1
 // CHECK:         store i8** [[WTABLE]], i8*** [[WTABLE_SLOT]], align 8
 // CHECK:         [[INSTANCE_SLOT:%.*]] = getelementptr inbounds { %swift.weak, i8** }, { %swift.weak, i8** }* %0, i32 0, i32 0
-// CHECK-objc:    call void @swift_unknownWeakAssign(%swift.weak* [[INSTANCE_SLOT]], %objc_object* [[INSTANCE]]) {{#[0-9]+}}
+// CHECK-objc:    call %swift.weak* @swift_unknownWeakAssign(%swift.weak* [[INSTANCE_SLOT]], %objc_object* [[INSTANCE]]) {{#[0-9]+}}
 // CHECK-native:  call %swift.weak* @swift_weakAssign(%swift.weak* [[INSTANCE_SLOT]], %swift.refcounted* [[INSTANCE]]) {{#[0-9]+}}
 // CHECK:         ret void
 // CHECK:       }

unittests/runtime/weak.mm

@@ -277,7 +277,8 @@ TEST(WeakTest, simple_objc_and_swift) {
   DestroyedObjCCount = 0;
 
   WeakReference ref1;
-  swift_unknownWeakInit(&ref1, o1);
+  auto res = swift_unknownWeakInit(&ref1, o1);
+  ASSERT_EQ(&ref1, res);
 
   void *tmp = swift_unknownWeakLoadStrong(&ref1);
   ASSERT_EQ(tmp, o1);
@@ -435,7 +436,8 @@ TEST(WeakTest, objc_unowned_copyInit_nil) {
   ASSERT_EQ(nullptr, result);
 
   // ref2 = ref1 (nil -> nil)
-  swift_unknownUnownedCopyInit(&ref2, &ref1);
+  auto res = swift_unknownUnownedCopyInit(&ref2, &ref1);
+  ASSERT_EQ(&ref2, res);
   result = swift_unknownUnownedLoadStrong(&ref1);
   ASSERT_EQ(nullptr, result);
   result = swift_unknownUnownedLoadStrong(&ref2);
@@ -535,7 +537,8 @@ TEST(WeakTest, objc_unowned_takeInit_nil) {
   ASSERT_EQ(nullptr, result);
 
   // ref2 = ref1 (nil -> nil)
-  swift_unknownUnownedTakeInit(&ref2, &ref1);
+  auto res = swift_unknownUnownedTakeInit(&ref2, &ref1);
+  ASSERT_EQ(&ref2, res);
   result = swift_unknownUnownedLoadStrong(&ref2);
   ASSERT_EQ(nullptr, result);
   swift_unknownUnownedDestroy(&ref2);
@@ -638,7 +641,8 @@ TEST(WeakTest, objc_unowned_copyAssign) {
   swift_unknownRelease(result);
 
   // ref1 = ref2 (objc self transition)
-  swift_unknownUnownedCopyAssign(&ref1, &ref2);
+  auto res = swift_unknownUnownedCopyAssign(&ref1, &ref2);
+  ASSERT_EQ(&ref1, res);
   result = swift_unknownUnownedLoadStrong(&ref1);
   ASSERT_EQ(objc1, result);
   swift_unknownRelease(result);
@@ -766,7 +770,8 @@ TEST(WeakTest, objc_unowned_takeAssign) {
   void *result;
 
   // ref1 = objc1
-  swift_unknownUnownedInit(&ref1, objc1);
+  auto res = swift_unknownUnownedInit(&ref1, objc1);
+  ASSERT_EQ(&ref1, res);
   result = swift_unknownUnownedLoadStrong(&ref1);
   ASSERT_EQ(objc1, result);
   swift_unknownRelease(result);
@@ -778,7 +783,8 @@ TEST(WeakTest, objc_unowned_takeAssign) {
   swift_unknownRelease(result);
 
   // ref1 = ref2 (objc self transition)
-  swift_unknownUnownedTakeAssign(&ref1, &ref2);
+  res = swift_unknownUnownedTakeAssign(&ref1, &ref2);
+  ASSERT_EQ(&ref1, res);
   result = swift_unknownUnownedLoadStrong(&ref1);
   ASSERT_EQ(objc1, result);
   swift_unknownRelease(result);
@@ -928,3 +934,34 @@ TEST(WeakTest, objc_unowned_isEqual_DeathTest) {
   swift_unownedDestroy(&ref1);
   swift_unknownUnownedDestroy(&ref2);
 }
+
+TEST(WeakTest, unknownWeak) {
+  void *objc1 = make_objc_object();
+  HeapObject *swift1 = make_swift_object();
+
+  WeakReference ref1;
+  auto res = swift_unknownWeakInit(&ref1, objc1);
+  ASSERT_EQ(&ref1, res);
+
+  WeakReference ref2;
+  res = swift_unknownWeakCopyInit(&ref2, &ref1);
+  ASSERT_EQ(&ref2, res);
+
+  WeakReference ref3; // ref2 dead.
+  res = swift_unknownWeakTakeInit(&ref3, &ref2);
+  ASSERT_EQ(&ref3, res);
+
+  res = swift_unknownWeakAssign(&ref3, swift1);
+  ASSERT_EQ(&ref3, res);
+
+  res = swift_unknownWeakCopyAssign(&ref3, &ref1);
+  ASSERT_EQ(&ref3, res);
+
+  res = swift_unknownWeakTakeAssign(&ref3, &ref1);
+  ASSERT_EQ(&ref3, res);
+
+  swift_unknownWeakDestroy(&ref3);
+
+  swift_release(swift1);
+  swift_unknownRelease(objc1);
+}