iOS底层原理10：消息流程分析之快速查找-CFANZ编程社区

本文主要来分析objc_msgSend的方法查找流程
在前面的文章iOS底层原理09：类结构分析——cache属性中，我们分析了cache的写入流程，在写入流程之前，还有一个cache读取流程，即objc_msgSend和cache_getImp

在分析之前，首先来了解什么是 Runtime文档地址

Runtime 介绍

runtime称为运行时，它与编译时的区别：

运行时 是代码跑起来，被装载到内存中的过程，如果此时出错，则程序会崩溃，是一个动态阶段
编译时 是源代码翻译成机器能识别的代码的过程，主要是对语言进行最基本的检查报错，即词法分析、语法分析等，是一个静态的阶段

runtime有下列三种使用方式：

通过OC代码，例如[p sayHello];
通过NSObject方法，例如iskindOfClass
通过Runtime API，例如class_getInstanceSize

探索方法的本质

方法的本质

在iOS底层原理06：对象的本质 & isa中，利用clang将main.m编译成 main.cpp，理解了OC对象的本质，同样的，我们来看看方法在底层编译成什么样子

新建工程如下图，HTPerson类中有两个对象方法，其中sayBye方法未实现

利用clang编译器将main.m编译成 main.cpp：clang -rewrite-objc main.m -o main.cpp，查看编译后的底层实现

//?clang编译后的底层实现
HTPerson *p = ((HTPerson *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("HTPerson"), sel_registerName("alloc"));
((void (*)(id, SEL))(void *)objc_msgSend)((id)p, sel_registerName("sayHello"));
((void (*)(id, SEL))(void *)objc_msgSend)((id)p, sel_registerName("sayBye"));

通过上述代码可以看出，方法的本质就是objc_msgSend消息发送

运行程序，可以编译成功，但是运行时发生崩溃，unrecognized selector sent to instance xxx，是我们开发过程中经常遇到的错误

通过Runtime API调用方法

直接调用objc_msgSend，需要导入头文件#import <objc/message.h>
需要将target --> Build Setting --> enable strict checking of obc_msgSend calls 设置为NO，将严厉的检查机制关掉，否则objc_msgSend的参数会报错
运行程序，查看打印结果

我们发现打印结果是一致的，所以[p sayHello]; 等价于objc_msgSend(p, sel_registerName("sayHello")); 和 objc_msgSend(p, @selector(sayHello));

objc_msgSendSuper方法探究

我们可以通过objc_msgSendSuper来跳过本类，去父类中找方法实现

定义两个类HTPerson和HTStudent，都有- (void)sayHello的方法实现

objc4-818源码中，查看objc_msgSendSuper方法如下

objc_super结构体源码

打印结果如下

【问题】 objc_msgSend 和 objc_msgSendSuper 是如何找到方法实现的？带着这个问题，我们来探索objc_msgSend的源码实现

objc_msgSend 快速查找流程分析

在objc4-818源码中，搜索objc_msgSend，发现都是汇编代码实现的，由于我们日常开发的都是架构是arm64，所以主要来分析arm64.s中的objc_msgSend源码实现

【补充知识】-- Tagged Pointer对象

64位系统与Tagged Pointer对象博客地址
在64位系统中，如果我们真正使用一个指针来存储NSNumber实例，那么我们首先需要一个8字节的指针，另外需要一块内存存储NSNumber实例，这通常又是8字节。这样的内存开销是比较大的。苹果对于NSNumber和NSDate对象，改成了用Tagged Pointer来存储，简单来说，Tagged Pointer是一个假的指针，它的值不再是另一个地址，而就是对应变量的值。

Tagged Pointer主要有以下3个特点：

Tagged Pointer专门用来存储小的对象，例如NSNumber和NSDate
Tagged Pointer指针的值不再是地址了，而是真正的值。所以，实际上它不再是一个对象了，它只是一个披着对象皮的普通变量而已！所以，它的内存并不存储在堆中，也不需要malloc和free。
在内存读取上有着3倍的效率（以前是寻址->发消息->获取值，现在直接获取值），创建时比以前快106倍。

objc_msgSend 汇编源码

objc_msgSend是消息发送的源码的入口，使用汇编实现的，_objc_msgSend源码实现如下

//---- 消息发送 -- 汇编入口--objc_msgSend主要是拿到接收者的isa信息
    ENTRY _objc_msgSend
//---- 无窗口
    UNWIND _objc_msgSend, NoFrame
//---- p0和空对比，即判断接收者是否存在，其中p0是objc_msgSend的第一个参数-消息接收者receiver
    cmp p0, #0          // nil check and tagged pointer check
//---- arm64架构 --支持taggedpointer（小对象类型）的流程
#if SUPPORT_TAGGED_POINTERS
    b.le    LNilOrTagged        //  (MSB tagged pointer looks negative)
#else
    b.eq    LReturnZero
#endif
//---- 从对象的首地址中取值，即拿到isa，存入 p13寄存器
    ldr p13, [x0]       // p13 = isa
//---- 在64位架构下通过 p16 = isa（p13） & ISA_MASK，拿出shiftcls信息，得到class信息
    GetClassFromIsa_p16 p13, 1, x0  // p16 = class
LGetIsaDone:
    // calls imp or objc_msgSend_uncached
//---- 如果有isa，走到CacheLookup 即缓存查找流程，也就是所谓的sel-imp快速查找流程
    CacheLookup NORMAL, _objc_msgSend, __objc_msgSend_uncached

#if SUPPORT_TAGGED_POINTERS
LNilOrTagged:
    b.eq    LReturnZero     // nil check
    GetTaggedClass
    b   LGetIsaDone
// SUPPORT_TAGGED_POINTERS
#endif

LReturnZero:
    // x0 is already zero
    mov x1, #0
    movi    d0, #0
    movi    d1, #0
    movi    d2, #0
    movi    d3, #0
    ret

    END_ENTRY _objc_msgSend

objc_msgSend汇编源码主要有以下几步：

【第一步】判断objc_msgSend方法的第一个参数receiver是否为空
- 如果支持tagged pointer，并且p0 <= 0x0，跳转至LNilOrTagged
  - 如果小对象为空，则直接返回空，即LReturnZero
  - 如果小对象（指的是NSNumber或者NSDate对象）不为空，则处理小对象的获得class，走到【第二步】
- 如果不支持tagged pointer，并且receiver为空，直接返回，跳转至LReturnZero
- 如果即不是小对象，receiver也不为空，有以下两步
  - 从receiver中取出isa存入p13寄存器
  - 通过 GetClassFromIsa_p16中，arm64架构下通过 isa & ISA_MASK 获取shiftcls位域的类信息，即class，GetClassFromIsa_p16的汇编实现如下，然后走到【第二步】

.macro GetClassFromIsa_p16 src, needs_auth, auth_address /* note: auth_address is not required if !needs_auth */

//---- 此处用于watchOS
#if SUPPORT_INDEXED_ISA
    // Indexed isa
    mov p16, \src           // optimistically set dst = src
    tbz p16, #ISA_INDEX_IS_NPI_BIT, 1f  // done if not non-pointer isa
    // isa in p16 is indexed
    adrp    x10, _objc_indexed_classes@PAGE
    add x10, x10, _objc_indexed_classes@PAGEOFF
    ubfx    p16, p16, #ISA_INDEX_SHIFT, #ISA_INDEX_BITS  // extract index
    ldr p16, [x10, p16, UXTP #PTRSHIFT] // load class from array
1:

//---- 用于64位系统
#elif __LP64__
.if \needs_auth == 0 // _cache_getImp takes an authed class already
    mov p16, \src
.else
    // 64-bit packed isa
//---- p16 = class（类收地址） = isa & ISA_MASK(位运算 & 即获取isa中的shiftcls信息)
    ExtractISA p16, \src, \auth_address
.endif
#else
//---- 用于32位系统
    // 32-bit raw isa
    mov p16, \src

#endif

.endmacro

【第二步】获取isa完毕，进入快速查找流程CacheLookup NORMAL

CacheLookup(缓存查找)汇编源码

//---- CacheLookup NORMAL, _objc_msgSend, __objc_msgSend_uncached
//---- 此时的参数：x0：receiver； x1: selector； x16: isa（类的首地址）
.macro CacheLookup Mode, Function, MissLabelDynamic, MissLabelConstant
    //
    // Restart protocol:
    //
    //   As soon as we're past the LLookupStart\Function label we may have
    //   loaded an invalid cache pointer or mask.
    //
    //   When task_restartable_ranges_synchronize() is called,
    //   (or when a signal hits us) before we're past LLookupEnd\Function,
    //   then our PC will be reset to LLookupRecover\Function which forcefully
    //   jumps to the cache-miss codepath which have the following
    //   requirements:
    //
    //   GETIMP:
    //     The cache-miss is just returning NULL (setting x0 to 0)
    //
    //   NORMAL and LOOKUP:
    //   - x0 contains the receiver
    //   - x1 contains the selector
    //   - x16 contains the isa
    //   - other registers are set as per calling conventions
    //

    mov x15, x16            // stash the original isa
LLookupStart\Function:
    // p1 = SEL, p16 = isa
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16_BIG_ADDRS
    ldr p10, [x16, #CACHE]              // p10 = mask|buckets
    lsr p11, p10, #48           // p11 = mask
    and p10, p10, #0xffffffffffff   // p10 = buckets
    and w12, w1, w11            // x12 = _cmd & mask
//---- 【64位真机】
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
//---- #define CACHE (2 * __SIZEOF_POINTER__)，其中 __SIZEOF_POINTER__表示pointer的大小 ，即 2*8 = 16
//---- p11 = mask|buckets -- 从x16（即isa）中平移16字节，取出cache 存入p11寄存器 -- isa距离cache 正好16字节：isa（8字节）-superClass（8字节）-cache（mask高16位 + buckets低48位）
    ldr p11, [x16, #CACHE]          // p11 = mask|buckets
#if CONFIG_USE_PREOPT_CACHES  // arm64架构下 == 1
#if __has_feature(ptrauth_calls) // A12 以上
    tbnz    p11, #0, LLookupPreopt\Function
    and p10, p11, #0x0000ffffffffffff   // p10 = buckets
#else
//---- p10等于 buckets的首地址
    and p10, p11, #0x0000fffffffffffe   // p10 = buckets
//---- tbnz p11, #0，表示_bucketsAndMaybeMask的第0为!=0时，跳转到LLookupPreopt\Function
    tbnz    p11, #0, LLookupPreopt\Function
#endif
//---- eor表示异或 p1=_cmd，p12 = (_cmd ^ (_cmd >> 7))
    eor p12, p1, p1, LSR #7
//---- p11 >> 48 得到mask； x12 = (_cmd ^ (_cmd >> 7)) & mask； 这一步主要是hash计算下标index
    and p12, p12, p11, LSR #48      // x12 = (_cmd ^ (_cmd >> 7)) & mask
#else
    and p10, p11, #0x0000ffffffffffff   // p10 = buckets
    and p12, p1, p11, LSR #48       // x12 = _cmd & mask
#endif // CONFIG_USE_PREOPT_CACHES
//--- 【非64位真机】
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
    ldr p11, [x16, #CACHE]              // p11 = mask|buckets
    and p10, p11, #~0xf         // p10 = buckets
    and p11, p11, #0xf          // p11 = maskShift
    mov p12, #0xffff
    lsr p11, p12, p11           // p11 = mask = 0xffff >> p11
    and p12, p1, p11            // x12 = _cmd & mask
#else
#error Unsupported cache mask storage for ARM64.
#endif

/**
 ---- 此时几个参数分别代表：
 - p10 = buckets;
 - p12 = (_cmd ^ (_cmd >> 7)) & mask  即hash下标;
 - p16 = isa（类的首地址）
 - p11 = _bucketsAndMaybeMask
 - p13 = hash下标对应的bucket地址
 */
//---- PTRSHIFT = 3； p13 = p10 + (p12 << 1+3) 这一步就是为了找到 下标对应的 bucket的位置
    add p13, p10, p12, LSL #(1+PTRSHIFT)
                        // p13 = buckets + ((_cmd & mask) << (1+PTRSHIFT))

                        // do {
//---- ldp操作两个寄存器，从hash下标对应的bucket地址中 取出对应的 imp 和 sel， 然后p13的地址向左平移1步长（hash冲突，重新计算下标，与cache_t 中的insert算法相同）
1:  ldp p17, p9, [x13], #-BUCKET_SIZE   //     {imp, sel} = *bucket--
//---- 比较sel 与要调用的_cmd是否相等
    cmp p9, p1              //     if (sel != _cmd) {
//---- b.ne (not equal)不相等，跳转到#3继续执行
    b.ne    3f              //         scan more
                        //     } else {
//---- CacheHit缓存命中，即在缓存中已经有这个方法了，直接返回imp
2:  CacheHit \Mode              // hit:    call or return imp
                        //     }
//---- 如果p9为空，即 sel == 0，表示缓存中没有这个方法，跳转到__objc_msgSend_uncached
3:  cbz p9, \MissLabelDynamic       //     if (sel == 0) goto Miss;
//---- 如果bucket >= buckets（没有越界），继续跳转到1流程，查找bucket
    cmp p13, p10            // } while (bucket >= buckets)
    b.hs    1b

    // wrap-around:
    //   p10 = first bucket
    //   p11 = mask (and maybe other bits on LP64)
    //   p12 = _cmd & mask
    //
    // A full cache can happen with CACHE_ALLOW_FULL_UTILIZATION.
    // So stop when we circle back to the first probed bucket
    // rather than when hitting the first bucket again.
    //
    // Note that we might probe the initial bucket twice
    // when the first probed slot is the last entry.

//---- 遍历缓存至 buckets首地址还没有找到，则跳到最后一个bucket的位置，继续向前查找，
/**
 ---- 此时几个参数分别代表：
 - p10 = buckets;
 - p12 = (_cmd ^ (_cmd >> 7)) & mask  即hash下标;
 - p16 = isa（类的首地址）
 - p11 = _bucketsAndMaybeMask
 - p13 = hash下标对应的bucket地址
 */
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16_BIG_ADDRS
    add p13, p10, w11, UXTW #(1+PTRSHIFT)
                        // p13 = buckets + (mask << 1+PTRSHIFT)
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
//---- 将p13定位到最后一个 bucket的位置
    add p13, p10, p11, LSR #(48 - (1+PTRSHIFT))
                        // p13 = buckets + (mask << 1+PTRSHIFT)
                        // see comment about maskZeroBits
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
    add p13, p10, p11, LSL #(1+PTRSHIFT)
                        // p13 = buckets + (mask << 1+PTRSHIFT)
#else
#error Unsupported cache mask storage for ARM64.
#endif

//---- p12 = 第一次hash 计算的index
    add p12, p10, p12, LSL #(1+PTRSHIFT)
                        // p12 = first probed bucket

//---- 向前循环查找方法
                        // do {
//---- ldp操作两个寄存器，从hash下标对应的bucket地址中 取出对应的 imp 和 sel， 然后p13的地址向左平移1步长（hash冲突，重新计算下标，与cache_t 中的insert算法相同）
4:  ldp p17, p9, [x13], #-BUCKET_SIZE   //     {imp, sel} = *bucket--
//---- 比较sel 与要调用的_cmd是否相等
    cmp p9, p1              //     if (sel == _cmd)
//---- 如果相等，CacheHit缓存命中，即在缓存中已经有这个方法了，跳转到 【2流程】，然后返回imp
    b.eq    2b              //         goto hit
    cmp p9, #0              // } while (sel != 0 &&
    ccmp    p13, p12, #0, ne        //     bucket > first_probed)
//---- b.hi 表示无符号大于，继续循环执行，跳转【4流程】
    b.hi    4b

LLookupEnd\Function:

LLookupRecover\Function:
//---- 跳转至__objc_msgSend_uncached，即进入慢速查找流程
    b   \MissLabelDynamic

主要分为以下几步

【第一步】通过cache首地址平移16字节（因为在objc_class中，首地址距离cache正好16字节，即isa 占8字节，superClass占8字节）获取cahce，cache中高16位存mask，低48位存buckets，即p11 = cache
【第二步】从cache中分别取出buckets和mask，并由mask根据哈希算法计算出哈希下标
- 通过cache和掩码（即0x0000fffffffffffe）的 & 运算，将高16位mask抹零，得到buckets指针地址，即p10 = buckets
- 将cache右移48位，得到mask，即p11 = mask
- 将objc_msgSend的参数p1（即第二个参数_cmd）& msak，通过哈希算法，得到需要查找存储sel-imp的bucket下标index，即p12 = index = _cmd & mask，为什么通过这种方式呢？因为在存储sel-imp时，也是通过同样哈希算法计算哈希下标进行存储，所以读取也需要通过同样的方式读取，如下所示
【第三步】根据所得的哈希下标index 和 buckets首地址，取出哈希下标对应的bucket
- 其中PTRSHIFT等于3，左移4位（即2^4 = 16字节）的目的是计算出一个bucket实际占用的大小，结构体bucket_t中sel占8字节，imp占8字节
- 根据计算的哈希下标index 乘以 单个bucket占用的内存大小，得到内存中的偏移量
- 通过buckets首地址 + 偏移量，获取哈希下标index对应的bucket地址
【第四步】根据获取的bucket，取出其中的imp存入p17，即p17 = imp，取出sel存入p9，即p9 = sel
【第五步】第一次递归循环
- 比较获取的bucket中sel 与 objc_msgSend的第二个参数的_cmd(即p1)是否相等
- 如果相等，则直接跳转至CacheHit，即缓存命中，返回imp
- 如果不相等，有以下几种情况
  - 如果sel == 0，说明buckets中没有有方法，会跳转至__objc_msgSend_uncached，即进入慢速查找流程
  - 如果当前bucket >= buckets的第一个元素，则继续向前查找，重复【第五步】第一次递归循环
  - 如果发生越界，将bucket定位到buckets的最后一个位置
【第六步】第二次递归循环
- 重复【第五步】的操作，继续向前查找，直到【第二步】计算的哈希下标
- 如果没有找到，跳转至__objc_msgSend_uncached，即进入慢速查找流程

缓存快速查找流程图

流程图-待补充