1
inline void
2
objc_object::initIsa(Class cls, bool nonpointer, UNUSED_WITHOUT_INDEXED_ISA_AND_DTOR_BIT bool hasCxxDtor)
3
{
4
    ASSERT(!isTaggedPointer());
5

6
    isa_t newisa(0);
7

8
    if (!nonpointer) {
9
        newisa.setClass(cls, this);
10
    } else {
11
        ASSERT(!DisableNonpointerIsa);
12
        ASSERT(!cls->instancesRequireRawIsa());
13

14

15
#if SUPPORT_INDEXED_ISA
16
        ASSERT(cls->classArrayIndex() > 0);
17
        newisa.bits = ISA_INDEX_MAGIC_VALUE;
18
        // isa.magic is part of ISA_MAGIC_VALUE
19
        // isa.nonpointer is part of ISA_MAGIC_VALUE
20
        newisa.has_cxx_dtor = hasCxxDtor;
21
        newisa.indexcls = (uintptr_t)cls->classArrayIndex();
22
#else
23
        newisa.bits = ISA_MAGIC_VALUE;
24
        // isa.magic is part of ISA_MAGIC_VALUE
25
        // isa.nonpointer is part of ISA_MAGIC_VALUE
26
#   if ISA_HAS_CXX_DTOR_BIT
27
        newisa.has_cxx_dtor = hasCxxDtor;
28
#   endif
29
        newisa.setClass(cls, this);
30
#endif
31
        newisa.extra_rc = 1;
32
    }
33

34
    // This write must be performed in a single store in some cases
35
    // (for example when realizing a class because other threads
36
    // may simultaneously try to use the class).
37
    // fixme use atomics here to guarantee single-store and to
38
    // guarantee memory order w.r.t. the class index table
39
    // ...but not too atomic because we don't want to hurt instantiation
40
    isa = newisa;
41
}

1
union isa_t {
2
    // 构造方法
3
    isa_t() { }
4
    isa_t(uintptr_t value) : bits(value) { }
5

6
    uintptr_t bits;
7

8
private:
9
    // Accessing the class requires custom ptrauth operations, so
10
    // force clients to go through setClass/getClass by making this
11
    // private.
12
    Class cls;
13

14
public:
15
#if defined(ISA_BITFIELD)
16
    struct {
17
        ISA_BITFIELD;  // defined in isa.h
18
    };
19

20
    bool isDeallocating() {
21
        return extra_rc == 0 && has_sidetable_rc == 0;
22
    }
23
    void setDeallocating() {
24
        extra_rc = 0;
25
        has_sidetable_rc = 0;
26
    }
27
#endif
28

29
    void setClass(Class cls, objc_object *obj);
30
    Class getClass(bool authenticated);
31
    Class getDecodedClass(bool authenticated);
32
};

1
#     define ISA_BITFIELD                                                      \
2
        uintptr_t nonpointer        : 1;                                       \
3
        uintptr_t has_assoc         : 1;                                       \
4
        uintptr_t has_cxx_dtor      : 1;                                       \
5
        uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ \
6
        uintptr_t magic             : 6;                                       \
7
        uintptr_t weakly_referenced : 1;                                       \
8
        uintptr_t unused            : 1;                                       \
9
        uintptr_t has_sidetable_rc  : 1;                                       \
10
        uintptr_t extra_rc          : 19

1
inline Class
2
isa_t::getClass(MAYBE_UNUSED_AUTHENTICATED_PARAM bool authenticated) {
3
#if SUPPORT_INDEXED_ISA
4
    return cls;
5
#else
6

7
    uintptr_t clsbits = bits;
8

9
#   if __has_feature(ptrauth_calls)
10
#       if ISA_SIGNING_AUTH_MODE == ISA_SIGNING_AUTH
11
    // Most callers aren't security critical, so skip the
12
    // authentication unless they ask for it. Message sending and
13
    // cache filling are protected by the auth code in msgSend.
14
    if (authenticated) {
15
        // Mask off all bits besides the class pointer and signature.
16
        clsbits &= ISA_MASK;
17
        if (clsbits == 0)
18
            return Nil;
19
        clsbits = (uintptr_t)ptrauth_auth_data((void *)clsbits, ISA_SIGNING_KEY, ptrauth_blend_discriminator(this, ISA_SIGNING_DISCRIMINATOR));
20
    } else {
21
        // If not authenticating, strip using the precomputed class mask.
22
        clsbits &= objc_debug_isa_class_mask;
23
    }
24
#       else
25
    // If not authenticating, strip using the precomputed class mask.
26
    clsbits &= objc_debug_isa_class_mask;
27
#       endif
28

29
#   else
30
    clsbits &= ISA_MASK;
31
#   endif
32

33
    return (Class)clsbits;
34
#endif
35
}

1
// Set the class field in an isa. Takes both the class to set and
2
// a pointer to the object where the isa will ultimately be used.
3
// This is necessary to get the pointer signing right.
4
//
5
// Note: this method does not support setting an indexed isa. When
6
// indexed isas are in use, it can only be used to set the class of a
7
// raw isa.
8
inline void
9
isa_t::setClass(Class newCls, UNUSED_WITHOUT_PTRAUTH objc_object *obj)
10
{
11
    // Match the conditional in isa.h.
12
#if __has_feature(ptrauth_calls) || TARGET_OS_SIMULATOR
13
#   if ISA_SIGNING_SIGN_MODE == ISA_SIGNING_SIGN_NONE
14
    // No signing, just use the raw pointer.
15
    uintptr_t signedCls = (uintptr_t)newCls;
16

17
#   elif ISA_SIGNING_SIGN_MODE == ISA_SIGNING_SIGN_ONLY_SWIFT
18
    // We're only signing Swift classes. Non-Swift classes just use
19
    // the raw pointer
20
    uintptr_t signedCls = (uintptr_t)newCls;
21
    if (newCls->isSwiftStable())
22
        signedCls = (uintptr_t)ptrauth_sign_unauthenticated((void *)newCls, ISA_SIGNING_KEY, ptrauth_blend_discriminator(obj, ISA_SIGNING_DISCRIMINATOR));
23

24
#   elif ISA_SIGNING_SIGN_MODE == ISA_SIGNING_SIGN_ALL
25
    // We're signing everything
26
    uintptr_t signedCls = (uintptr_t)ptrauth_sign_unauthenticated((void *)newCls, ISA_SIGNING_KEY, ptrauth_blend_discriminator(obj, ISA_SIGNING_DISCRIMINATOR));
27

28
#   else
29
#       error Unknown isa signing mode.
30
#   endif
31

32
    shiftcls_and_sig = signedCls >> 3;
33

34
#elif SUPPORT_INDEXED_ISA
35
    // Indexed isa only uses this method to set a raw pointer class.
36
    // Setting an indexed class is handled separately.
37
    cls = newCls;
38

39
#else // Nonpointer isa, no ptrauth
40
    shiftcls = (uintptr_t)newCls >> 3;
41
#endif
42
}