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

[runtime] Remove TwoWordPair and use the Swift calling convention instead. (#13299)

Browse Source
This commit is contained in:
Thomas Roughton
2017-12-08 16:27:24 +13:00
committed by Greg Parker
parent f767040b4a
commit c5bf2ec553
20 changed files with 104 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/swift/Runtime/Config.h
View File

@@ -121,8 +121,8 @@
// convention. // convention.
#define SWIFT_LLVM_CC(CC) SWIFT_LLVM_CC_##CC #define SWIFT_LLVM_CC(CC) SWIFT_LLVM_CC_##CC
// Currently, RuntimeFunction.def uses the following calling conventions: // Currently, RuntimeFunctions.def uses the following calling conventions:
// DefaultCC, RegisterPreservingCC. // DefaultCC, RegisterPreservingCC, SwiftCC.
// If new runtime calling conventions are added later, they need to be mapped // If new runtime calling conventions are added later, they need to be mapped
// here to something appropriate. // here to something appropriate.
@@ -131,6 +131,8 @@
#define SWIFT_CC_DefaultCC_IMPL SWIFT_CC_c #define SWIFT_CC_DefaultCC_IMPL SWIFT_CC_c
#define SWIFT_LLVM_CC_DefaultCC llvm::CallingConv::C #define SWIFT_LLVM_CC_DefaultCC llvm::CallingConv::C
#define SWIFT_CC_SwiftCC SWIFT_CC_swift
#define SWIFT_LLVM_CC_RegisterPreservingCC llvm::CallingConv::PreserveMost #define SWIFT_LLVM_CC_RegisterPreservingCC llvm::CallingConv::PreserveMost
#if SWIFT_USE_SWIFTCALL #if SWIFT_USE_SWIFTCALL

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

@@ -97,66 +97,10 @@ HeapObject *swift_initStaticObject(HeapMetadata const *metadata,
SWIFT_RUNTIME_EXPORT SWIFT_RUNTIME_EXPORT
void swift_verifyEndOfLifetime(HeapObject *object); void swift_verifyEndOfLifetime(HeapObject *object);
/// A structure that's two pointers in size. struct BoxPair {
/// HeapObject *object;
/// C functions can use the TwoWordPair::Return type to return a value in OpaqueValue *buffer;
/// two registers, compatible with Swift's calling convention for tuples
/// and structs of two word-sized elements.
template<typename A, typename B>
struct TwoWordPair {
A first;
B second;
TwoWordPair() = default;
TwoWordPair(A first, B second);
// FIXME: rdar://16257592 arm codegen doesn't call swift_allocBox correctly.
// Structs are returned indirectly on these platforms, but we want to return
// in registers, so cram the result into an unsigned long long.
// Use an enum class with implicit conversions so we don't dirty C callers
// too much.
#if __arm__ || __i386__ || defined(__CYGWIN__) || defined(_MSC_VER)
#if defined(__CYGWIN__)
enum class Return : unsigned __int128 {};
#else
enum class Return : unsigned long long {};
#endif
operator Return() const {
union {
TwoWordPair value;
Return mangled;
} reinterpret = {*this};
return reinterpret.mangled;
}
/*implicit*/ TwoWordPair(Return r) {
union {
Return mangled;
TwoWordPair value;
} reinterpret = {r};
*this = reinterpret.value;
}
#else
using Return = TwoWordPair;
#endif
}; };
template<typename A, typename B>
inline TwoWordPair<A,B>::TwoWordPair(A first, B second)
: first(first), second(second)
{
static_assert(sizeof(A) == sizeof(void*),
"first type must be word-sized");
static_assert(sizeof(B) == sizeof(void*),
"second type must be word-sized");
static_assert(alignof(TwoWordPair) == alignof(void*),
"pair must be word-aligned");
}
using BoxPair = TwoWordPair<HeapObject *, OpaqueValue *>;
/// Allocates a heap object that can contain a value of the given type. /// Allocates a heap object that can contain a value of the given type.
/// Returns a Box structure containing a HeapObject* pointer to the /// Returns a Box structure containing a HeapObject* pointer to the
@@ -165,19 +109,19 @@ using BoxPair = TwoWordPair<HeapObject *, OpaqueValue *>;
/// appropriate to store a value of the given type. /// appropriate to store a value of the given type.
/// The heap object has an initial retain count of 1, and its metadata is set /// The heap object has an initial retain count of 1, and its metadata is set
/// such that destroying the heap object destroys the contained value. /// such that destroying the heap object destroys the contained value.
SWIFT_RUNTIME_EXPORT SWIFT_CC(swift) SWIFT_RUNTIME_EXPORT
BoxPair::Return swift_allocBox(Metadata const *type); BoxPair swift_allocBox(Metadata const *type);
SWIFT_RUNTIME_EXPORT SWIFT_CC(swift) SWIFT_RUNTIME_EXPORT
BoxPair::Return (*_swift_allocBox)(Metadata const *type); BoxPair (*_swift_allocBox)(Metadata const *type);
/// Performs a uniqueness check on the pointer to a box structure. If the check /// Performs a uniqueness check on the pointer to a box structure. If the check
/// fails allocates a new box and stores the pointer in the buffer. /// fails allocates a new box and stores the pointer in the buffer.
/// ///
/// if (!isUnique(buffer[0])) /// if (!isUnique(buffer[0]))
/// buffer[0] = swift_allocBox(type) /// buffer[0] = swift_allocBox(type)
SWIFT_RUNTIME_EXPORT SWIFT_CC(swift) SWIFT_RUNTIME_EXPORT
BoxPair::Return swift_makeBoxUnique(OpaqueValue *buffer, Metadata const *type, BoxPair swift_makeBoxUnique(OpaqueValue *buffer, Metadata const *type,
size_t alignMask); size_t alignMask);
/// Returns the address of a heap object representing all empty box types. /// Returns the address of a heap object representing all empty box types.
@@ -1242,11 +1186,16 @@ static inline bool swift_unknownUnownedIsEqual(UnownedReference *ref,
#endif /* SWIFT_OBJC_INTEROP */ #endif /* SWIFT_OBJC_INTEROP */
struct TypeNamePair {
const char *data;
uintptr_t length;
};
/// Return the name of a Swift type represented by a metadata object. /// Return the name of a Swift type represented by a metadata object.
/// func _getTypeName(_ type: Any.Type, qualified: Bool) /// func _getTypeName(_ type: Any.Type, qualified: Bool)
/// -> (UnsafePointer<UInt8>, Int) /// -> (UnsafePointer<UInt8>, Int)
SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_API SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_API
TwoWordPair<const char *, uintptr_t>::Return TypeNamePair
swift_getTypeName(const Metadata *type, bool qualified); swift_getTypeName(const Metadata *type, bool qualified);
} // end namespace swift } // end namespace swift

2
include/swift/Runtime/InstrumentsSupport.h
View File

@@ -26,7 +26,7 @@ HeapObject *(*_swift_allocObject)(HeapMetadata const *metadata,
size_t requiredAlignmentMask); size_t requiredAlignmentMask);
SWIFT_RUNTIME_EXPORT SWIFT_RUNTIME_EXPORT
BoxPair::Return (*_swift_allocBox)(Metadata const *type); BoxPair (*swift_allocBox)(Metadata const *type);
SWIFT_RUNTIME_EXPORT SWIFT_RUNTIME_EXPORT
HeapObject *(*_swift_retain)(HeapObject *object); HeapObject *(*_swift_retain)(HeapObject *object);

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

@@ -50,7 +50,7 @@
#endif #endif
FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(AllocBox, swift_allocBox, FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(AllocBox, swift_allocBox,
_swift_allocBox, _swift_allocBox_, DefaultCC, _swift_allocBox, _swift_allocBox_, SwiftCC,
RETURNS(RefCountedPtrTy, OpaquePtrTy), RETURNS(RefCountedPtrTy, OpaquePtrTy),
ARGS(TypeMetadataPtrTy), ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind)) ATTRS(NoUnwind))
@@ -58,7 +58,7 @@ FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(AllocBox, swift_allocBox,
// BoxPair swift_makeBoxUnique(OpaqueValue *buffer, Metadata *type, size_t alignMask); // BoxPair swift_makeBoxUnique(OpaqueValue *buffer, Metadata *type, size_t alignMask);
FUNCTION(MakeBoxUnique, FUNCTION(MakeBoxUnique,
swift_makeBoxUnique, swift_makeBoxUnique,
DefaultCC, SwiftCC,
RETURNS(RefCountedPtrTy, OpaquePtrTy), RETURNS(RefCountedPtrTy, OpaquePtrTy),
ARGS(OpaquePtrTy, TypeMetadataPtrTy, SizeTy), ARGS(OpaquePtrTy, TypeMetadataPtrTy, SizeTy),
ATTRS(NoUnwind)) ATTRS(NoUnwind))
@@ -1332,7 +1332,7 @@ FUNCTION(DeletedMethodError, swift_deletedMethodError, C_CC,
ARGS(), ARGS(),
ATTRS(NoUnwind)) ATTRS(NoUnwind))
FUNCTION(AllocError, swift_allocError, C_CC, FUNCTION(AllocError, swift_allocError, SwiftCC,
RETURNS(ErrorPtrTy, OpaquePtrTy), RETURNS(ErrorPtrTy, OpaquePtrTy),
ARGS(TypeMetadataPtrTy, WitnessTablePtrTy, OpaquePtrTy, Int1Ty), ARGS(TypeMetadataPtrTy, WitnessTablePtrTy, OpaquePtrTy, Int1Ty),
ATTRS(NoUnwind)) ATTRS(NoUnwind))

4
lib/IRGen/IRGenModule.cpp
View File

@@ -610,6 +610,10 @@ llvm::Constant *swift::getWrapperFn(llvm::Module &Module,
RETURNS, ARGS, ATTRS) \ RETURNS, ARGS, ATTRS) \
FUNCTION_IMPL(ID, NAME, CC, QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS)) FUNCTION_IMPL(ID, NAME, CC, QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS))
#define FUNCTION_WITH_GLOBAL_SYMBOL_FOR_CONV_SwiftCC(ID, NAME, SYMBOL, CC, \
RETURNS, ARGS, ATTRS) \
FUNCTION_IMPL(ID, NAME, CC, QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS))
#define FUNCTION_WITH_GLOBAL_SYMBOL_FOR_CONV_RegisterPreservingCC( \ #define FUNCTION_WITH_GLOBAL_SYMBOL_FOR_CONV_RegisterPreservingCC( \
ID, NAME, SYMBOL, CC, RETURNS, ARGS, ATTRS) \ ID, NAME, SYMBOL, CC, RETURNS, ARGS, ATTRS) \
FUNCTION_WITH_GLOBAL_SYMBOL_IMPL(ID, NAME, SYMBOL, CC, QUOTE(RETURNS), \ FUNCTION_WITH_GLOBAL_SYMBOL_IMPL(ID, NAME, SYMBOL, CC, QUOTE(RETURNS), \

6
stdlib/public/SDK/Foundation/CheckClass.mm
View File

@@ -59,9 +59,9 @@ namespace {
template <size_t N> template <size_t N>
StringRefLite(const char (&staticStr)[N]) : data(staticStr), length(N) {} StringRefLite(const char (&staticStr)[N]) : data(staticStr), length(N) {}
StringRefLite(swift::TwoWordPair<const char *, uintptr_t>::Return rawValue) StringRefLite(swift::TypeNamePair rawValue)
: data(swift::TwoWordPair<const char *, uintptr_t>(rawValue).first), : data(rawValue.data),
length(swift::TwoWordPair<const char *, uintptr_t>(rawValue).second){} length(rawValue.length){}
NS_RETURNS_RETAINED NS_RETURNS_RETAINED
NSString *newNSStringNoCopy() const { NSString *newNSStringNoCopy() const {

13
stdlib/public/runtime/Casting.cpp
View File

@@ -113,9 +113,8 @@ std::string swift::nameForMetadata(const Metadata *type,
return result; return result;
} }
TwoWordPair<const char *, uintptr_t>::Return TypeNamePair
swift::swift_getTypeName(const Metadata *type, bool qualified) { swift::swift_getTypeName(const Metadata *type, bool qualified) {
using Pair = TwoWordPair<const char *, uintptr_t>;
using Key = llvm::PointerIntPair<const Metadata *, 1, bool>; using Key = llvm::PointerIntPair<const Metadata *, 1, bool>;
static StaticReadWriteLock TypeNameCacheLock; static StaticReadWriteLock TypeNameCacheLock;
@@ -132,7 +131,7 @@ swift::swift_getTypeName(const Metadata *type, bool qualified) {
auto found = cache.find(key); auto found = cache.find(key);
if (found != cache.end()) { if (found != cache.end()) {
auto result = found->second; auto result = found->second;
return Pair{result.first, result.second}; return TypeNamePair{result.first, result.second};
} }
} }
@@ -145,7 +144,7 @@ swift::swift_getTypeName(const Metadata *type, bool qualified) {
auto found = cache.find(key); auto found = cache.find(key);
if (found != cache.end()) { if (found != cache.end()) {
auto result = found->second; auto result = found->second;
return Pair{result.first, result.second}; return TypeNamePair{result.first, result.second};
} }
// Build the metadata name. // Build the metadata name.
@@ -157,7 +156,7 @@ swift::swift_getTypeName(const Metadata *type, bool qualified) {
result[size] = 0; result[size] = 0;
cache.insert({key, {result, size}}); cache.insert({key, {result, size}});
return Pair{result, size}; return TypeNamePair{result, size};
} }
} }
@@ -955,7 +954,7 @@ static bool _dynamicCastToExistential(OpaqueValue *dest,
(canConsumeDynamicValue && (flags & DynamicCastFlags::TakeOnSuccess)); (canConsumeDynamicValue && (flags & DynamicCastFlags::TakeOnSuccess));
BoxPair destBox = swift_allocError(srcDynamicType, errorWitness, BoxPair destBox = swift_allocError(srcDynamicType, errorWitness,
srcDynamicValue, isTake); srcDynamicValue, isTake);
*destBoxAddr = reinterpret_cast<SwiftError*>(destBox.first); *destBoxAddr = reinterpret_cast<SwiftError*>(destBox.object);
maybeDeallocateSource(true); maybeDeallocateSource(true);
return true; return true;
} }
@@ -1977,7 +1976,7 @@ static id dynamicCastValueToNSError(OpaqueValue *src,
BoxPair errorBox = swift_allocError(srcType, srcErrorWitness, src, BoxPair errorBox = swift_allocError(srcType, srcErrorWitness, src,
/*isTake*/ flags & DynamicCastFlags::TakeOnSuccess); /*isTake*/ flags & DynamicCastFlags::TakeOnSuccess);
return _swift_stdlib_bridgeErrorToNSError((SwiftError*)errorBox.first); return _swift_stdlib_bridgeErrorToNSError((SwiftError*)errorBox.object);
} }
#endif #endif

8
stdlib/public/runtime/ErrorObject.h
View File

@@ -171,10 +171,10 @@ struct SwiftError : SwiftErrorHeader {
/// copied (or taken if \c isTake is true) into the newly-allocated error box. /// copied (or taken if \c isTake is true) into the newly-allocated error box.
/// If value is null, the box's contents will be left uninitialized, and /// If value is null, the box's contents will be left uninitialized, and
/// \c isTake should be false. /// \c isTake should be false.
SWIFT_RUNTIME_STDLIB_API SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_API
BoxPair::Return swift_allocError(const Metadata *type, BoxPair swift_allocError(const Metadata *type,
const WitnessTable *errorConformance, const WitnessTable *errorConformance,
OpaqueValue *value, bool isTake); OpaqueValue *value, bool isTake);
/// Deallocate an error object whose contained object has already been /// Deallocate an error object whose contained object has already been
/// destroyed. /// destroyed.

2
stdlib/public/runtime/ErrorObject.mm
View File

@@ -161,7 +161,7 @@ static Class getSwiftNativeNSErrorClass() {
} }
/// Allocate a catchable error object. /// Allocate a catchable error object.
BoxPair::Return BoxPair
swift::swift_allocError(const Metadata *type, swift::swift_allocError(const Metadata *type,
const WitnessTable *errorConformance, const WitnessTable *errorConformance,
OpaqueValue *initialValue, OpaqueValue *initialValue,

2
stdlib/public/runtime/ErrorObjectNative.cpp
View File

@@ -64,7 +64,7 @@ static const FullMetadata<HeapMetadata> ErrorMetadata{
Metadata{MetadataKind::ErrorObject}, Metadata{MetadataKind::ErrorObject},
}; };
BoxPair::Return BoxPair
swift::swift_allocError(const swift::Metadata *type, swift::swift_allocError(const swift::Metadata *type,
const swift::WitnessTable *errorConformance, const swift::WitnessTable *errorConformance,
OpaqueValue *initialValue, OpaqueValue *initialValue,

10
stdlib/public/runtime/HeapObject.cpp
View File

@@ -203,11 +203,11 @@ public:
static SimpleGlobalCache<BoxCacheEntry> Boxes; static SimpleGlobalCache<BoxCacheEntry> Boxes;
BoxPair::Return swift::swift_allocBox(const Metadata *type) { BoxPair swift::swift_allocBox(const Metadata *type) {
return SWIFT_RT_ENTRY_REF(swift_allocBox)(type); return SWIFT_RT_ENTRY_REF(swift_allocBox)(type);
} }
BoxPair::Return swift::swift_makeBoxUnique(OpaqueValue *buffer, const Metadata *type, BoxPair swift::swift_makeBoxUnique(OpaqueValue *buffer, const Metadata *type,
size_t alignMask) { size_t alignMask) {
auto *inlineBuffer = reinterpret_cast<ValueBuffer*>(buffer); auto *inlineBuffer = reinterpret_cast<ValueBuffer*>(buffer);
HeapObject *box = reinterpret_cast<HeapObject *>(inlineBuffer->PrivateData[0]); HeapObject *box = reinterpret_cast<HeapObject *>(inlineBuffer->PrivateData[0]);
@@ -219,8 +219,8 @@ BoxPair::Return swift::swift_makeBoxUnique(OpaqueValue *buffer, const Metadata *
auto *oldObjectAddr = reinterpret_cast<OpaqueValue *>( auto *oldObjectAddr = reinterpret_cast<OpaqueValue *>(
reinterpret_cast<char *>(box) + headerOffset); reinterpret_cast<char *>(box) + headerOffset);
// Copy the data. // Copy the data.
type->vw_initializeWithCopy(refAndObjectAddr.second, oldObjectAddr); type->vw_initializeWithCopy(refAndObjectAddr.buffer, oldObjectAddr);
inlineBuffer->PrivateData[0] = refAndObjectAddr.first; inlineBuffer->PrivateData[0] = refAndObjectAddr.object;
// Release ownership of the old box. // Release ownership of the old box.
swift_release(box); swift_release(box);
return refAndObjectAddr; return refAndObjectAddr;
@@ -234,7 +234,7 @@ BoxPair::Return swift::swift_makeBoxUnique(OpaqueValue *buffer, const Metadata *
SWIFT_RT_ENTRY_IMPL_VISIBILITY SWIFT_RT_ENTRY_IMPL_VISIBILITY
extern "C" extern "C"
BoxPair::Return SWIFT_RT_ENTRY_IMPL(swift_allocBox)(const Metadata *type) { BoxPair SWIFT_RT_ENTRY_IMPL(swift_allocBox)(const Metadata *type) {
// Get the heap metadata for the box. // Get the heap metadata for the box.
auto metadata = &Boxes.getOrInsert(type).first->Data; auto metadata = &Boxes.getOrInsert(type).first->Data;

8
stdlib/public/runtime/Metadata.cpp
View File

@@ -636,8 +636,8 @@ static OpaqueValue *tuple_allocateBuffer(ValueBuffer *buffer,
if (IsInline) if (IsInline)
return reinterpret_cast<OpaqueValue*>(buffer); return reinterpret_cast<OpaqueValue*>(buffer);
BoxPair refAndValueAddr(swift_allocBox(metatype)); BoxPair refAndValueAddr(swift_allocBox(metatype));
*reinterpret_cast<HeapObject **>(buffer) = refAndValueAddr.first; *reinterpret_cast<HeapObject **>(buffer) = refAndValueAddr.object;
return refAndValueAddr.second; return refAndValueAddr.buffer;
} }
/// Generic tuple value witness for 'destroy'. /// Generic tuple value witness for 'destroy'.
@@ -2542,8 +2542,8 @@ template <> OpaqueValue *Metadata::allocateBoxForExistentialIn(ValueBuffer *buff
// Allocate the box. // Allocate the box.
BoxPair refAndValueAddr(swift_allocBox(this)); BoxPair refAndValueAddr(swift_allocBox(this));
buffer->PrivateData[0] = refAndValueAddr.first; buffer->PrivateData[0] = refAndValueAddr.object;
return refAndValueAddr.second; return refAndValueAddr.buffer;
} }
template <> OpaqueValue *Metadata::allocateBufferIn(ValueBuffer *buffer) const { template <> OpaqueValue *Metadata::allocateBufferIn(ValueBuffer *buffer) const {

16
stdlib/public/runtime/Reflection.mm
View File

@@ -633,21 +633,21 @@ void swift_EnumMirror_subscript(String *outString,
BoxPair pair = swift_allocBox(boxType); BoxPair pair = swift_allocBox(boxType);
type->vw_destructiveProjectEnumData(const_cast<OpaqueValue *>(value)); type->vw_destructiveProjectEnumData(const_cast<OpaqueValue *>(value));
boxType->vw_initializeWithCopy(pair.second, const_cast<OpaqueValue *>(value)); boxType->vw_initializeWithCopy(pair.buffer, const_cast<OpaqueValue *>(value));
type->vw_destructiveInjectEnumTag(const_cast<OpaqueValue *>(value), type->vw_destructiveInjectEnumTag(const_cast<OpaqueValue *>(value),
(int) (tag - Description.getNumPayloadCases())); (int) (tag - Description.getNumPayloadCases()));
swift_release(owner); swift_release(owner);
owner = pair.first; owner = pair.object;
value = pair.second; value = pair.buffer;
// If the payload is indirect, we need to jump through the box to get it. // If the payload is indirect, we need to jump through the box to get it.
if (indirect) { if (indirect) {
owner = *reinterpret_cast<HeapObject * const *>(value); owner = *reinterpret_cast<HeapObject * const *>(value);
value = swift_projectBox(const_cast<HeapObject *>(owner)); value = swift_projectBox(const_cast<HeapObject *>(owner));
swift_retain(owner); swift_retain(owner);
swift_release(pair.first); swift_release(pair.object);
} }
new (outString) String(getFieldName(Description.CaseNames, tag)); new (outString) String(getFieldName(Description.CaseNames, tag));
@@ -1035,12 +1035,12 @@ MagicMirror::MagicMirror(OpaqueValue *value, const Metadata *T,
BoxPair box = swift_allocBox(T); BoxPair box = swift_allocBox(T);
if (take) if (take)
T->vw_initializeWithTake(box.second, value); T->vw_initializeWithTake(box.buffer, value);
else else
T->vw_initializeWithCopy(box.second, value); T->vw_initializeWithCopy(box.buffer, value);
std::tie(T, Self, MirrorWitness) = getImplementationForType(T, box.second); std::tie(T, Self, MirrorWitness) = getImplementationForType(T, box.buffer);
Data = {box.first, box.second, T}; Data = {box.object, box.buffer, T};
} }
/// MagicMirror ownership-sharing subvalue constructor. /// MagicMirror ownership-sharing subvalue constructor.

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

@@ -1423,10 +1423,13 @@ bool swift::swift_isUniquelyReferencedOrPinned_nonNull_native(
return object->refCounts.isUniquelyReferencedOrPinned(); return object->refCounts.isUniquelyReferencedOrPinned();
} }
using ClassExtents = TwoWordPair<size_t, size_t>; struct ClassExtents {
size_t negative;
size_t positive;
};
SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
ClassExtents::Return ClassExtents
_getSwiftClassInstanceExtents(const Metadata *c) { _getSwiftClassInstanceExtents(const Metadata *c) {
assert(c && c->isClassObject()); assert(c && c->isClassObject());
auto metaData = c->getClassObject(); auto metaData = c->getClassObject();
@@ -1439,7 +1442,7 @@ _getSwiftClassInstanceExtents(const Metadata *c) {
#if SWIFT_OBJC_INTEROP #if SWIFT_OBJC_INTEROP
SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
ClassExtents::Return ClassExtents
_getObjCClassInstanceExtents(const ClassMetadata* c) { _getObjCClassInstanceExtents(const ClassMetadata* c) {
// Pure ObjC classes never have negative extents. // Pure ObjC classes never have negative extents.
if (c->isPureObjC()) if (c->isPureObjC())

4
stdlib/public/runtime/SwiftValue.mm
View File

@@ -366,10 +366,10 @@ static NSString *getValueDescription(_SwiftValue *self) {
return getSwiftValueTypeMetadata(self); return getSwiftValueTypeMetadata(self);
} }
- (NSString *)_swiftTypeName { - (NSString *)_swiftTypeName {
TwoWordPair<const char *, uintptr_t> typeName TypeNamePair typeName
= swift_getTypeName(getSwiftValueTypeMetadata(self), true); = swift_getTypeName(getSwiftValueTypeMetadata(self), true);
return [NSString stringWithUTF8String: typeName.first]; return [NSString stringWithUTF8String: typeName.data];
} }
- (const OpaqueValue *)_swiftValue { - (const OpaqueValue *)_swiftValue {
return getValueFromSwiftValue(self).second; return getValueFromSwiftValue(self).second;

4
test/IRGen/boxed_existential.sil
View File

@@ -21,7 +21,7 @@ entry(%e : $Error):
// CHECK-LABEL: define{{( protected)?}} swiftcc %swift.error* @alloc_boxed_existential(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.Error) // CHECK-LABEL: define{{( protected)?}} swiftcc %swift.error* @alloc_boxed_existential(%swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.Error)
sil @alloc_boxed_existential : $@convention(thin) <T: Error> (@in T) -> @owned Error { sil @alloc_boxed_existential : $@convention(thin) <T: Error> (@in T) -> @owned Error {
entry(%x : $*T): entry(%x : $*T):
// CHECK: [[BOX_PAIR:%.*]] = call { %swift.error*, %swift.opaque* } @swift_allocError(%swift.type* %T, i8** %T.Error, %swift.opaque* null, i1 false) // CHECK: [[BOX_PAIR:%.*]] = call swiftcc { %swift.error*, %swift.opaque* } @swift_allocError(%swift.type* %T, i8** %T.Error, %swift.opaque* null, i1 false)
// CHECK: [[BOX:%.*]] = extractvalue { %swift.error*, %swift.opaque* } [[BOX_PAIR]], 0 // CHECK: [[BOX:%.*]] = extractvalue { %swift.error*, %swift.opaque* } [[BOX_PAIR]], 0
// CHECK: [[ADDR:%.*]] = extractvalue { %swift.error*, %swift.opaque* } [[BOX_PAIR]], 1 // CHECK: [[ADDR:%.*]] = extractvalue { %swift.error*, %swift.opaque* } [[BOX_PAIR]], 1
%b = alloc_existential_box $Error, $T %b = alloc_existential_box $Error, $T
@@ -40,7 +40,7 @@ struct SomeError: Error {
// CHECK-LABEL: define{{( protected)?}} swiftcc %swift.error* @alloc_boxed_existential_concrete // CHECK-LABEL: define{{( protected)?}} swiftcc %swift.error* @alloc_boxed_existential_concrete
sil @alloc_boxed_existential_concrete : $@convention(thin) (@owned SomeError) -> @owned Error { sil @alloc_boxed_existential_concrete : $@convention(thin) (@owned SomeError) -> @owned Error {
entry(%x : $SomeError): entry(%x : $SomeError):
// CHECK: [[BOX_PAIR:%.*]] = call { %swift.error*, %swift.opaque* } @swift_allocError(%swift.type* {{.*}} @_T017boxed_existential9SomeErrorVMf, {{.*}}, i8** {{%.*|@_T017boxed_existential9SomeErrorVs0D0AAWP}}, %swift.opaque* null, i1 false) // CHECK: [[BOX_PAIR:%.*]] = call swiftcc { %swift.error*, %swift.opaque* } @swift_allocError(%swift.type* {{.*}} @_T017boxed_existential9SomeErrorVMf, {{.*}}, i8** {{%.*|@_T017boxed_existential9SomeErrorVs0D0AAWP}}, %swift.opaque* null, i1 false)
// CHECK: [[BOX:%.*]] = extractvalue { %swift.error*, %swift.opaque* } [[BOX_PAIR]], 0 // CHECK: [[BOX:%.*]] = extractvalue { %swift.error*, %swift.opaque* } [[BOX_PAIR]], 0
// CHECK: [[OPAQUE_ADDR:%.*]] = extractvalue { %swift.error*, %swift.opaque* } [[BOX_PAIR]], 1 // CHECK: [[OPAQUE_ADDR:%.*]] = extractvalue { %swift.error*, %swift.opaque* } [[BOX_PAIR]], 1
// CHECK: [[ADDR:%.*]] = bitcast %swift.opaque* [[OPAQUE_ADDR]] to %T17boxed_existential9SomeErrorV* // CHECK: [[ADDR:%.*]] = bitcast %swift.opaque* [[OPAQUE_ADDR]] to %T17boxed_existential9SomeErrorV*

2
test/IRGen/closure.swift
View File

@@ -49,7 +49,7 @@ func b<T : Ordinable>(seq seq: T) -> (Int) -> Int {
func captures_tuple<T, U>(x x: (T, U)) -> () -> (T, U) { func captures_tuple<T, U>(x x: (T, U)) -> () -> (T, U) {
// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getTupleTypeMetadata2(%swift.type* %T, %swift.type* %U, i8* null, i8** null) // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getTupleTypeMetadata2(%swift.type* %T, %swift.type* %U, i8* null, i8** null)
// CHECK-NOT: @swift_getTupleTypeMetadata2 // CHECK-NOT: @swift_getTupleTypeMetadata2
// CHECK: [[BOX:%.*]] = call { %swift.refcounted*, %swift.opaque* } @swift_allocBox(%swift.type* [[METADATA]]) // CHECK: [[BOX:%.*]] = call swiftcc { %swift.refcounted*, %swift.opaque* } @swift_allocBox(%swift.type* [[METADATA]])
// CHECK: [[ADDR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[BOX]], 1 // CHECK: [[ADDR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[BOX]], 1
// CHECK: bitcast %swift.opaque* [[ADDR]] to <{}>* // CHECK: bitcast %swift.opaque* [[ADDR]] to <{}>*
return {x} return {x}

4
test/IRGen/existentials_opaque_boxed.sil
View File

@@ -54,7 +54,7 @@ entry(%0 : $*T):
// CHECK: ret %swift.opaque* [[EXISTENTIAL_BUFFER_OPAQUE]] // CHECK: ret %swift.opaque* [[EXISTENTIAL_BUFFER_OPAQUE]]
// //
// CHECK:allocateBox: // CHECK:allocateBox:
// CHECK: [[CALL:%.*]] = call { %swift.refcounted*, %swift.opaque* } @swift_allocBox(%swift.type* [[METATYPE]]) // CHECK: [[CALL:%.*]] = call swiftcc { %swift.refcounted*, %swift.opaque* } @swift_allocBox(%swift.type* [[METATYPE]])
// CHECK: [[BOX:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[CALL]], 0 // CHECK: [[BOX:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[CALL]], 0
// CHECK: [[ADDR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[CALL]], 1 // CHECK: [[ADDR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[CALL]], 1
// CHECK: [[ADDR_IN_BUFFER:%.*]] = bitcast [{{(24|12)}} x i8]* [[EXISTENTIAL_BUFFER]] to %swift.refcounted** // CHECK: [[ADDR_IN_BUFFER:%.*]] = bitcast [{{(24|12)}} x i8]* [[EXISTENTIAL_BUFFER]] to %swift.refcounted**
@@ -221,7 +221,7 @@ bb0(%0 : $*Existential):
// CHECK: boxed: // CHECK: boxed:
// CHECK: [[ALIGNMASK:%.*]] = and {{(i64|i32)}} [[FLAGS]], 65535 // CHECK: [[ALIGNMASK:%.*]] = and {{(i64|i32)}} [[FLAGS]], 65535
// CHECK: [[OPAQUE_ADDR:%.*]] = bitcast [{{(24|12)}} x i8]* %0 to %swift.opaque* // CHECK: [[OPAQUE_ADDR:%.*]] = bitcast [{{(24|12)}} x i8]* %0 to %swift.opaque*
// CHECK: [[REFANDADDR:%.*]] = call { %swift.refcounted*, %swift.opaque* } @swift_makeBoxUnique(%swift.opaque* [[OPAQUE_ADDR]], %swift.type* %1, {{(i64|i32)}} [[ALIGNMASK]]) // CHECK: [[REFANDADDR:%.*]] = call swiftcc { %swift.refcounted*, %swift.opaque* } @swift_makeBoxUnique(%swift.opaque* [[OPAQUE_ADDR]], %swift.type* %1, {{(i64|i32)}} [[ALIGNMASK]])
// CHECK: [[REF:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[REFANDADDR]], 0 // CHECK: [[REF:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[REFANDADDR]], 0
// CHECK: [[ADDR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[REFANDADDR]], 1 // CHECK: [[ADDR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[REFANDADDR]], 1
// CHECK: ret %swift.opaque* [[ADDR]] // CHECK: ret %swift.opaque* [[ADDR]]

4
test/IRGen/typed_boxes.sil
View File

@@ -121,7 +121,7 @@ sil @take_t : $@convention(thin) <T> (@in T) -> ()
sil @dyn_box_a : $@convention(thin) <T> () -> () { sil @dyn_box_a : $@convention(thin) <T> () -> () {
entry: entry:
// CHECK: [[METADATA:%.*]] = call %swift.type* @_T011typed_boxes3DynVMa(%swift.type* %T) // CHECK: [[METADATA:%.*]] = call %swift.type* @_T011typed_boxes3DynVMa(%swift.type* %T)
// CHECK: [[ALLOC:%.*]] = call { %swift.refcounted*, %swift.opaque* } @swift_allocBox(%swift.type* [[METADATA]]) // CHECK: [[ALLOC:%.*]] = call swiftcc { %swift.refcounted*, %swift.opaque* } @swift_allocBox(%swift.type* [[METADATA]])
// CHECK: [[BOX:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[ALLOC]], 0 // CHECK: [[BOX:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[ALLOC]], 0
// CHECK: [[PTR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[ALLOC]], 1 // CHECK: [[PTR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[ALLOC]], 1
%a = alloc_box $<τ_0_0> { var τ_0_0 } <Dyn<T>> %a = alloc_box $<τ_0_0> { var τ_0_0 } <Dyn<T>>
@@ -138,7 +138,7 @@ entry:
// CHECK-LABEL: define{{( protected)?}} swiftcc void @dyn_box_b // CHECK-LABEL: define{{( protected)?}} swiftcc void @dyn_box_b
sil @dyn_box_b : $@convention(thin) <T> () -> () { sil @dyn_box_b : $@convention(thin) <T> () -> () {
entry: entry:
// CHECK: [[ALLOC:%.*]] = call { %swift.refcounted*, %swift.opaque* } @swift_allocBox(%swift.type* %T) // CHECK: [[ALLOC:%.*]] = call swiftcc { %swift.refcounted*, %swift.opaque* } @swift_allocBox(%swift.type* %T)
// CHECK: [[BOX:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[ALLOC]], 0 // CHECK: [[BOX:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[ALLOC]], 0
// CHECK: [[PTR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[ALLOC]], 1 // CHECK: [[PTR:%.*]] = extractvalue { %swift.refcounted*, %swift.opaque* } [[ALLOC]], 1
%a = alloc_box $<τ_0_0> { var τ_0_0 } <T> %a = alloc_box $<τ_0_0> { var τ_0_0 } <T>

60
unittests/runtime/Metadata.cpp
View File

@@ -1222,23 +1222,23 @@ TEST(TestOpaqueExistentialBox, test_assignWithCopy_indirect_indirect) {
Metadata *metadata2 = &testMetadata2.base; Metadata *metadata2 = &testMetadata2.base;
auto refAndObjectAddr = BoxPair(swift_allocBox(metadata)); auto refAndObjectAddr = BoxPair(swift_allocBox(metadata));
swift_retain(refAndObjectAddr.first); swift_retain(refAndObjectAddr.object);
auto refAndObjectAddr2 = BoxPair(swift_allocBox(metadata2)); auto refAndObjectAddr2 = BoxPair(swift_allocBox(metadata2));
struct { struct {
ValueBuffer buffer; ValueBuffer buffer;
Metadata *type; Metadata *type;
uintptr_t canary; uintptr_t canary;
} existBox{{{refAndObjectAddr.first, nullptr, nullptr}}, metadata, 0x5A5A5A5AU}, } existBox{{{refAndObjectAddr.object, nullptr, nullptr}}, metadata, 0x5A5A5A5AU},
existBox2{{{refAndObjectAddr2.first, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U}; existBox2{{{refAndObjectAddr2.object, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U};
anyVWT->assignWithCopy(reinterpret_cast<OpaqueValue *>(&existBox), anyVWT->assignWithCopy(reinterpret_cast<OpaqueValue *>(&existBox),
reinterpret_cast<OpaqueValue *>(&existBox2), any); reinterpret_cast<OpaqueValue *>(&existBox2), any);
EXPECT_EQ(existBox.type, metadata2); EXPECT_EQ(existBox.type, metadata2);
EXPECT_EQ(existBox.canary, 0x5A5A5A5AU); EXPECT_EQ(existBox.canary, 0x5A5A5A5AU);
EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.first); EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.object);
EXPECT_EQ(swift_retainCount(refAndObjectAddr.first), 1u); EXPECT_EQ(swift_retainCount(refAndObjectAddr.object), 1u);
EXPECT_EQ(swift_retainCount(refAndObjectAddr2.first), 2u); EXPECT_EQ(swift_retainCount(refAndObjectAddr2.object), 2u);
} }
TEST(TestOpaqueExistentialBox, test_assignWithTake_indirect_indirect) { TEST(TestOpaqueExistentialBox, test_assignWithTake_indirect_indirect) {
@@ -1258,23 +1258,23 @@ TEST(TestOpaqueExistentialBox, test_assignWithTake_indirect_indirect) {
Metadata *metadata2 = &testMetadata2.base; Metadata *metadata2 = &testMetadata2.base;
auto refAndObjectAddr = BoxPair(swift_allocBox(metadata)); auto refAndObjectAddr = BoxPair(swift_allocBox(metadata));
swift_retain(refAndObjectAddr.first); swift_retain(refAndObjectAddr.object);
auto refAndObjectAddr2 = BoxPair(swift_allocBox(metadata2)); auto refAndObjectAddr2 = BoxPair(swift_allocBox(metadata2));
struct { struct {
ValueBuffer buffer; ValueBuffer buffer;
Metadata *type; Metadata *type;
uintptr_t canary; uintptr_t canary;
} existBox{{{refAndObjectAddr.first, nullptr, nullptr}}, metadata, 0x5A5A5A5AU}, } existBox{{{refAndObjectAddr.object, nullptr, nullptr}}, metadata, 0x5A5A5A5AU},
existBox2{{{refAndObjectAddr2.first, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U}; existBox2{{{refAndObjectAddr2.object, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U};
anyVWT->assignWithTake(reinterpret_cast<OpaqueValue *>(&existBox), anyVWT->assignWithTake(reinterpret_cast<OpaqueValue *>(&existBox),
reinterpret_cast<OpaqueValue *>(&existBox2), any); reinterpret_cast<OpaqueValue *>(&existBox2), any);
EXPECT_EQ(existBox.type, metadata2); EXPECT_EQ(existBox.type, metadata2);
EXPECT_EQ(existBox.canary, 0x5A5A5A5AU); EXPECT_EQ(existBox.canary, 0x5A5A5A5AU);
EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.first); EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.object);
EXPECT_EQ(swift_retainCount(refAndObjectAddr.first), 1u); EXPECT_EQ(swift_retainCount(refAndObjectAddr.object), 1u);
EXPECT_EQ(swift_retainCount(refAndObjectAddr2.first), 1u); EXPECT_EQ(swift_retainCount(refAndObjectAddr2.object), 1u);
} }
TEST(TestOpaqueExistentialBox, test_assignWithCopy_pod_indirect) { TEST(TestOpaqueExistentialBox, test_assignWithCopy_pod_indirect) {
@@ -1299,15 +1299,15 @@ TEST(TestOpaqueExistentialBox, test_assignWithCopy_pod_indirect) {
Metadata *type; Metadata *type;
uintptr_t canary; uintptr_t canary;
} existBox{{{nullptr, nullptr, nullptr}}, metadata, 0x5A5A5A5AU}, } existBox{{{nullptr, nullptr, nullptr}}, metadata, 0x5A5A5A5AU},
existBox2{{{refAndObjectAddr2.first, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U}; existBox2{{{refAndObjectAddr2.object, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U};
anyVWT->assignWithCopy(reinterpret_cast<OpaqueValue *>(&existBox), anyVWT->assignWithCopy(reinterpret_cast<OpaqueValue *>(&existBox),
reinterpret_cast<OpaqueValue *>(&existBox2), any); reinterpret_cast<OpaqueValue *>(&existBox2), any);
EXPECT_EQ(existBox.type, metadata2); EXPECT_EQ(existBox.type, metadata2);
EXPECT_EQ(existBox.canary, 0x5A5A5A5AU); EXPECT_EQ(existBox.canary, 0x5A5A5A5AU);
EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.first); EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.object);
EXPECT_EQ(swift_retainCount(refAndObjectAddr2.first), 2u); EXPECT_EQ(swift_retainCount(refAndObjectAddr2.object), 2u);
} }
TEST(TestOpaqueExistentialBox, test_assignWithTake_pod_indirect) { TEST(TestOpaqueExistentialBox, test_assignWithTake_pod_indirect) {
@@ -1332,15 +1332,15 @@ TEST(TestOpaqueExistentialBox, test_assignWithTake_pod_indirect) {
Metadata *type; Metadata *type;
uintptr_t canary; uintptr_t canary;
} existBox{{{nullptr, nullptr, nullptr}}, metadata, 0x5A5A5A5AU}, } existBox{{{nullptr, nullptr, nullptr}}, metadata, 0x5A5A5A5AU},
existBox2{{{refAndObjectAddr2.first, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U}; existBox2{{{refAndObjectAddr2.object, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U};
anyVWT->assignWithTake(reinterpret_cast<OpaqueValue *>(&existBox), anyVWT->assignWithTake(reinterpret_cast<OpaqueValue *>(&existBox),
reinterpret_cast<OpaqueValue *>(&existBox2), any); reinterpret_cast<OpaqueValue *>(&existBox2), any);
EXPECT_EQ(existBox.type, metadata2); EXPECT_EQ(existBox.type, metadata2);
EXPECT_EQ(existBox.canary, 0x5A5A5A5AU); EXPECT_EQ(existBox.canary, 0x5A5A5A5AU);
EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.first); EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.object);
EXPECT_EQ(swift_retainCount(refAndObjectAddr2.first), 1u); EXPECT_EQ(swift_retainCount(refAndObjectAddr2.object), 1u);
} }
TEST(TestOpaqueExistentialBox, test_assignWithCopy_indirect_pod) { TEST(TestOpaqueExistentialBox, test_assignWithCopy_indirect_pod) {
@@ -1361,13 +1361,13 @@ TEST(TestOpaqueExistentialBox, test_assignWithCopy_indirect_pod) {
auto refAndObjectAddr2 = BoxPair(swift_allocBox(metadata2)); auto refAndObjectAddr2 = BoxPair(swift_allocBox(metadata2));
void *someAddr = &anyVWT; void *someAddr = &anyVWT;
swift_retain(refAndObjectAddr2.first); swift_retain(refAndObjectAddr2.object);
struct { struct {
ValueBuffer buffer; ValueBuffer buffer;
Metadata *type; Metadata *type;
uintptr_t canary; uintptr_t canary;
} existBox2{{{someAddr, nullptr, someAddr}}, metadata, 0x5A5A5A5AU}, } existBox2{{{someAddr, nullptr, someAddr}}, metadata, 0x5A5A5A5AU},
existBox{{{refAndObjectAddr2.first, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U}; existBox{{{refAndObjectAddr2.object, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U};
anyVWT->assignWithCopy(reinterpret_cast<OpaqueValue *>(&existBox), anyVWT->assignWithCopy(reinterpret_cast<OpaqueValue *>(&existBox),
reinterpret_cast<OpaqueValue *>(&existBox2), any); reinterpret_cast<OpaqueValue *>(&existBox2), any);
@@ -1377,7 +1377,7 @@ TEST(TestOpaqueExistentialBox, test_assignWithCopy_indirect_pod) {
EXPECT_EQ(existBox.buffer.PrivateData[0], someAddr); EXPECT_EQ(existBox.buffer.PrivateData[0], someAddr);
EXPECT_EQ(existBox.buffer.PrivateData[1], nullptr); EXPECT_EQ(existBox.buffer.PrivateData[1], nullptr);
EXPECT_EQ(existBox.buffer.PrivateData[2], someAddr); EXPECT_EQ(existBox.buffer.PrivateData[2], someAddr);
EXPECT_EQ(swift_retainCount(refAndObjectAddr2.first), 1u); EXPECT_EQ(swift_retainCount(refAndObjectAddr2.object), 1u);
} }
TEST(TestOpaqueExistentialBox, test_assignWithTake_indirect_pod) { TEST(TestOpaqueExistentialBox, test_assignWithTake_indirect_pod) {
@@ -1398,13 +1398,13 @@ TEST(TestOpaqueExistentialBox, test_assignWithTake_indirect_pod) {
auto refAndObjectAddr2 = BoxPair(swift_allocBox(metadata2)); auto refAndObjectAddr2 = BoxPair(swift_allocBox(metadata2));
void *someAddr = &anyVWT; void *someAddr = &anyVWT;
swift_retain(refAndObjectAddr2.first); swift_retain(refAndObjectAddr2.object);
struct { struct {
ValueBuffer buffer; ValueBuffer buffer;
Metadata *type; Metadata *type;
uintptr_t canary; uintptr_t canary;
} existBox2{{{someAddr, nullptr, someAddr}}, metadata, 0x5A5A5A5AU}, } existBox2{{{someAddr, nullptr, someAddr}}, metadata, 0x5A5A5A5AU},
existBox{{{refAndObjectAddr2.first, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U}; existBox{{{refAndObjectAddr2.object, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U};
anyVWT->assignWithTake(reinterpret_cast<OpaqueValue *>(&existBox), anyVWT->assignWithTake(reinterpret_cast<OpaqueValue *>(&existBox),
reinterpret_cast<OpaqueValue *>(&existBox2), any); reinterpret_cast<OpaqueValue *>(&existBox2), any);
@@ -1414,7 +1414,7 @@ TEST(TestOpaqueExistentialBox, test_assignWithTake_indirect_pod) {
EXPECT_EQ(existBox.buffer.PrivateData[0], someAddr); EXPECT_EQ(existBox.buffer.PrivateData[0], someAddr);
EXPECT_EQ(existBox.buffer.PrivateData[1], nullptr); EXPECT_EQ(existBox.buffer.PrivateData[1], nullptr);
EXPECT_EQ(existBox.buffer.PrivateData[2], someAddr); EXPECT_EQ(existBox.buffer.PrivateData[2], someAddr);
EXPECT_EQ(swift_retainCount(refAndObjectAddr2.first), 1u); EXPECT_EQ(swift_retainCount(refAndObjectAddr2.object), 1u);
} }
TEST(TestOpaqueExistentialBox, test_initWithCopy_pod) { TEST(TestOpaqueExistentialBox, test_initWithCopy_pod) {
@@ -1507,15 +1507,15 @@ TEST(TestOpaqueExistentialBox, test_initWithCopy_indirect) {
Metadata *type; Metadata *type;
uintptr_t canary; uintptr_t canary;
} existBox{{{nullptr, nullptr, nullptr}}, metadata, 0x5A5A5A5AU}, } existBox{{{nullptr, nullptr, nullptr}}, metadata, 0x5A5A5A5AU},
existBox2{{{refAndObjectAddr2.first, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U}; existBox2{{{refAndObjectAddr2.object, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U};
anyVWT->initializeWithCopy(reinterpret_cast<OpaqueValue *>(&existBox), anyVWT->initializeWithCopy(reinterpret_cast<OpaqueValue *>(&existBox),
reinterpret_cast<OpaqueValue *>(&existBox2), any); reinterpret_cast<OpaqueValue *>(&existBox2), any);
EXPECT_EQ(existBox.type, metadata2); EXPECT_EQ(existBox.type, metadata2);
EXPECT_EQ(existBox.canary, 0x5A5A5A5AU); EXPECT_EQ(existBox.canary, 0x5A5A5A5AU);
EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.first); EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.object);
EXPECT_EQ(swift_retainCount(refAndObjectAddr2.first), 2u); EXPECT_EQ(swift_retainCount(refAndObjectAddr2.object), 2u);
} }
TEST(TestOpaqueExistentialBox, test_initWithTake_indirect) { TEST(TestOpaqueExistentialBox, test_initWithTake_indirect) {
@@ -1540,13 +1540,13 @@ TEST(TestOpaqueExistentialBox, test_initWithTake_indirect) {
Metadata *type; Metadata *type;
uintptr_t canary; uintptr_t canary;
} existBox{{{nullptr, nullptr, nullptr}}, metadata, 0x5A5A5A5AU}, } existBox{{{nullptr, nullptr, nullptr}}, metadata, 0x5A5A5A5AU},
existBox2{{{refAndObjectAddr2.first, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U}; existBox2{{{refAndObjectAddr2.object, nullptr, nullptr}}, metadata2, 0xB5A5A5A5U};
anyVWT->initializeWithTake(reinterpret_cast<OpaqueValue *>(&existBox), anyVWT->initializeWithTake(reinterpret_cast<OpaqueValue *>(&existBox),
reinterpret_cast<OpaqueValue *>(&existBox2), any); reinterpret_cast<OpaqueValue *>(&existBox2), any);
EXPECT_EQ(existBox.type, metadata2); EXPECT_EQ(existBox.type, metadata2);
EXPECT_EQ(existBox.canary, 0x5A5A5A5AU); EXPECT_EQ(existBox.canary, 0x5A5A5A5AU);
EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.first); EXPECT_EQ(existBox.buffer.PrivateData[0], refAndObjectAddr2.object);
EXPECT_EQ(swift_retainCount(refAndObjectAddr2.first), 1u); EXPECT_EQ(swift_retainCount(refAndObjectAddr2.object), 1u);
} }