averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #11950 from aschwaighofer/runtime_return_dest_2

Browse Source 
runtime: Also return the destination argument of the unknownWeak- and…
This commit is contained in:
Arnold Schwaighofer
2017-09-15 14:54:44 -07:00
committed by GitHub
parent c1b9ff7fd9 8b2fa67799
commit d008e37b13
8 changed files with 201 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
include/swift/Runtime/HeapObject.h
View File

@@ -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) {
swift_weakInit(ref, static_cast<HeapObject *>(value));
static inline WeakReference *swift_unknownWeakInit(WeakReference *ref,
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) {
swift_weakAssign(ref, static_cast<HeapObject *>(value));
static inline WeakReference *swift_unknownWeakAssign(WeakReference *ref,
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);
#else
static inline void swift_unknownWeakCopyInit(WeakReference *dest,
static inline WeakReference *swift_unknownWeakCopyInit(WeakReference *dest,
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);
#else
static inline void swift_unknownWeakTakeInit(WeakReference *dest,
static inline WeakReference *swift_unknownWeakTakeInit(WeakReference *dest,
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);
#else
static inline void swift_unknownWeakCopyAssign(WeakReference *dest,
static inline WeakReference *swift_unknownWeakCopyAssign(WeakReference *dest,
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);
#else
static inline void swift_unknownWeakTakeAssign(WeakReference *dest,
static inline WeakReference *swift_unknownWeakTakeAssign(WeakReference *dest,
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) {
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,
void *value) {
static inline UnownedReference *
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);
#else
static inline void swift_unknownUnownedCopyInit(UnownedReference *dest,
UnownedReference *src) {
static inline UnownedReference *
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);
#else
static inline void swift_unknownUnownedTakeInit(UnownedReference *dest,
UnownedReference *src) {
static inline UnownedReference *
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);
#else
static inline void swift_unknownUnownedCopyAssign(UnownedReference *dest,
UnownedReference *src) {
static inline UnownedReference *
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);
#else
static inline void swift_unknownUnownedTakeAssign(UnownedReference *dest,
UnownedReference *src) {
static inline UnownedReference *
swift_unknownUnownedTakeAssign(UnownedReference *dest, UnownedReference *src) {
swift_unownedTakeAssign(dest, src);
return dest;
}
#endif /* SWIFT_OBJC_INTEROP */

70
include/swift/Runtime/RuntimeFunctions.def
View File

@@ -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,

48
stdlib/public/runtime/SwiftObject.mm
View File

@@ -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,7 +945,7 @@ void swift::swift_unknownUnownedDestroy(UnownedReference *ref) {
}
}
void swift::swift_unknownUnownedCopyInit(UnownedReference *dest,
UnownedReference *swift::swift_unknownUnownedCopyInit(UnownedReference *dest,
UnownedReference *src) {
assert(dest != src);
if (!src->Value) {
@@ -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) {
assert(dest != src);
dest->Value = src->Value;
return dest;
}
void swift::swift_unknownUnownedCopyAssign(UnownedReference *dest,
UnownedReference *swift::swift_unknownUnownedCopyAssign(UnownedReference *dest,
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) {
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) {
return ref->unknownInit(value);
WeakReference *swift::swift_unknownWeakInit(WeakReference *ref, void *value) {
ref->unknownInit(value);
return ref;
}
void swift::swift_unknownWeakAssign(WeakReference *ref, void *value) {
return ref->unknownAssign(value);
WeakReference *swift::swift_unknownWeakAssign(WeakReference *ref, void *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) {
dest->unknownCopyAssign(src);
return dest;
}
void swift::swift_unknownWeakTakeAssign(WeakReference *dest,
WeakReference *swift::swift_unknownWeakTakeAssign(WeakReference *dest,
WeakReference *src) {
dest->unknownTakeAssign(src);
return dest;
}
// SWIFT_OBJC_INTEROP

14
test/IRGen/existentials_objc.sil
View File

@@ -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

14
test/IRGen/unowned_objc.sil
View File

@@ -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]])

4
test/IRGen/weak.sil
View File

@@ -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

2
test/IRGen/weak_class_protocol.sil
View File

@@ -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: }

49
unittests/runtime/weak.mm
View File

@@ -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);
}