// runtime/isa.h 的思想摘要：不同架构位数不同，但字段职责一致。
#define ISA_BITFIELD                 \
    uintptr_t nonpointer        : 1; // 1 表示 nonpointer isa，0 表示 raw class pointer \
    uintptr_t has_assoc         : 1; // 是否可能有关联对象 \
    uintptr_t has_cxx_dtor      : 1; // 是否可能需要 C++ 析构，部分布局没有这个位 \
    uintptr_t shiftcls          : N; // 类指针右移后的主体位，或 indexed isa 的 indexcls \
    uintptr_t magic             : M; // 布局校验位 \
    uintptr_t weakly_referenced : 1; // 是否曾被弱引用 \
    uintptr_t has_sidetable_rc  : 1; // SideTable 中是否有溢出的引用计数 \
    uintptr_t extra_rc          : R; // 内联引用计数，retain/release 快路径直接加减这里
```text

**计数语义：**源码中 `initIsa()` 为新 nonpointer 实例设置 `extra_rc = 1`，`rootRetainCount()` 对 nonpointer isa 直接返回 `extra_rc + sidetable extra`。因此这里的 `extra_rc` 表示用户可观察的 retain count 基数，而不是“额外持有数 + 1”这种外部抽象。

## 3. 核心结构和关键字段方法

### `isa_t`：同一个机器字的两种解释

`runtime/objc-private.h` 中 `isa_t` 是 union：既可以通过 `bits` 做整字原子更新，也可以通过位字段读写状态。`cls` 被放在 private 区域，迫使调用者通过 `setClass()` 和 `getClass()` 处理 mask、indexed isa 和 pointer authentication。

``` cpp
union isa_t {
    uintptr_t bits;        // retain/release 使用整字 CAS 修改 isa

private:
    Class cls;             // raw isa 下的类指针；访问要走 setClass/getClass

public:
    struct {
        ISA_BITFIELD;      // 来自 runtime/isa.h 的架构相关位布局
    };

    bool isDeallocating() const {
        // nonpointer isa 没有单独 deallocating 位：
        // extra_rc == 0 且没有 SideTable 计数，表示正在/应该 dealloc。
        return extra_rc == 0 && has_sidetable_rc == 0;
    }
};
```text

### `objc_object`：对象头与入口方法

`objc_object` 把 `isa_t` 存在 `isa_storage` 中，并提供三类入口： `ISA()`/`getIsa()` 解码类，`initIsa()`/`changeIsa()` 初始化或改写类， `rootRetain()`/`rootRelease()`/`clearDeallocating()` 操作生命周期。

``` cpp
struct objc_object {
private:
    char isa_storage[sizeof(isa_t)];
    isa_t &isa();          // 对象第一个机器字

public:
    Class ISA(bool authenticated = false) const;
    void initInstanceIsa(Class cls, bool hasCxxDtor);
    Class changeIsa(Class newCls);

    id rootRetain();
    bool rootRelease();
    uintptr_t rootRetainCount() const;
    void clearDeallocating();
};
```text

### `SideTable`：锁、引用计数表、弱引用表

`runtime/NSObject-private.h` 定义 `SideTable`。真实全局容器在 `NSObject.mm` 中是 `StripedMap<SideTable>`，按对象地址映射到不同条带，降低锁竞争。

``` cpp
struct SideTable {
    spinlock_t slock;      // 保护 refcnts 和 weak_table
    RefcountMap refcnts;   // key 是 DisguisedPtr<objc_object>，避免 leaks 把它当根
    weak_table_t weak_table;
};
```text

`NSObject.mm` 中 SideTable 引用计数的低位布局如下：

``` cpp
#define SIDE_TABLE_WEAKLY_REFERENCED (1UL<<0) // 对象曾被弱引用
#define SIDE_TABLE_DEALLOCATING      (1UL<<1) // raw isa 或 SideTable 路径的 deallocating 标记
#define SIDE_TABLE_RC_ONE            (1UL<<2) // 每一次 retain 增加的单位
#define SIDE_TABLE_RC_SHIFT 2                 // 真实计数 = refcnt >> 2
```text

## 4. 关键流程

### 4.1 isa 初始化

**选择 raw 还是 nonpointer。** `initInstanceIsa(cls, hasCxxDtor)` 要求类不需要 raw isa，然后调用 `initIsa(cls, true, hasCxxDtor)`；类对象用 `initClassIsa()`，始终 raw isa。

**写入 magic 和类信息。** packed isa 写 `ISA_MAGIC_VALUE` 后通过 `setClass()` 写入 `shiftcls`；indexed isa 写 `ISA_INDEX_MAGIC_VALUE` 和 `indexcls`。

**建立初始引用计数。** 若支持 `ISA_HAS_INLINE_RC`，新 nonpointer 对象设置 `extra_rc = 1`。

``` cpp
// runtime/objc-object.h：初始化 nonpointer isa 的关键逻辑
isa_t newisa(0);
newisa.bits = ISA_MAGIC_VALUE;  // nonpointer 位和 magic 位来自常量
newisa.setClass(cls, this);     // packed isa: 写 shiftcls/shiftcls_and_sig
newisa.extra_rc = 1;            // 新对象 retainCount 从 1 开始
isa() = newisa;                 // 单次存储发布对象头
```text

### 4.2 retain 快路径

**入口分流。** `objc_retain()` 跳过 nil/tagged pointer，然后进入 `obj->retain()`。 `retain()` 在无自定义 RR 时走 `rootRetain()`，否则发消息或调用 Swift RR。

**raw isa 进入 SideTable。** 如果 `isa.nonpointer == 0`，且不是元类，retain 直接调用 `sidetable_retain()`。

**nonpointer isa 原子加一。** 使用 `LoadExclusive` / `StoreExclusive` 循环，把 `isa.bits += RC_ONE`，也就是增加 `extra_rc`。

**溢出时转慢路径。** 加法 carry 表示 `extra_rc` 溢出；快路径调用 `rootRetain_overflow()` 进入完整路径。

``` cpp
// rootRetain() 的核心思想，省略 custom RR 和 tagged pointer 分支
oldisa = LoadExclusive(&isa().bits);
do {
    newisa = oldisa;

    if (!newisa.nonpointer) {
        ClearExclusive(&isa().bits);
        return sidetable_retain();     // raw isa 没有内联计数
    }

    if (newisa.isDeallocating()) {
        ClearExclusive(&isa().bits);
        return tryRetain ? nil : (id)this;
    }

    uintptr_t carry;
    newisa.bits = addc(newisa.bits, RC_ONE, 0, &carry); // extra_rc++

    if (carry) {
        // extra_rc 放不下：完整慢路径会把一半计数放进 SideTable
        return rootRetain_overflow(tryRetain);
    }
} while (!StoreExclusive(&isa().bits, &oldisa.bits, newisa.bits));
```cpp

### 4.3 retain 溢出到 SideTable

完整慢路径中，retain 溢出不会把所有计数都搬走，而是把 `extra_rc` 留在半满状态 `RC_HALF`，同时设置 `has_sidetable_rc = true`，再把另一半计数加到 `SideTable::refcnts`。这样后续 retain/release 仍有较大概率继续命中内联快路径。

``` cpp
// rootRetain(..., RRVariant::Full) 溢出处理
if (carry) {
    sidetable_lock();              // 保护 SideTable refcnts
    newisa.extra_rc = RC_HALF;     // isa 内保留一半容量
    newisa.has_sidetable_rc = true;
    transcribeToSideTable = true;
}

// CAS 成功后执行，避免 isa 和 SideTable 不一致
if (transcribeToSideTable) {
    sidetable_addExtraRC_nolock(RC_HALF);
}
```text

### 4.4 release 快路径、借计数与 dealloc 判定

**nonpointer release 先减内联计数。** `rootRelease()` 做 `isa.bits -= RC_ONE`。如果减法未 underflow，则 CAS 成功后检查 `newisa.isDeallocating()`。

**underflow 且有 SideTable 计数时借回。** 若 `has_sidetable_rc` 为真，慢路径锁住 SideTable，调用 `sidetable_subExtraRC_nolock(RC_HALF)` 借一批计数回 `extra_rc`。

**无可借计数时进入 dealloc。** 当内联计数减到 0 且没有 SideTable 计数时，`isDeallocating()` 为真，随后 `performDealloc()` 调用 `dealloc` 或自定义 dealloc initiation。

``` cpp
// rootRelease() 的核心思想
newisa.bits = subc(newisa.bits, RC_ONE, 0, &carry); // extra_rc--
if (carry) {
    // extra_rc 下溢：如果 SideTable 有计数，尝试借回 RC_HALF
    goto underflow;
}

if (newisa.isDeallocating()) {
    // extra_rc == 0 且 has_sidetable_rc == 0
    goto deallocate;
}

underflow:
if (newisa.has_sidetable_rc) {
    sidetable_lock();
    auto borrow = sidetable_subExtraRC_nolock(RC_HALF);
    newisa.extra_rc = borrow.borrowed - 1; // 同时补做本次 release
    newisa.has_sidetable_rc = borrow.remaining != 0;
    // CAS 成功后，如果 SideTable 没剩计数，清除 refcnts 项
}

deallocate:
if (performDealloc) this->performDealloc();
```text

### 4.5 raw isa 的 SideTable retain/release

raw isa 没有 `extra_rc`。`sidetable_retain()` 直接给 `refcnts[this]` 加 `SIDE_TABLE_RC_ONE`；`sidetable_release()` 如果没有表项， 会插入 `SIDE_TABLE_DEALLOCATING` 并触发 dealloc。如果已有表项且计数大于标志位，则减 `SIDE_TABLE_RC_ONE`。

``` cpp
// raw isa release 的关键语义
auto it = table.refcnts.try_emplace(this, SIDE_TABLE_DEALLOCATING);
auto &refcnt = it.first->second;

if (it.second) {
    do_dealloc = true;                 // 原本没有额外 retain，release 后归零
} else if (refcnt < SIDE_TABLE_DEALLOCATING) {
    do_dealloc = true;
    refcnt |= SIDE_TABLE_DEALLOCATING; // 保留 weak 标志，设置 deallocating
} else if (!(refcnt & SIDE_TABLE_RC_PINNED)) {
    refcnt -= SIDE_TABLE_RC_ONE;       // 正常减 SideTable 计数
}
```text

### 4.6 dealloc 与 clearDeallocating

`rootDealloc()` 对简单 nonpointer 对象有极快路径：没有弱引用、关联对象、C++ 析构和 SideTable 计数时直接 `free(this)`。否则进入对象销毁流程，最后通过 `objc_clear_deallocating()` 调用 `clearDeallocating()` 清理 SideTable 和 weak table。

``` cpp
// clearDeallocating() 的分流
if (!isa().nonpointer) {
    sidetable_clearDeallocating();       // raw isa：状态都在 SideTable
} else if (isa().weakly_referenced || isa().has_sidetable_rc) {
    clearDeallocating_slow();            // nonpointer：只在需要时进 SideTable
}

// clearDeallocating_slow()
table.lock();
if (isa().weakly_referenced) {
    weak_clear_no_lock(&table.weak_table, (id)this);
}
if (isa().has_sidetable_rc) {
    table.refcnts.erase(this);
}
table.unlock();
```text

### 4.7 changeIsa 时的计数迁移

`object_setClass()` 可能触发 `changeIsa()`。测试 `nonpointerisa.m` 验证了 nonpointer 到 nonpointer、nonpointer 到 raw pointer、raw pointer 到 raw pointer 都必须保留 retain count。关键点是 nonpointer 变 raw pointer 时，源码先锁 SideTable，再改 isa，随后用 `sidetable_moveExtraRC_nolock()` 把旧 `extra_rc`、deallocating 和 weak 标志转写到 SideTable。

``` cpp
// changeIsa(): nonpointer -> raw pointer 的保守迁移
if (oldisa.nonpointer && newClsRequiresRawIsa) {
    sidetable_lock();                 // 防止并发 release 看到半迁移状态
    newisa.setClass(newCls, this);    // isa 变成 raw class pointer
    StoreExclusive(&isa().bits, &oldisa.bits, newisa.bits);

    sidetable_moveExtraRC_nolock(
        oldisa.extra_rc,
        oldisa.isDeallocating(),
        oldisa.weakly_referenced);
    sidetable_unlock();
}