1
objc_object::rootRetain(bool tryRetain, objc_object::RRVariant variant)
2
{
3
    // 不处理 TaggedPointer 直接 return
4
    if (slowpath(isTaggedPointer())) return (id)this;
5

6
    ...
7

8
    do {
9
        transcribeToSideTable = false;
10
        newisa = oldisa;
11
        if (slowpath(!newisa.nonpointer)) {
12
            // 非 nonpointer 通过 sidetable 处理
13
            ClearExclusive(&isa.bits);
14
            if (tryRetain) return sidetable_tryRetain() ? (id)this : nil;
15
            else return sidetable_retain(sideTableLocked);
16
        }
17

18
        ...
19

20
        uintptr_t carry; // 标志 extra_rc 容量是否还能够承受
21
        newisa.bits = addc(newisa.bits, RC_ONE, 0, &carry);  // extra_rc++
22

23
        if (slowpath(carry)) {
24
            // 超出 extra_rc 容量
25
            // newisa.extra_rc++ overflowed
26
            if (variant != RRVariant::Full) {
27
                ClearExclusive(&isa.bits);
28
                return rootRetain_overflow(tryRetain);
29
            }
30
            // 保留一般的引用计数，并将另一半拷贝到 side table
31
            // Leave half of the retain counts inline and
32
            // prepare to copy the other half to the side table.
33
            if (!tryRetain && !sideTableLocked) sidetable_lock();
34
            sideTableLocked = true;
35
            transcribeToSideTable = true;
36
            newisa.extra_rc = RC_HALF;
37
            newisa.has_sidetable_rc = true;
38
        }
39
    } while (slowpath(!StoreExclusive(&isa.bits, &oldisa.bits, newisa.bits)));
40

41
    if (variant == RRVariant::Full) {
42
        if (slowpath(transcribeToSideTable)) {
43
            // Copy the other half of the retain counts to the side table.
44
            sidetable_addExtraRC_nolock(RC_HALF);
45
        }
46

47
        if (slowpath(!tryRetain && sideTableLocked)) sidetable_unlock();
48
    } else {
49
        ASSERT(!transcribeToSideTable);
50
        ASSERT(!sideTableLocked);
51
    }
52

53
    return (id)this;
54
}

1
objc_object::rootRelease(bool performDealloc, objc_object::RRVariant variant)
2
{
3
    // 不处理 TaggedPointer 直接 return
4
    if (slowpath(isTaggedPointer())) return false;
5

6
    ...
7

8
retry:
9
    do {
10
        newisa = oldisa;
11
        if (slowpath(!newisa.nonpointer)) {
12
            // 非 nonpointer 通过 sidetable 处理
13
            ClearExclusive(&isa.bits);
14
            return sidetable_release(sideTableLocked, performDealloc);
15
        }
16
        ...
17
        // don't check newisa.fast_rr; we already called any RR overrides
18
        uintptr_t carry;
19
        newisa.bits = subc(newisa.bits, RC_ONE, 0, &carry);  // extra_rc--
20
        if (slowpath(carry)) {
21
            // don't ClearExclusive()
22
            // extra_rc 见底 跳转执行 underflow
23
            goto underflow;
24
        }
25
    } while (slowpath(!StoreReleaseExclusive(&isa.bits, &oldisa.bits, newisa.bits)));
26

27
    if (slowpath(newisa.isDeallocating()))
28
        goto deallocate;
29

30
    ...
31
    return false;
32

33
 underflow:
34
    // extra_rc 见底后，从 SideTable 拿回引用计数，或者销毁
35
    // newisa.extra_rc-- underflowed: borrow from side table or deallocate
36

37
    // abandon newisa to undo the decrement
38
    newisa = oldisa;
39

40
    if (slowpath(newisa.has_sidetable_rc)) {
41
        // 如果有使用 SideTable
42
        if (variant != RRVariant::Full) {
43
            ClearExclusive(&isa.bits);
44
            return rootRelease_underflow(performDealloc);
45
        }
46

47
        // Transfer retain count from side table to inline storage.
48

49
        if (!sideTableLocked) {
50
            ClearExclusive(&isa.bits);
51
            sidetable_lock();
52
            sideTableLocked = true;
53
            // Need to start over to avoid a race against
54
            // the nonpointer -> raw pointer transition.
55
            oldisa = LoadExclusive(&isa.bits);
56
            goto retry;
57
        }
58

59
        // 从 SideTable 移除引用计数
60
        // Try to remove some retain counts from the side table.
61
        auto borrow = sidetable_subExtraRC_nolock(RC_HALF);
62

63
        bool emptySideTable = borrow.remaining == 0; // we'll clear the side table if no refcounts remain there
64

65
        if (borrow.borrowed > 0) {
66
            // Side table retain count decreased.
67
            // Try to add them to the inline count.
68
            bool didTransitionToDeallocating = false;
69
            // 修改 extra_rc 及标志位
70
            newisa.extra_rc = borrow.borrowed - 1;  // redo the original decrement too
71
            newisa.has_sidetable_rc = !emptySideTable;
72
            ...
73
        }
74
        else {
75
            // Side table is empty after all. Fall-through to the dealloc path.
76
        }
77
    }
78

79
deallocate:
80
    // Really deallocate.
81
    // 销毁
82
    ...
83

84
    if (performDealloc) {
85
        ((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(dealloc));
86
    }
87
    return true;
88
}