【iOS】Runtime - Part 2 && 消息发送：缓存、查找与转发

1
@implementation Son : Father
2
- (id)init
3
{
4
    self = [super init];
5
    if (self)
6
    {
7
        NSLog(@"%@", NSStringFromClass([self class]));   // 输出什么？
8
        NSLog(@"%@", NSStringFromClass([super class])); // 输出什么？
9
    }
10
    return self;
11
}
12
@end

1
// 编译器生成
2
struct objc_super superInfo = {
3
    .receiver    = self,        // receiver 仍然是 Son 实例，没有变
4
    .super_class = Son.class,   // 传【当前类】Son，不是 Father（Super2 的关键）
5
};
6
// objc_msgSendSuper2 内部再做 Son->superclass = Father，从 Father 开始查找
7
objc_msgSendSuper2(&superInfo, @selector(class));

1
// NSObject -class 的实现本质上是：
2
- (Class)class {
3
    return object_getClass(self); // self 是谁？
4
}

1
// objc-runtime-new.h:337  —— cache_t 字段（仅展开 arm64 真机 HIGH_16 分支，其余平台见文末折叠块）
2
struct cache_t {
3
private:
4
    explicit_atomic<uintptr_t> _bucketsAndMaybeMask;  // buckets 指针，也可能顺便包含 mask
5

6
    //核心字段：arm64 上高 16 位 = mask，低 48 位 = buckets 指针（一字双用）
7
    union {
8
        // Note: _flags on ARM64 needs to line up with the unused bits of
9
        // _originalPreoptCache because we access some flags (specifically
10
        // FAST_CACHE_HAS_DEFAULT_CORE and FAST_CACHE_HAS_DEFAULT_AWZ) on
11
        // unrealized classes with the assumption that they will start out
12
        // as 0.
13

14
        struct {
15
            //arm64 真机（HIGH_16）：注意没有独立 _mask！mask 在 _bucketsAndMaybeMask 高位
16
            // Inline cache mask storage, 64-bit, we have occupied, flags, and
17
            // empty space to line up flags with originalPreoptCache.
18
            //
19
            // Note: the assembly code for objc_release_xN knows about the
20
            // location of _flags and the
21
            // FAST_CACHE_HAS_CUSTOM_DEALLOC_INITIATION flag within. Any changes
22
            // must be applied there as well.
23
            uint32_t                   _disguisedPreoptCacheSignature;//4
24
            uint16_t                   _occupied;// 2 bytes
25
            uint16_t                   _flags;// 2 bytes
26

27
#   define CACHE_T_HAS_FLAGS 1
28
        };
29

30
        //  这一段有关之前涉及的PAC机制，暂且可以不管
31
        explicit_atomic<preopt_cache_t *, PTRAUTH_STR(originalPreoptCache, ptrauth_key_process_independent_data)> _originalPreoptCache;
32
    };
33

34
    // Simple constructor for testing purposes only.
35
    cache_t() : _bucketsAndMaybeMask(0) {}
36

37
    // —— 只展开 arm64 真机 HIGH_16 的 mask 存储常量；OUTLINED / BIG_ADDRS / LOW_4 见折叠块 ——
38
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
39
    //arm64 真机的 mask 存储常量定义
40
    // _bucketsAndMaybeMask is a buckets_t pointer in the low 48 bits
41

42
    // How much the mask is shifted by.
43
    static constexpr uintptr_t maskShift = 48;    //mask 放在第 48 位起的高 16 位
44

45
    // Additional bits after the mask which must be zero. msgSend
46
    // takes advantage of these additional bits to construct the value
47
    // `mask << 4` from `_maskAndBuckets` in a single instruction.
48
    static constexpr uintptr_t maskZeroBits = 4;  //紧邻 mask 的 4 位必须为 0，
49
              // 让 msgSend 一条指令算出 mask<<4（见 2.2 的 LSR #(48-(1+PTRSHIFT))）
50

51
    // The largest mask value we can store.
52
    static constexpr uintptr_t maxMask = ((uintptr_t)1 << (64 - maskShift)) - 1;
53

54
    // The mask applied to `_maskAndBuckets` to retrieve the buckets pointer.
55
    static constexpr uintptr_t bucketsMask = ((uintptr_t)1 << (maskShift - maskZeroBits)) - 1;
56

57
    // Ensure we have enough bits for the buckets pointer.
58
    static_assert(bucketsMask >= OBJC_VM_MAX_ADDRESS,
59
            "Bucket field doesn't have enough bits for arbitrary pointers.");
60

61
#if CONFIG_USE_PREOPT_CACHES
62
    static constexpr uintptr_t preoptBucketsMarker = 1ul;
63
#if __has_feature(ptrauth_calls)
64
    // 63..60: hash_mask_shift
65
    // 59..55: hash_shift
66
    // 54.. 1: buckets ptr + auth
67
    //      0: always 1
68
    static constexpr uintptr_t preoptBucketsMask = 0x007ffffffffffffe;
69
    static inline uintptr_t preoptBucketsHashParams(const preopt_cache_t *cache) {
70
        uintptr_t value = (uintptr_t)cache->shift << 55;
71
        // masks have 11 bits but can be 0, so we compute
72
        // the right shift for 0x7fff rather than 0xffff
73
        return value | ((objc::mask16ShiftBits(cache->mask) - 1) << 60);
74
    }
75
#endif
76
#endif // CONFIG_USE_PREOPT_CACHES
77
#endif
78

79
    // ……（以下为 mask()/buckets()/insert()/reallocate() 等方法声明，
80
    //     以及 FAST_CACHE_* 快速分配标志位定义，属另一主题，本块略去）
81
};

1
// objc-cache.mm（arm64 HIGH_16 分支）
2
void cache_t::setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask) {   // :625 编码（装）
3
    // mask 放高位、buckets 放低位，或成一个字
4
    _bucketsAndMaybeMask.store(((uintptr_t)newMask << maskShift) | (uintptr_t)newBuckets,
5
                               memory_order_release);
6
    _occupied = 0;
7
}
8

9
mask_t cache_t::mask() const {                                                   // :637 取 mask（拆高位）
10
    uintptr_t maskAndBuckets = _bucketsAndMaybeMask.load(memory_order_relaxed);
11
    return maskAndBuckets >> maskShift;             //>>48，对应汇编 lsr p11,#48
12
}
13

14
struct bucket_t *cache_t::buckets() const {                                      // :671 取 buckets（拆低位）
15
    uintptr_t addr = _bucketsAndMaybeMask.load(memory_order_relaxed);
16
    return (bucket_t *)(addr & bucketsMask);        //& 低位掩码，对应汇编 and p10,…
17
}

1
位 63 ........ 48 | 47 .. 44 | 43 ............... 0
2
   mask（16 位）   | 必为 0   |  buckets 指针（低 44 位）
3
   └ maskShift=48           └ maskZeroBits=4

1
struct cache_t {
2
    struct bucket_t *_buckets;   // 桶数组指针（独立字段）
3
    mask_t _mask;                // 容量掩码（独立字段）
4
    mask_t _occupied;            // 已用槽数（独立字段）
5
    ...
6
    void expand();
7
    struct bucket_t * find(SEL sel, id receiver);
8
};

1
struct cache_t {
2
    explicit_atomic<uintptr_t> _bucketsAndMaybeMask;  // 高16位=mask，低48位=buckets，一字双用
3
    union {
4
        struct { uint32_t _disguisedPreoptCacheSignature; uint16_t _occupied; uint16_t _flags; };
5
        explicit_atomic<preopt_cache_t *> _originalPreoptCache;
6
    };
7
    ...
8
};

1
// objc-runtime-new.h:214  —— bucket_t（全文）
2
struct bucket_t {
3
private:
4
    // IMP-first is better for arm64e ptrauth and no worse for arm64.
5
    // SEL-first is better for armv7* and i386 and x86_64.
6
    //arm64e 的 ptrauth 更适合 IMP 在前；armv7*/i386/x86_64 则 SEL 在前更优
7
#if __arm64__
8
    explicit_atomic<uintptr_t> _imp;  //arm64：IMP 在前（利于 ptrauth），存「编码后」的实现地址
9
    explicit_atomic<SEL> _sel;    //SEL：方法选择子，桶的查找键（命中判定就比它）
10
#else
11
    explicit_atomic<SEL> _sel;    //非 arm64：SEL 在前
12
    explicit_atomic<uintptr_t> _imp;  //IMP：编码后的函数实现地址
13
#endif
14

15
    // Compute the ptrauth signing modifier from &_imp, newSel, and cls.
16
    //modifierForSEL 把"这个 IMP 应该出现在哪里"这件事——哪个缓存数组、哪个方法、哪个类——压缩成一个整数，作为 ptrauth 签名的上下文标签，让每个 bucket 的签名都是唯一的，无法跨 bucket、跨 SEL、跨类复制。
17
    uintptr_t modifierForSEL(bucket_t *base, SEL newSel, Class cls) const {  //算 IMP 的 ptrauth 签名修饰子
18
        return (uintptr_t)base ^ (uintptr_t)newSel ^ (uintptr_t)cls;
19
        //IMP 的签名修饰子 = buckets_base ^ sel ^ cls（命中时汇编里两条 eor 就是在重算它）
20
    }
21

22
    // Sign newImp, with &_imp, newSel, and cls as modifiers.
23
    // 如果直接存裸指针，攻击者只要能写入 cache_t 所在的内存（比如通过堆溢出漏洞），就能把 _imp 改成任意地址，下次 objc_msgSend 命中这个 bucket 时就会跳到攻击者控制的地址，实现任意代码执行。
24

25
  // encodeImp 的存在就是为了防止这件事——存入 _imp 的不是裸指针，而是经过某种变换的值，让攻击者即使能写内存，也无法构造出一个"看起来合法"的 _imp 值。​
26
    //把一个 IMP 转成一个可以安全存入 _imp 字段的整数值，三条路径只是"怎么转"的区别，输入输出的本质完全相同。
27
    uintptr_t encodeImp(UNUSED_WITHOUT_PTRAUTH bucket_t *base, IMP newImp, UNUSED_WITHOUT_PTRAUTH SEL newSel, Class cls) const {  //写入缓存前：给 IMP 编码/签名
28
        if (!newImp) return 0;    //空 IMP 存 0，不参与编码
29
#if CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_PTRAUTH
30
        //arm64e：用 ptrauth 把 IMP 重新签名，修饰子带入 base^sel^cls
31
        return (uintptr_t)
32
        bitcast_auth_and_resign(void *, newImp,
33
                                ptrauth_key_function_pointer,      //源密钥：通用函数指针
34
                                ptrauth_function_pointer_type_discriminator(IMP),  //源判别子：IMP 类型
35
                                ptrauth_key_process_dependent_code,    //目标密钥：进程相关代码
36
                                modifierForSEL(base, newSel, cls));    //目标修饰子：base^sel^cls
37

38
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_ISA_XOR
39
        return (uintptr_t)newImp ^ (uintptr_t)cls;  //非 ptrauth 设备：用类指针 cls 对 IMP 做异或，结果存入 _imp。这不是密码学安全，但它能防止最简单的攻击：直接从内存里读出 _imp 的值，得到的是混淆后的整数，不是可以直接调用的函数地址。还原时再 XOR 一次 cls 即可，因为 a ^ b ^ b = a
40

41
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_NONE
42
        return (uintptr_t)newImp;    //不编码：裸存 IMP（模拟器/部分调试配置）
43
#else
44
#error Unknown method cache IMP encoding.
45
#endif
46
    }
47

48
public:
49
    static inline size_t offsetOfSel() { return offsetof(bucket_t, _sel); }  //_sel 在结构体内的偏移（汇编/插入定位用）
50

51

52
    inline SEL sel() const { return _sel.load(memory_order_relaxed); }    //原子读出 SEL（relaxed，无屏障）
53

54
#if CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_ISA_XOR
55
#define MAYBE_UNUSED_ISA        //ISA_XOR 编码：解码要用到 cls，参数不能标 unused
56
#else
57
#define MAYBE_UNUSED_ISA __attribute__((unused))  //其它编码用不到 cls，标 unused 避免「未使用参数」告警
58
#endif
59

60
    inline IMP rawImp(MAYBE_UNUSED_ISA objc_class *cls) const {  //取 IMP「裸值」：解 XOR 混淆，但不验证 ptrauth 签名
61
        uintptr_t imp = _imp.load(memory_order_relaxed);
62
        if (!imp) return nil;      //空槽返回 nil
63
#if CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_PTRAUTH
64
        //ptrauth：rawImp 不解签名，原样返回带签名位的指针
65
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_ISA_XOR
66
        imp ^= (uintptr_t)cls;      //还原 ISA_XOR：再异或一次 cls
67
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_NONE
68
#else
69
#error Unknown method cache IMP encoding.
70
#endif
71
        return (IMP)imp;
72
    }
73

74
    inline IMP imp(UNUSED_WITHOUT_PTRAUTH bucket_t *base, Class cls) const {  //取可直接调用的 IMP：完整解码 + 验签
75
        uintptr_t imp = _imp.load(memory_order_relaxed);
76
        if (!imp) return nil;      //空槽返回 nil
77
#if CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_PTRAUTH
78
        SEL sel = _sel.load(memory_order_relaxed);  //ptrauth：先读出 sel 以重算修饰子
79
        return bitcast_auth_and_resign(IMP, imp,
80
                                       ptrauth_key_process_dependent_code,    //源密钥：进程相关代码
81
                                       modifierForSEL(base, sel, cls),      //源修饰子：base^sel^cls（用它验签）
82
                                       ptrauth_key_function_pointer,      //目标密钥：通用函数指针
83
                                       ptrauth_function_pointer_type_discriminator(IMP));  //目标判别子：IMP 类型
84
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_ISA_XOR
85
        return (IMP)(imp ^ (uintptr_t)cls);  //还原 IMP ^ cls
86
#elif CACHE_IMP_ENCODING == CACHE_IMP_ENCODING_NONE
87
        return (IMP)imp;      //裸值直接返回
88
#else
89
#error Unknown method cache IMP encoding.
90
#endif
91
    }
92

93
    inline void scribbleIMP(uintptr_t value) {  //用指定值覆写 _imp（缓存清空/标记无效用）
94
        _imp.store(value, memory_order_relaxed);
95
    }
96

97
    template <Atomicity, IMPEncoding>    //模板参数决定：原子性（是否加锁/屏障）与 IMP 编码方式
98
    void set(bucket_t *base, SEL newSel, IMP newImp, Class cls);  //把 {sel,imp} 落位到本桶（声明，实现在 .mm）
99
};

1
#if __arm64__
2
    uintptr_t _imp;          // 非 atomic 裸字段
3
    SEL _sel;
4
#endif
5
    uintptr_t modifierForSEL(SEL newSel) const {
6
        return (uintptr_t)&_imp ^ (uintptr_t)newSel;       // 仅 2 项
7
    }

1
#if __arm64__
2
    explicit_atomic<uintptr_t> _imp;     // 改为原子字段
3
    explicit_atomic<SEL> _sel;
4
#endif
5
    uintptr_t modifierForSEL(bucket_t *base, SEL newSel, Class cls) const {
6
        return (uintptr_t)base ^ (uintptr_t)newSel ^ (uintptr_t)cls;   // 加入 cls，3 项
7
    }

1
ptrauth_auth_and_resign(newImp,
2
                        ptrauth_key_function_pointer, 0,        // 判别子 = 0
3
                        ptrauth_key_process_dependent_code,
4
                        modifierForSEL(base, newSel, cls));

1
bitcast_auth_and_resign(void *, newImp,
2
                        ptrauth_key_function_pointer,
3
                        ptrauth_function_pointer_type_discriminator(IMP),  // 绑定到 IMP 类型
4
                        ptrauth_key_process_dependent_code,
5
                        modifierForSEL(base, newSel, cls));

1
// objc-cache.mm:240  —— cache_next（全文，含两种配置）
2
#if CACHE_END_MARKER
3
static inline mask_t cache_next(mask_t i, mask_t mask) {
4
    return (i+1) & mask;      //带哨兵：向高地址探测，回绕到 0
5
}
6
#elif __arm64__
7
static inline mask_t cache_next(mask_t i, mask_t mask) {
8
    return i ? i-1 : mask;      //arm64：向低地址探测，到 0 则回绕到 mask（表尾）
9
}
10
#else
11
#error unexpected configuration
12
#endif
13

14
// objc-cache.mm:304
15
// Class points to cache. SEL is key. Cache buckets store SEL+IMP.
16
// Caches are never built in the dyld shared cache.
17

18
// objc-cache.mm:307  —— cache_hash  SEL到下标到，它的输入是 SEL，输出是一个下标整数（mask_t），仅此而已。它不知道 buckets_t * 在哪里，也不接触任何 bucket_t
19
static inline mask_t cache_hash(SEL sel, mask_t mask)
20
{
21
    uintptr_t value = (uintptr_t)sel;
22
#if SEL_HASH_SHIFT_XOR
23
    value ^= value >> 7;      //与汇编 eor p12,p1,p1,LSR #7 一一对应
24
#endif
25
    return (mask_t)(value & mask);
26
}

1
// objc-runtime-new.h:2635 —— 类对象本身就是一个 objc_class
2
struct objc_class : objc_object {
3
    // Class ISA;          //偏移 0：继承自 objc_object（2.1 节 ldr [x0] 取的就是它）
4
    Class superclass;      //偏移 8
5
    cache_t cache;         //偏移 16
6
    class_data_bits_t bits;//偏移 16+sizeof(cache_t)：class_rw_t* + rr/alloc 标志
7
};

1
;; objc-msg-arm64.s:79 —— 类结构里被选用的字段偏移
2
#define SUPERCLASS       __SIZEOF_POINTER__        // = 8   → [x16, #SUPERCLASS]
3
#define CACHE            (2 * __SIZEOF_POINTER__)  // = 16  → [x16, #CACHE]
4
#define BUCKET_SIZE      (2 * __SIZEOF_POINTER__)  // = 16  → 2.2 的 ldp …, #-BUCKET_SIZE

1
;; objc-msg-arm64.s:115  —— GetClassFromIsa_p16 宏（全文）
2
.macro GetClassFromIsa_p16 src, needs_auth, auth_address /* note: auth_address is not required if !needs_auth */
3

4
#if SUPPORT_INDEXED_ISA
5
  // Indexed isa
6
  //watchOS 等：isa 存的是类表下标，不是指针
7
  mov  p16, \src      // optimistically set dst = src
8
  tbz  p16, #ISA_INDEX_IS_NPI_BIT, 1f  // done if not non-pointer isa
9
  // isa in p16 is indexed
10
  adrp  x10, _objc_indexed_classes@PAGE
11
  add  x10, x10, _objc_indexed_classes@PAGEOFF
12
  ubfx  p16, p16, #ISA_INDEX_SHIFT, #ISA_INDEX_BITS  // extract index
13
  ldr  p16, [x10, p16, UXTP #PTRSHIFT]  // load class from array
14
1:
15

16
#elif __LP64__
17
  //arm64 真机走这里
18
.if \needs_auth == 0 // _cache_getImp takes an authed class already
19
  mov  p16, \src
20
.else
21
  // 64-bit packed isa
22
  ExtractISA p16, \src, \auth_address
23
  //ExtractISA = 用 ISA_MASK(0x7ffffffffffff8) 抹低位 + autda 解 ptrauth 签名
24
.endif
25
#else
26
  // 32-bit raw isa
27
  mov  p16, \src      //32 位：isa 就是裸指针，直接用
28

29
#endif
30

31
.endmacro

1
(lldb) disassemble --name objc_msgSend
2
objc_msgSend:
3
  <+0>:  cmp    x0, #0x0
4
  <+4>:  b.le   <+128>                       ; nil/tagged
5
  <+8>:  ldr    x14, [x0]                     ; raw isa
6
  <+12>: and    x16, x14, #0x7ffffffffffff8   ; ISA_MASK → class
7
  <+16>: mov    x10, x0
8
  <+20>: movk   x10, #0x6ae1, lsl #48
9
  <+24>: autda  x16, x10                      ; ptrauth 解签

1
;; objc-msg-arm64.s:336  —— CacheLookup 宏（全文）
2
.macro CacheLookup Mode, Function, MissLabelDynamic, MissLabelConstant
3
  //
4
  // Restart protocol:
5
  //
6
  //   As soon as we're past the LLookupStart\Function label we may have
7
  //   loaded an invalid cache pointer or mask.
8
  //
9
  //   When task_restartable_ranges_synchronize() is called,
10
  //   (or when a signal hits us) before we're past LLookupEnd\Function,
11
  //   then our PC will be reset to LLookupRecover\Function which forcefully
12
  //   jumps to the cache-miss codepath which have the following
13
  //   requirements:
14
  //
15
  //   GETIMP:
16
  //     The cache-miss is just returning NULL (setting x0 to 0)
17
  //
18
  //   NORMAL and LOOKUP:
19
  //   - x0 contains the receiver
20
  //   - x1 contains the selector
21
  //   - x16 contains the isa
22
  //   - other registers are set as per calling conventions
23
  //
24

25
  mov  x15, x16      // stash the original isa
26
          //备份 isa，转发指令里要用它判断是否回退到父类
27
LLookupStart\Function:
28
  // p1 = SEL, p16 = isa
29

30
  // ════════ ① ：取 mask + buckets  ════════
31
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16_BIG_ADDRS
32

33
  //macOS 原生 + Mac Catalyst 走这里（地址空间大，objc-config.h:218）
34

35
  ldr  p10, [x16, #CACHE]        // p10 = mask|buckets
36
  lsr  p11, p10, #48      // p11 = mask
37
  and  p10, p10, #0xffffffffffff  // p10 = buckets
38

39
  //分两步取出 mask(高16)、buckets(低48)。因为现代 64 位系统实际只用低 48 位寻址,高 16 位是空闲的,正好拿来塞 mask,省一次内存访问。
40

41

42
#  if SEL_HASH_SHIFT_XOR
43
  eor  p12, p1, p1, LSR #7
44
  and  w12, w12, w11      // x12 = (_cmd ^ (_cmd >> 7)) & mask
45
#  else
46
  and  w12, w1, w11      // x12 = _cmd & mask
47
#  endif
48
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
49

50

51
  // 算哈希桶索引：普通版 _cmd & mask；XOR 版先 sel^(sel>>7) 混淆再 &mask（即 cache_hash，减冲突）。桶数恒为 2 的幂，&mask 等价取模
52

53
  //iOS 真机走这里（objc-config.h:218）：一条 ldr 取出 mask|buckets，后面边算哈希边移位，比 BIG_ADDRS 省一步
54

55
  ldr  p11, [x16, #CACHE]      // p11 = mask|buckets
56
#  if CONFIG_USE_PREOPT_CACHES
57
#    if __has_feature(ptrauth_calls)
58
  tbnz  p11, #0, LLookupPreopt\Function  //最低位=1 → 这是共享缓存预优化表，跳专门路径
59
  and  p10, p11, #0x0000ffffffffffff  // p10 = buckets
60
#    else
61
  and  p10, p11, #0x0000fffffffffffe  // p10 = buckets
62
  tbnz  p11, #0, LLookupPreopt\Function
63
#    endif
64
#  endif
65

66
#  if SEL_HASH_SHIFT_XOR
67
  eor  p12, p1, p1, LSR #7    //sel ^ (sel>>7)，对应 cache_hash
68
  and  p12, p12, p11, LSR #48    // x12 = (_cmd ^ (_cmd >> 7)) & mask
69
#  else
70
  and  p10, p11, #0x0000ffffffffffff  // p10 = buckets
71
  and  p12, p1, p11, LSR #48    // x12 = _cmd & mask
72
#  endif // CONFIG_USE_PREOPT_CACHES
73
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
74
#  if SEL_HASH_SHIFT_XOR
75
#    error SEL_HASH_SHIFT_XOR not supported for LOW_4
76
#  endif
77
  ldr  p11, [x16, #CACHE]        // p11 = mask|buckets
78
  and  p10, p11, #~0xf      // p10 = buckets
79
  and  p11, p11, #0xf      // p11 = maskShift
80
  mov  p12, #0xffff
81
  lsr  p11, p12, p11      // p11 = mask = 0xffff >> p11
82
  and  p12, p1, p11      // x12 = _cmd & mask
83
#else
84
#error Unsupported cache mask storage for ARM64.
85
#endif
86

87
  // ════════ ② 定位起始 bucket，进入 do-while 探测循环 ════════
88

89
  add  p13, p10, p12, LSL #(1+PTRSHIFT)
90
            // p13 = buckets + ((_cmd & mask) << (1+PTRSHIFT))
91
          //p13 指向哈希命中的那个 bucket（每个 bucket 16 字节）
92

93
            // do {
94
1:  ldp  p17, p9, [x13], #-BUCKET_SIZE  //     {imp, sel} = *bucket--
95
          //取出 {imp,sel}，并让指针向低地址移一格（探测方向）
96
  cmp  p9, p1        //     if (sel != _cmd) {
97
  b.ne  3f        //         scan more
98
            //     } else {
99
2:  CacheHit \Mode        // hit:    call or return imp
100
            //     }
101
3:  cbz  p9, \MissLabelDynamic    //     if (sel == 0) goto Miss;
102
          //撞到空槽(sel==0) → 缓存未命中，跳慢速查找
103
  cmp  p13, p10      // } while (bucket >= buckets)
104
  b.hs  1b
105

106
  // ════════ ③ 扑空回绕：wrap-around 绕到表尾再扫一圈 ════════
107
  // wrap-around:
108
  //   p10 = first bucket
109
  //   p11 = mask (and maybe other bits on LP64)
110
  //   p12 = _cmd & mask
111
  //
112
  // A full cache can happen with CACHE_ALLOW_FULL_UTILIZATION.
113
  // So stop when we circle back to the first probed bucket
114
  // rather than when hitting the first bucket again.
115
  //
116
  // Note that we might probe the initial bucket twice
117
  // when the first probed slot is the last entry.
118

119

120
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16_BIG_ADDRS
121
  add  p13, p10, w11, UXTW #(1+PTRSHIFT)
122
            // p13 = buckets + (mask << 1+PTRSHIFT)
123
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
124
  add  p13, p10, p11, LSR #(48 - (1+PTRSHIFT))
125
            // p13 = buckets + (mask << 1+PTRSHIFT)
126
            // see comment about maskZeroBits
127
          //回绕：跳到表尾（最后一个 bucket）从尾部继续探测
128
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
129
  add  p13, p10, p11, LSL #(1+PTRSHIFT)
130
            // p13 = buckets + (mask << 1+PTRSHIFT)
131
#else
132
#error Unsupported cache mask storage for ARM64.
133
#endif
134
  add  p12, p10, p12, LSL #(1+PTRSHIFT)
135
            // p12 = first probed bucket
136
          //记下最初探测的位置，绕一圈回到这里就停
137

138
            // do {
139
4:  ldp  p17, p9, [x13], #-BUCKET_SIZE  //     {imp, sel} = *bucket--
140
  cmp  p9, p1        //     if (sel == _cmd)
141
  b.eq  2b        //         goto hit
142
  cmp  p9, #0        // } while (sel != 0 &&
143
  ccmp  p13, p12, #0, ne    //     bucket > first_probed)
144
  b.hi  4b
145

146
LLookupEnd\Function:
147
LLookupRecover\Function:
148
  b  \MissLabelDynamic    //绕完整圈仍没有 → 未命中
149

150
  // ════════ ④ 预优化缓存路径（仅 iOS / dyld 共享缓存里的系统类才进，你这条用不到）════════
151

152
#if CONFIG_USE_PREOPT_CACHES
153
#if CACHE_MASK_STORAGE != CACHE_MASK_STORAGE_HIGH_16
154
#error config unsupported
155
#endif
156
LLookupPreopt\Function:
157
  //以下是 dyld 共享缓存「预优化缓存」专用查找，普通动态类不会进
158
  // 怎么进来的：①里 cache 字段最低位被置 1（tbnz p11,#0）就说明这是 dyld 进来的「常量缓存」，跳到这里
159
  // —— 步骤 A：取 buckets 基址并尽早认证 ——
160
#if __has_feature(ptrauth_calls)
161
  and  p10, p11, #0x007ffffffffffffe  // p10 = buckets　← 抹掉低位 tag，得到 buckets 指针
162
  autdb  x10, x16      // auth as early as possible　← 用 isa 当 modifier 解签该指针（ptrauth），越早越好
163
#endif
164

165
  // —— 步骤 B：把 _cmd 换算成「相对共享缓存首个 SEL 的偏移」，再哈希定位条目 ——
166
  // x12 = (_cmd - first_shared_cache_sel)
167
  adrp  x9, _MagicSelRef@PAGE    // 取 first_shared_cache_sel 的地址（共享缓存里 SEL 连续排布）
168
  ldr  p9, [x9, _MagicSelRef@PAGEOFF]  // p9 = first_shared_cache_sel
169
  sub  p12, p1, p9      // x12 = _cmd 相对首个 SEL 的偏移（用偏移代替整指针，省位宽）
170

171
  // w9  = ((_cmd - first_shared_cache_sel) >> hash_shift & hash_mask)
172
#if __has_feature(ptrauth_calls)
173
  // bits 63..60 of x11 are the number of bits in hash_mask　← hash 参数被打包进 cache 值(x11)的高位
174
  // bits 59..55 of x11 is hash_shift
175

176
  lsr  x17, x11, #55      // w17 = (hash_shift, ...)　← 取出 hash_shift
177
  lsr  w9, w12, w17      // >>= shift　← 偏移先右移 hash_shift
178

179
  lsr  x17, x11, #60      // w17 = mask_bits　← 取出「mask 占几位」
180
  mov  x11, #0x7fff
181
  lsr  x11, x11, x17      // p11 = mask (0x7fff >> mask_bits)　← 据此算出 hash_mask
182
  and  x9, x9, x11      // &= mask　← x9 = 条目下标
183
#else
184
  // bits 63..53 of x11 is hash_mask　← 非 ptrauth：打包位置不同
185
  // bits 52..48 of x11 is hash_shift
186
  lsr  x17, x11, #48      // w17 = (hash_shift, hash_mask)
187
  lsr  w9, w12, w17      // >>= shift　← 偏移右移 hash_shift
188
  and  x9, x9, x11, LSR #53    // &=  mask　← x9 = 条目下标
189
#endif
190

191
  // —— 步骤 C：读出打包条目，比对 SEL，命中就算出 IMP；否则按 fallback 重查 ——
192
  // sel_offs is 26 bits because it needs to address a 64 MB buffer (~ 20 MB as of writing)
193
  // keep the remaining 38 bits for the IMP offset, which may need to reach
194
  // across the shared cache. This offset needs to be shifted << 2. We did this
195
  // to give it even more reach, given the alignment of source (the class data)
196
  // and destination (the IMP)
197
  // 一条条目 8 字节，把 SEL 偏移和 IMP 偏移压在一起：高 26 位 sel_offs、低 38 位 imp_offs
198
  ldr  x17, [x10, x9, LSL #3]    // x17 == (sel_offs << 38) | imp_offs　← 取出该条目
199
  cmp  x12, x17, LSR #38    // 用我们算的 sel 偏移 比对 条目里存的 sel_offs（高 26 位）
200

201
.if \Mode == GETIMP
202
  b.ne  \MissLabelConstant    // cache miss　← 对不上：常量缓存未命中
203
  sbfiz x17, x17, #2, #38         // imp_offs = combined_imp_and_sel[0..37] << 2　← 取低 38 位再 <<2 还原 IMP 偏移
204
  sub  x0, x16, x17            // imp = isa - imp_offs　← IMP = isa 基址 - 偏移
205
  SignAsImp x0, x17      // 给 IMP 重新签名
206
  ret          // GETIMP 模式：把 IMP 放 x0 返回
207
.else
208
  b.ne  5f                // cache miss　← 对不上：跳 fallback 重查
209
  sbfiz x17, x17, #2, #38         // imp_offs = combined_imp_and_sel[0..37] << 2　← 还原 IMP 偏移
210
  sub x17, x16, x17               // imp = isa - imp_offs　← 算出 IMP
211
.if \Mode == NORMAL
212
  br  x17        // NORMAL：直接尾跳进方法实现
213
.elseif \Mode == LOOKUP
214
  orr x16, x16, #3 // for instrumentation, note that we hit a constant cache　← 在 isa 低位打标记：本次命中的是常量缓存
215
  SignAsImp x17, x10      // 给 IMP 签名
216
  ret          // LOOKUP：返回 IMP，不跳转
217
.else
218
.abort  unhandled mode \Mode
219
.endif
220

221
  // —— fallback：本类常量缓存没有 → 顺着 fallback 指向的另一个 isa 再查一遍 ——
222
5:  ldur  x9, [x10, #-16]      // offset -16 is the fallback offset　← buckets 前 16B 存的是 fallback 偏移
223
  add  x16, x16, x9      // compute the fallback isa　← isa += 偏移，得到 fallback 类
224
  b  LLookupStart\Function    // lookup again with a new isa　← 带新 isa 回到 ① 重新走整套查找
225
.endif
226
#endif // CONFIG_USE_PREOPT_CACHES