1
int main(int argc, const char * argv[]) {
2
    @autoreleasepool {
3
        // insert code here...
4
        NSLog(@"Hello, World!");
5
        RYModel *father = [RYModel alloc];<-
6

7
        RYModel *objc = [RYModel alloc];<-
8
    }
9
    return 0;
10
}

1
+ (id)alloc {
2
    return _objc_rootAlloc(self);
3
}

1
// Calls [cls alloc].
2
id
3
objc_alloc(Class cls)
4
{
5
    return callAlloc(cls, true/*checkNil*/, false/*allocWithZone*/);
6
}

1
// Call [cls alloc] or [cls allocWithZone:nil], with appropriate
2
// shortcutting optimizations.
3
static ALWAYS_INLINE id
4
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
5
{
6
#if __OBJC2__
7
    if (slowpath(checkNil && !cls)) return nil;
8
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {
9
        return _objc_rootAllocWithZone(cls, nil);
10
    }
11
#endif
12

13
    // No shortcuts available.
14
    if (allocWithZone) {
15
        return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
16
    }
17
    return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
18
}

1
id
2
_objc_rootAlloc(Class cls)
3
{
4
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/); <-
5
}

1
static ALWAYS_INLINE id
2
callAlloc(Class cls, bool checkNil, bool allocWithZone=false) {
3
#if __OBJC2__
4
    ...
5
    if (fastpath(!cls->ISA()->hasCustomAWZ())) { // 这里会判断类对象的isa指针是否有自定义的AllocWithZone的实现
6
        return _objc_rootAllocWithZone(cls, nil); <-
7
    }
8
#endif
9
    ...
10
}

1
NEVER_INLINE
2
id
3
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
4
{
5
    // allocWithZone under __OBJC2__ ignores the zone parameter
6
    return _class_createInstanceFromZone(cls, 0, nil,
7
                                         OBJECT_CONSTRUCT_CALL_BADALLOC);
8
}

1
/***********************************************************************
2
* class_createInstance
3
* fixme
4
* Locking: none
5
*
6
* Note: this function has been carefully written so that the fastpath
7
* takes no branch.
8
**********************************************************************/
9
static ALWAYS_INLINE id
10
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
11
                              int construct_flags = OBJECT_CONSTRUCT_NONE,
12
                              bool cxxConstruct = true,
13
                              size_t *outAllocatedSize = nil)
14
{
15
    ASSERT(cls->isRealized());
16

17
    // Read class's info bits all at once for performance
18
    bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
19
    bool hasCxxDtor = cls->hasCxxDtor();
20
    bool fast = cls->canAllocNonpointer();
21
    size_t size;
22

23
    size = cls->instanceSize(extraBytes);// 1. 计算所需大小
24
    if (outAllocatedSize) *outAllocatedSize = size;
25

26
    id obj;
27
    if (zone) {
28
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
29
    } else {
30
        obj = (id)calloc(1, size); // 2. 开辟空间
31
    }
32
    if (slowpath(!obj)) {
33
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
34
            return _objc_callBadAllocHandler(cls);
35
        }
36
        return nil;
37
    }
38

39
    if (!zone && fast) {
40
        obj->initInstanceIsa(cls, hasCxxDtor); // 3. 实例化isa
41
    } else {
42
        // Use raw pointer isa on the assumption that they might be
43
        // doing something weird with the zone or RR.
44
        obj->initIsa(cls);
45
    }
46

47
    if (fastpath(!hasCxxCtor)) {
48
        return obj;
49
    }
50

51
    construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
52
    return object_cxxConstructFromClass(obj, cls, construct_flags);
53
}

1
// Get the class pointer out of an isa. When ptrauth is supported,
2
// this operation is optionally authenticated. Many code paths don't
3
// need the authentication, so it can be skipped in those cases for
4
// better performance.
5
//
6
// Note: this method does not support retrieving indexed isas. When
7
// indexed isas are in use, it can only be used to retrieve the class
8
// of a raw isa.
9
#if SUPPORT_INDEXED_ISA || (ISA_SIGNING_AUTH_MODE != ISA_SIGNING_AUTH)
10
#define MAYBE_UNUSED_AUTHENTICATED_PARAM __attribute__((unused))
11
#else
12
#define MAYBE_UNUSED_AUTHENTICATED_PARAM UNUSED_WITHOUT_PTRAUTH
13
#endif
14

15
inline Class
16
isa_t::getClass(MAYBE_UNUSED_AUTHENTICATED_PARAM bool authenticated) {
17
#if SUPPORT_INDEXED_ISA
18
    return cls;
19
#else
20

21
    uintptr_t clsbits = bits;
22

23
#   if __has_feature(ptrauth_calls)
24
#       if ISA_SIGNING_AUTH_MODE == ISA_SIGNING_AUTH
25
    // Most callers aren't security critical, so skip the
26
    // authentication unless they ask for it. Message sending and
27
    // cache filling are protected by the auth code in msgSend.
28
    if (authenticated) {
29
        // Mask off all bits besides the class pointer and signature.
30
        clsbits &= ISA_MASK;
31
        if (clsbits == 0)
32
            return Nil;
33
        clsbits = (uintptr_t)ptrauth_auth_data((void *)clsbits, ISA_SIGNING_KEY, ptrauth_blend_discriminator(this, ISA_SIGNING_DISCRIMINATOR));
34
    } else {
35
        // If not authenticating, strip using the precomputed class mask.
36
        clsbits &= objc_debug_isa_class_mask;
37
    }
38
#       else
39
    // If not authenticating, strip using the precomputed class mask.
40
    clsbits &= objc_debug_isa_class_mask;
41
#       endif
42

43
#   else
44
    clsbits &= ISA_MASK;
45
#   endif
46

47
    return (Class)clsbits;
48
#endif
49
}

1
#     define ISA_MASK        0x0000000ffffffff8ULL

1
(lldb) po 0x000061a10441570d & 0x0000000ffffffff8
2
Ryukie

1
(lldb) x/4gx obj1
2
0x28150e2e0: 0x000041a100c0577d 0x0000001200000001
3
0x28150e2f0: 0x0000000100c00008 0x0000000100c00028