[apple/objc4.git] / test / taggedPointers.m

// TEST_CFLAGS -fobjc-weak

#include "test.h"
#include <objc/runtime.h>
#include <objc/objc-internal.h>
#include <objc/objc-gdb.h>
#include <dlfcn.h>
#import <Foundation/NSObject.h>

#if OBJC_HAVE_TAGGED_POINTERS

#if !__x86_64__  &&  !__arm64__
#error wrong architecture for tagged pointers
#endif

static BOOL didIt;

@interface WeakContainer : NSObject
{
  @public
    __weak id weaks[10000];
}
@end
@implementation WeakContainer
-(void) dealloc {
    for (unsigned int i = 0; i < sizeof(weaks)/sizeof(weaks[0]); i++) {
        testassert(weaks[i] == nil);
    }
    SUPER_DEALLOC();
}
@end

OBJC_ROOT_CLASS
@interface TaggedBaseClass60
@end

@implementation TaggedBaseClass60
-(id) self { return self; }

+ (void) initialize {
}

- (void) instanceMethod {
    didIt = YES;
}

- (uintptr_t) taggedValue {
    return _objc_getTaggedPointerValue((__bridge void*)self);
}

- (struct stret) stret: (struct stret) aStruct {
    return aStruct;
}

- (long double) fpret: (long double) aValue {
    return aValue;
}


-(void) dealloc {
    fail("TaggedBaseClass60 dealloc called!");
}

static void *
retain_fn(void *self, SEL _cmd __unused) {
    void * (*fn)(void *) = (typeof(fn))_objc_rootRetain;
    return fn(self); 
}

static void 
release_fn(void *self, SEL _cmd __unused) {
    void (*fn)(void *) = (typeof(fn))_objc_rootRelease;
    fn(self); 
}

static void *
autorelease_fn(void *self, SEL _cmd __unused) { 
    void * (*fn)(void *) = (typeof(fn))_objc_rootAutorelease;
    return fn(self); 
}

static unsigned long 
retaincount_fn(void *self, SEL _cmd __unused) { 
    unsigned long (*fn)(void *) = (typeof(fn))_objc_rootRetainCount;
    return fn(self); 
}

+(void) load {
    class_addMethod(self, sel_registerName("retain"), (IMP)retain_fn, "");
    class_addMethod(self, sel_registerName("release"), (IMP)release_fn, "");
    class_addMethod(self, sel_registerName("autorelease"), (IMP)autorelease_fn, "");
    class_addMethod(self, sel_registerName("retainCount"), (IMP)retaincount_fn, "");    
}

@end

@interface TaggedSubclass52: TaggedBaseClass60
@end

@implementation TaggedSubclass52

- (void) instanceMethod {
    return [super instanceMethod];
}

- (uintptr_t) taggedValue {
    return [super taggedValue];
}

- (struct stret) stret: (struct stret) aStruct {
    return [super stret: aStruct];
}

- (long double) fpret: (long double) aValue {
    return [super fpret: aValue];
}
@end

@interface TaggedNSObjectSubclass : NSObject
@end

@implementation TaggedNSObjectSubclass

- (void) instanceMethod {
    didIt = YES;
}

- (uintptr_t) taggedValue {
    return _objc_getTaggedPointerValue((__bridge void*)self);
}

- (struct stret) stret: (struct stret) aStruct {
    return aStruct;
}

- (long double) fpret: (long double) aValue {
    return aValue;
}
@end

void testTaggedPointerValue(Class cls, objc_tag_index_t tag, uintptr_t value)
{
    void *taggedAddress = _objc_makeTaggedPointer(tag, value);
    testprintf("obj %p, tag %p, value %p\n", 
               taggedAddress, (void*)tag, (void*)value);

    bool ext = (tag >= OBJC_TAG_First52BitPayload);

    // _objc_makeTaggedPointer must quietly mask out of range values for now
    if (ext) {
        value = (value << 12) >> 12;
    } else {
        value = (value << 4) >> 4;
    }

    testassert(_objc_isTaggedPointer(taggedAddress));
    testassert(_objc_getTaggedPointerTag(taggedAddress) == tag);
    testassert(_objc_getTaggedPointerValue(taggedAddress) == value);
    testassert(objc_debug_taggedpointer_obfuscator != 0);

    if (ext) {
        uintptr_t slot = ((uintptr_t)taggedAddress >> objc_debug_taggedpointer_ext_slot_shift) & objc_debug_taggedpointer_ext_slot_mask;
        testassert(objc_debug_taggedpointer_ext_classes[slot] == cls);
        uintptr_t deobfuscated = (uintptr_t)taggedAddress ^ objc_debug_taggedpointer_obfuscator;
        testassert(((deobfuscated << objc_debug_taggedpointer_ext_payload_lshift) >> objc_debug_taggedpointer_ext_payload_rshift) == value);
    } 
    else {
        testassert(((uintptr_t)taggedAddress & objc_debug_taggedpointer_mask) == objc_debug_taggedpointer_mask);
        uintptr_t slot = ((uintptr_t)taggedAddress >> objc_debug_taggedpointer_slot_shift) & objc_debug_taggedpointer_slot_mask;
        testassert(objc_debug_taggedpointer_classes[slot] == cls);
        uintptr_t deobfuscated = (uintptr_t)taggedAddress ^ objc_debug_taggedpointer_obfuscator;
        testassert(((deobfuscated << objc_debug_taggedpointer_payload_lshift) >> objc_debug_taggedpointer_payload_rshift) == value);
    }

    id taggedPointer = (__bridge id)taggedAddress;
    testassert(!object_isClass(taggedPointer));
    testassert(object_getClass(taggedPointer) == cls);
    testassert([taggedPointer taggedValue] == value);

    didIt = NO;
    [taggedPointer instanceMethod];
    testassert(didIt);
    
    struct stret orig = STRET_RESULT;
    testassert(stret_equal(orig, [taggedPointer stret: orig]));
    
    long double dblvalue = 3.14156789;
    testassert(dblvalue == [taggedPointer fpret: dblvalue]);

    objc_setAssociatedObject(taggedPointer, (__bridge void *)taggedPointer, taggedPointer, OBJC_ASSOCIATION_RETAIN);
    testassert(objc_getAssociatedObject(taggedPointer, (__bridge void *)taggedPointer) == taggedPointer);
    objc_setAssociatedObject(taggedPointer, (__bridge void *)taggedPointer, nil, OBJC_ASSOCIATION_RETAIN);
    testassert(objc_getAssociatedObject(taggedPointer, (__bridge void *)taggedPointer) == nil);
}

void testGenericTaggedPointer(objc_tag_index_t tag, Class cls)
{
    testassert(cls);
    testprintf("%s\n", class_getName(cls));

    testTaggedPointerValue(cls, tag, 0);
    testTaggedPointerValue(cls, tag, 1UL << 0);
    testTaggedPointerValue(cls, tag, 1UL << 1);
    testTaggedPointerValue(cls, tag, 1UL << 50);
    testTaggedPointerValue(cls, tag, 1UL << 51);
    testTaggedPointerValue(cls, tag, 1UL << 52);
    testTaggedPointerValue(cls, tag, 1UL << 58);
    testTaggedPointerValue(cls, tag, 1UL << 59);
    testTaggedPointerValue(cls, tag, ~0UL >> 4);
    testTaggedPointerValue(cls, tag, ~0UL);

    // Tagged pointers should bypass refcount tables and autorelease pools
    // and weak reference tables
    WeakContainer *w = [WeakContainer new];

    // force sidetable retain of the WeakContainer before leak checking
    objc_retain(w);
#if !__has_feature(objc_arc)
    // prime method caches before leak checking
    id taggedPointer = (id)_objc_makeTaggedPointer(tag, 1234);
    [taggedPointer retain];
    [taggedPointer release];
    [taggedPointer autorelease];
#endif
    // prime is_debug() before leak checking
    (void)is_debug();

    leak_mark();
    testonthread(^(void) {
        for (uintptr_t i = 0; i < sizeof(w->weaks)/sizeof(w->weaks[0]); i++) {
            id o = (__bridge id)_objc_makeTaggedPointer(tag, i);
            testassert(object_getClass(o) == cls);
            
            id result = WEAK_STORE(w->weaks[i], o);
            testassert(result == o);
            testassert(w->weaks[i] == o);
            
            result = WEAK_LOAD(w->weaks[i]);
            testassert(result == o);
            
            uintptr_t rc = _objc_rootRetainCount(o);
            testassert(rc != 0);
            _objc_rootRelease(o);  testassert(_objc_rootRetainCount(o) == rc);
            _objc_rootRelease(o);  testassert(_objc_rootRetainCount(o) == rc);
            _objc_rootRetain(o);   testassert(_objc_rootRetainCount(o) == rc);
            _objc_rootRetain(o);   testassert(_objc_rootRetainCount(o) == rc);
            _objc_rootRetain(o);   testassert(_objc_rootRetainCount(o) == rc);
#if !__has_feature(objc_arc)
            [o release];  testassert(_objc_rootRetainCount(o) == rc);
            [o release];  testassert(_objc_rootRetainCount(o) == rc);
            [o retain];   testassert(_objc_rootRetainCount(o) == rc);
            [o retain];   testassert(_objc_rootRetainCount(o) == rc);
            [o retain];   testassert(_objc_rootRetainCount(o) == rc);
            objc_release(o);  testassert(_objc_rootRetainCount(o) == rc);
            objc_release(o);  testassert(_objc_rootRetainCount(o) == rc);
            objc_retain(o);   testassert(_objc_rootRetainCount(o) == rc);
            objc_retain(o);   testassert(_objc_rootRetainCount(o) == rc);
            objc_retain(o);   testassert(_objc_rootRetainCount(o) == rc);
#endif
            PUSH_POOL {
                testassert(_objc_rootRetainCount(o) == rc);
                _objc_rootAutorelease(o);
                testassert(_objc_rootRetainCount(o) == rc);
#if !__has_feature(objc_arc)
                [o autorelease];
                testassert(_objc_rootRetainCount(o) == rc);
                objc_autorelease(o);
                testassert(_objc_rootRetainCount(o) == rc);
                objc_retainAutorelease(o);
                testassert(_objc_rootRetainCount(o) == rc);
                objc_autoreleaseReturnValue(o);
                testassert(_objc_rootRetainCount(o) == rc);
                objc_retainAutoreleaseReturnValue(o);
                testassert(_objc_rootRetainCount(o) == rc);
                objc_retainAutoreleasedReturnValue(o);
                testassert(_objc_rootRetainCount(o) == rc);
#endif
            } POP_POOL;
            testassert(_objc_rootRetainCount(o) == rc);
        }
    });
    if (is_debug()) {
        // libobjc's debug lock checking makes this leak check fail
        testwarn("skipping leak check with debug libobjc build");
    } else {
        leak_check(0);
    }
    for (uintptr_t i = 0; i < 10000; i++) {
        testassert(w->weaks[i] != NULL);
        WEAK_STORE(w->weaks[i], NULL);
        testassert(w->weaks[i] == NULL);
        testassert(WEAK_LOAD(w->weaks[i]) == NULL);
    }
    objc_release(w);
    RELEASE_VAR(w);
}

#if OBJC_SPLIT_TAGGED_POINTERS
void testConstantTaggedPointerRoundTrip(void *ptr)
{
    uintptr_t tagged = (uintptr_t)ptr | objc_debug_constant_cfstring_tag_bits;
    void *untagged = _objc_getTaggedPointerRawPointerValue((void *)tagged);
    testassert(ptr == untagged);
}

void testConstantTaggedPointers(void)
{
    testConstantTaggedPointerRoundTrip(0);
    testConstantTaggedPointerRoundTrip((void *)sizeof(void *));
    testConstantTaggedPointerRoundTrip((void *)(MACH_VM_MAX_ADDRESS - sizeof(void *)));
}
#endif

int main()
{
    testassert(objc_debug_taggedpointer_mask != 0);
    testassert(_objc_taggedPointersEnabled());

    PUSH_POOL {
        // Avoid CF's tagged pointer tags because of rdar://11368528

        // Reserved slot should be nil until the 
        // first extended tag is registered.
        // This test no longer works because XPC now uses extended tags.
#define HAVE_XPC_TAGS 1

        uintptr_t extSlot = (~objc_debug_taggedpointer_obfuscator >> objc_debug_taggedpointer_slot_shift) & objc_debug_taggedpointer_slot_mask;
        Class extPlaceholder = objc_getClass("__NSUnrecognizedTaggedPointer");
        testassert(extPlaceholder != nil);

#if !HAVE_XPC_TAGS
        testassert(objc_debug_taggedpointer_classes[extSlot] == nil);
#endif

        _objc_registerTaggedPointerClass(OBJC_TAG_1, 
                                         objc_getClass("TaggedBaseClass60"));
        testGenericTaggedPointer(OBJC_TAG_1, 
                                 objc_getClass("TaggedBaseClass60"));
        
#if !HAVE_XPC_TAGS
        testassert(objc_debug_taggedpointer_classes[extSlot] == nil);
#endif

        _objc_registerTaggedPointerClass(OBJC_TAG_First52BitPayload, 
                                         objc_getClass("TaggedSubclass52"));
        testGenericTaggedPointer(OBJC_TAG_First52BitPayload, 
                                 objc_getClass("TaggedSubclass52"));

        testassert(objc_debug_taggedpointer_classes[extSlot] == extPlaceholder);
        
        _objc_registerTaggedPointerClass(OBJC_TAG_NSManagedObjectID, 
                                         objc_getClass("TaggedNSObjectSubclass"));
        testGenericTaggedPointer(OBJC_TAG_NSManagedObjectID, 
                                 objc_getClass("TaggedNSObjectSubclass"));

#if OBJC_SPLIT_TAGGED_POINTERS
        testConstantTaggedPointers();
#endif
    } POP_POOL;

    succeed(__FILE__);
}

// OBJC_HAVE_TAGGED_POINTERS
#else
// not OBJC_HAVE_TAGGED_POINTERS

// Tagged pointers not supported.

int main() 
{
    testassert(objc_debug_taggedpointer_mask == 0);
    succeed(__FILE__);
}

#endif
Commit	Line	Data
13ba007e A	1	// TEST_CFLAGS -fobjc-weak
	2
	3	#include "test.h"
	4	#include <objc/runtime.h>
	5	#include <objc/objc-internal.h>
	6	#include <objc/objc-gdb.h>
	7	#include <dlfcn.h>
	8	#import <Foundation/NSObject.h>
	9
	10	#if OBJC_HAVE_TAGGED_POINTERS
	11
	12	#if !__x86_64__ && !__arm64__
	13	#error wrong architecture for tagged pointers
	14	#endif
	15
	16	static BOOL didIt;
	17
	18	@interface WeakContainer : NSObject
	19	{
	20	@public
	21	__weak id weaks[10000];
	22	}
	23	@end
	24	@implementation WeakContainer
	25	-(void) dealloc {
	26	for (unsigned int i = 0; i < sizeof(weaks)/sizeof(weaks[0]); i++) {
	27	testassert(weaks[i] == nil);
	28	}
	29	SUPER_DEALLOC();
	30	}
	31	@end
	32
	33	OBJC_ROOT_CLASS
	34	@interface TaggedBaseClass60
	35	@end
	36
	37	@implementation TaggedBaseClass60
	38	-(id) self { return self; }
	39
	40	+ (void) initialize {
	41	}
	42
	43	- (void) instanceMethod {
	44	didIt = YES;
	45	}
	46
	47	- (uintptr_t) taggedValue {
	48	return _objc_getTaggedPointerValue((__bridge void*)self);
	49	}
	50
	51	- (struct stret) stret: (struct stret) aStruct {
	52	return aStruct;
	53	}
	54
	55	- (long double) fpret: (long double) aValue {
	56	return aValue;
	57	}
	58
	59
	60	-(void) dealloc {
	61	fail("TaggedBaseClass60 dealloc called!");
	62	}
	63
	64	static void *
65	retain_fn(void *self, SEL _cmd __unused) {
66	void * (fn)(void ) = (typeof(fn))_objc_rootRetain;
67	return fn(self);
68	}
69
70	static void
71	release_fn(void *self, SEL _cmd __unused) {
72	void (fn)(void ) = (typeof(fn))_objc_rootRelease;
73	fn(self);
74	}
75
76	static void *
77	autorelease_fn(void *self, SEL _cmd __unused) {
78	void * (fn)(void ) = (typeof(fn))_objc_rootAutorelease;
79	return fn(self);
80	}
81
82	static unsigned long
83	retaincount_fn(void *self, SEL _cmd __unused) {
84	unsigned long (fn)(void ) = (typeof(fn))_objc_rootRetainCount;
85	return fn(self);
86	}
87
88	+(void) load {
89	class_addMethod(self, sel_registerName("retain"), (IMP)retain_fn, "");
90	class_addMethod(self, sel_registerName("release"), (IMP)release_fn, "");
91	class_addMethod(self, sel_registerName("autorelease"), (IMP)autorelease_fn, "");
92	class_addMethod(self, sel_registerName("retainCount"), (IMP)retaincount_fn, "");
93	}
94
95	@end
96
97	@interface TaggedSubclass52: TaggedBaseClass60
98	@end
99
100	@implementation TaggedSubclass52
101
102	- (void) instanceMethod {
103	return [super instanceMethod];
104	}
105
106	- (uintptr_t) taggedValue {
107	return [super taggedValue];
108	}
109
110	- (struct stret) stret: (struct stret) aStruct {
111	return [super stret: aStruct];
112	}
113
114	- (long double) fpret: (long double) aValue {
115	return [super fpret: aValue];
116	}
117	@end
118
119	@interface TaggedNSObjectSubclass : NSObject
120	@end
121
122	@implementation TaggedNSObjectSubclass
123
124	- (void) instanceMethod {
125	didIt = YES;
126	}
127
128	- (uintptr_t) taggedValue {
129	return _objc_getTaggedPointerValue((__bridge void*)self);
130	}
131
132	- (struct stret) stret: (struct stret) aStruct {
133	return aStruct;
134	}
135
136	- (long double) fpret: (long double) aValue {
137	return aValue;
138	}
139	@end
140
141	void testTaggedPointerValue(Class cls, objc_tag_index_t tag, uintptr_t value)
142	{
143	void *taggedAddress = _objc_makeTaggedPointer(tag, value);
144	testprintf("obj %p, tag %p, value %p\n",
145	taggedAddress, (void)tag, (void)value);
146
147	bool ext = (tag >= OBJC_TAG_First52BitPayload);
148
149	// _objc_makeTaggedPointer must quietly mask out of range values for now
150	if (ext) {
151	value = (value << 12) >> 12;
152	} else {
153	value = (value << 4) >> 4;
154	}
155
156	testassert(_objc_isTaggedPointer(taggedAddress));
157	testassert(_objc_getTaggedPointerTag(taggedAddress) == tag);
158	testassert(_objc_getTaggedPointerValue(taggedAddress) == value);
159	testassert(objc_debug_taggedpointer_obfuscator != 0);
160
161	if (ext) {
162	uintptr_t slot = ((uintptr_t)taggedAddress >> objc_debug_taggedpointer_ext_slot_shift) & objc_debug_taggedpointer_ext_slot_mask;
163	testassert(objc_debug_taggedpointer_ext_classes[slot] == cls);
164	uintptr_t deobfuscated = (uintptr_t)taggedAddress ^ objc_debug_taggedpointer_obfuscator;
165	testassert(((deobfuscated << objc_debug_taggedpointer_ext_payload_lshift) >> objc_debug_taggedpointer_ext_payload_rshift) == value);
166	}
167	else {
168	testassert(((uintptr_t)taggedAddress & objc_debug_taggedpointer_mask) == objc_debug_taggedpointer_mask);
169	uintptr_t slot = ((uintptr_t)taggedAddress >> objc_debug_taggedpointer_slot_shift) & objc_debug_taggedpointer_slot_mask;
170	testassert(objc_debug_taggedpointer_classes[slot] == cls);
171	uintptr_t deobfuscated = (uintptr_t)taggedAddress ^ objc_debug_taggedpointer_obfuscator;
172	testassert(((deobfuscated << objc_debug_taggedpointer_payload_lshift) >> objc_debug_taggedpointer_payload_rshift) == value);
173	}
174
175	id taggedPointer = (__bridge id)taggedAddress;
176	testassert(!object_isClass(taggedPointer));
177	testassert(object_getClass(taggedPointer) == cls);
178	testassert([taggedPointer taggedValue] == value);
179
180	didIt = NO;
181	[taggedPointer instanceMethod];
182	testassert(didIt);
183
184	struct stret orig = STRET_RESULT;
185	testassert(stret_equal(orig, [taggedPointer stret: orig]));
186
187	long double dblvalue = 3.14156789;
188	testassert(dblvalue == [taggedPointer fpret: dblvalue]);
189
190	objc_setAssociatedObject(taggedPointer, (__bridge void *)taggedPointer, taggedPointer, OBJC_ASSOCIATION_RETAIN);
191	testassert(objc_getAssociatedObject(taggedPointer, (__bridge void *)taggedPointer) == taggedPointer);
192	objc_setAssociatedObject(taggedPointer, (__bridge void *)taggedPointer, nil, OBJC_ASSOCIATION_RETAIN);
193	testassert(objc_getAssociatedObject(taggedPointer, (__bridge void *)taggedPointer) == nil);
194	}
195
196	void testGenericTaggedPointer(objc_tag_index_t tag, Class cls)
197	{
198	testassert(cls);
199	testprintf("%s\n", class_getName(cls));
200
201	testTaggedPointerValue(cls, tag, 0);
202	testTaggedPointerValue(cls, tag, 1UL << 0);
203	testTaggedPointerValue(cls, tag, 1UL << 1);
204	testTaggedPointerValue(cls, tag, 1UL << 50);
205	testTaggedPointerValue(cls, tag, 1UL << 51);
206	testTaggedPointerValue(cls, tag, 1UL << 52);
207	testTaggedPointerValue(cls, tag, 1UL << 58);
208	testTaggedPointerValue(cls, tag, 1UL << 59);
209	testTaggedPointerValue(cls, tag, ~0UL >> 4);
210	testTaggedPointerValue(cls, tag, ~0UL);
211
212	// Tagged pointers should bypass refcount tables and autorelease pools
213	// and weak reference tables
214	WeakContainer *w = [WeakContainer new];
215
216	// force sidetable retain of the WeakContainer before leak checking
217	objc_retain(w);
218	#if !__has_feature(objc_arc)
219	// prime method caches before leak checking
220	id taggedPointer = (id)_objc_makeTaggedPointer(tag, 1234);
221	[taggedPointer retain];
222	[taggedPointer release];
223	[taggedPointer autorelease];
224	#endif
225	// prime is_debug() before leak checking
226	(void)is_debug();
227
228	leak_mark();
229	testonthread(^(void) {
230	for (uintptr_t i = 0; i < sizeof(w->weaks)/sizeof(w->weaks[0]); i++) {
231	id o = (__bridge id)_objc_makeTaggedPointer(tag, i);
232	testassert(object_getClass(o) == cls);
233
234	id result = WEAK_STORE(w->weaks[i], o);
235	testassert(result == o);
236	testassert(w->weaks[i] == o);
237
238	result = WEAK_LOAD(w->weaks[i]);
239	testassert(result == o);
240
241	uintptr_t rc = _objc_rootRetainCount(o);
242	testassert(rc != 0);
243	_objc_rootRelease(o); testassert(_objc_rootRetainCount(o) == rc);
244	_objc_rootRelease(o); testassert(_objc_rootRetainCount(o) == rc);
245	_objc_rootRetain(o); testassert(_objc_rootRetainCount(o) == rc);
246	_objc_rootRetain(o); testassert(_objc_rootRetainCount(o) == rc);
247	_objc_rootRetain(o); testassert(_objc_rootRetainCount(o) == rc);
248	#if !__has_feature(objc_arc)
249	[o release]; testassert(_objc_rootRetainCount(o) == rc);
250	[o release]; testassert(_objc_rootRetainCount(o) == rc);
251	[o retain]; testassert(_objc_rootRetainCount(o) == rc);
252	[o retain]; testassert(_objc_rootRetainCount(o) == rc);
253	[o retain]; testassert(_objc_rootRetainCount(o) == rc);
254	objc_release(o); testassert(_objc_rootRetainCount(o) == rc);
255	objc_release(o); testassert(_objc_rootRetainCount(o) == rc);
256	objc_retain(o); testassert(_objc_rootRetainCount(o) == rc);
257	objc_retain(o); testassert(_objc_rootRetainCount(o) == rc);
258	objc_retain(o); testassert(_objc_rootRetainCount(o) == rc);
259	#endif
260	PUSH_POOL {
261	testassert(_objc_rootRetainCount(o) == rc);
262	_objc_rootAutorelease(o);
263	testassert(_objc_rootRetainCount(o) == rc);
264	#if !__has_feature(objc_arc)
265	[o autorelease];
266	testassert(_objc_rootRetainCount(o) == rc);
267	objc_autorelease(o);
268	testassert(_objc_rootRetainCount(o) == rc);
269	objc_retainAutorelease(o);
270	testassert(_objc_rootRetainCount(o) == rc);
271	objc_autoreleaseReturnValue(o);
272	testassert(_objc_rootRetainCount(o) == rc);
273	objc_retainAutoreleaseReturnValue(o);
274	testassert(_objc_rootRetainCount(o) == rc);
275	objc_retainAutoreleasedReturnValue(o);
276	testassert(_objc_rootRetainCount(o) == rc);
277	#endif
278	} POP_POOL;
279	testassert(_objc_rootRetainCount(o) == rc);
280	}
281	});
282	if (is_debug()) {
283	// libobjc's debug lock checking makes this leak check fail
284	testwarn("skipping leak check with debug libobjc build");
285	} else {
286	leak_check(0);
287	}
288	for (uintptr_t i = 0; i < 10000; i++) {
289	testassert(w->weaks[i] != NULL);
290	WEAK_STORE(w->weaks[i], NULL);
291	testassert(w->weaks[i] == NULL);
292	testassert(WEAK_LOAD(w->weaks[i]) == NULL);
293	}
294	objc_release(w);
295	RELEASE_VAR(w);
296	}
297
34d5b5e8 A	298	#if OBJC_SPLIT_TAGGED_POINTERS
	299	void testConstantTaggedPointerRoundTrip(void *ptr)
	300	{
	301	uintptr_t tagged = (uintptr_t)ptr \| objc_debug_constant_cfstring_tag_bits;
	302	void untagged = _objc_getTaggedPointerRawPointerValue((void )tagged);
	303	testassert(ptr == untagged);
	304	}
	305
	306	void testConstantTaggedPointers(void)
	307	{
	308	testConstantTaggedPointerRoundTrip(0);
	309	testConstantTaggedPointerRoundTrip((void )sizeof(void ));
	310	testConstantTaggedPointerRoundTrip((void )(MACH_VM_MAX_ADDRESS - sizeof(void )));
	311	}
	312	#endif
	313
13ba007e A	314	int main()
	315	{
	316	testassert(objc_debug_taggedpointer_mask != 0);
	317	testassert(_objc_taggedPointersEnabled());
	318
	319	PUSH_POOL {
	320	// Avoid CF's tagged pointer tags because of rdar://11368528
	321
	322	// Reserved slot should be nil until the
	323	// first extended tag is registered.
	324	// This test no longer works because XPC now uses extended tags.
	325	#define HAVE_XPC_TAGS 1
	326
	327	uintptr_t extSlot = (~objc_debug_taggedpointer_obfuscator >> objc_debug_taggedpointer_slot_shift) & objc_debug_taggedpointer_slot_mask;
	328	Class extPlaceholder = objc_getClass("__NSUnrecognizedTaggedPointer");
	329	testassert(extPlaceholder != nil);
	330
	331	#if !HAVE_XPC_TAGS
	332	testassert(objc_debug_taggedpointer_classes[extSlot] == nil);
	333	#endif
	334
	335	_objc_registerTaggedPointerClass(OBJC_TAG_1,
	336	objc_getClass("TaggedBaseClass60"));
	337	testGenericTaggedPointer(OBJC_TAG_1,
	338	objc_getClass("TaggedBaseClass60"));
	339
	340	#if !HAVE_XPC_TAGS
	341	testassert(objc_debug_taggedpointer_classes[extSlot] == nil);
	342	#endif
	343
	344	_objc_registerTaggedPointerClass(OBJC_TAG_First52BitPayload,
	345	objc_getClass("TaggedSubclass52"));
	346	testGenericTaggedPointer(OBJC_TAG_First52BitPayload,
	347	objc_getClass("TaggedSubclass52"));
	348
	349	testassert(objc_debug_taggedpointer_classes[extSlot] == extPlaceholder);
	350
	351	_objc_registerTaggedPointerClass(OBJC_TAG_NSManagedObjectID,
	352	objc_getClass("TaggedNSObjectSubclass"));
	353	testGenericTaggedPointer(OBJC_TAG_NSManagedObjectID,
	354	objc_getClass("TaggedNSObjectSubclass"));
34d5b5e8 A	355
	356	#if OBJC_SPLIT_TAGGED_POINTERS
	357	testConstantTaggedPointers();
	358	#endif
13ba007e A	359	} POP_POOL;
	360
	361	succeed(__FILE__);
	362	}
	363
	364	// OBJC_HAVE_TAGGED_POINTERS
	365	#else
	366	// not OBJC_HAVE_TAGGED_POINTERS
	367
	368	// Tagged pointers not supported.
	369
	370	int main()
	371	{
	372	testassert(objc_debug_taggedpointer_mask == 0);
	373	succeed(__FILE__);
	374	}
	375
	376	#endif