objc_msgSend消息快速查找

消息发送之快速转发

在之前文章objc_class中的cache_t分析中，我们分析了，cache_t存储方法的过程，有留下一个疑问：cache_t在存储方法之前有读取方法的，那它是怎么读取方法的呢？

首先，让我们先了解，什么是方法，方法的本质是什么。顾名思义，类或者对象调用一个API，这个API就是方法，平时我们接触太多了，有自己定义的方法，也有调用系统的方法，那么这个方法在底层到底是什么？在何时调用的。

一、方法的本质
1.1 方法是何时调用

1. 创建一个student类，Teacher类，student继承Teacher。在student里声明sayStu方法，但没有实现。> 编译时和运行时图

2. 依次编译（command+B)、运行（command+R），结果：编译是成功的，运行时是崩溃报错的>
   

   方法没实现@2x.png

3. 可以得知我们方法都是在运行时执行的。

   补充：编译时和运行时概念
   编译时：编译器把源代码翻译成机器可以识别的代码过程。简单的说，是个翻译的工作，检查代码里有没有错写的关键字、词法分析、语法分析之类静态类型检查
   运行时：简单得说，就是代码跑起来，被装载到内存里面去（代码保存在磁盘上没有装入到内存之前是个死的东西，只有到内存里才是活的），如果此时出错，则程序会崩溃，是一个动态阶段。
   OC的运行时机制：一是将数据类型的确定由编译时，推迟到运行时。OC的这种运行时机制使对象的类型及对象的属性和方法在运行时才能确定；二是让OC具备多态（不同对象以自己的方式响应相同的消息）特性
   Runtime的三种调用：oc代码调用（如自定义方法）、framework调用（系统方法） 、RuntimeAPI（如class_getInstanceSize)调用

runtime三种方法调用.png

1.2 方法在底层是如何实现的

• 下面我们给student加上sayStu的实现，再clang一下main.m文件，看下底层方法是如何调用的

  clang（是一个由Apple主导编写，基于LLVM的C/C++/OC的编译器）:clang -rewrite-objc main.m -o main.cpp
  搜索sayStu，可以观察到，其实是调用了objc_msgSend函数，而且alloc方法也调用了objc_msgSend函数
  

  方法的本质@2x.png

• 调用格式：objc_msgSend： (消息接收者, 消息主体)

• 尝试在main文件里使用objc_msgSend调用方法
  需要导入头文件#import ；
  手动关闭运行时的编译警告: buildSettings->Enable Strict Checking of objc_msgSend Calls->设置为No（对objc_msgSend调用的严格检查关闭）
  加入测试代码objc_msgSend(p, sel_registerName("sayStu"));
  打印结果
  

  三种方式调用@2x.png

  我们发现，是调用成功的，三种形式的调用方式都是一个效果。
  由此我们可以得出结论：方法的本质就是方法名和对应的函数代码
  oc层面：是对象/类+方法名
  底层层面：是objc_msgSend发送消息sel->通过sel（方法编号）找到imp(函数指针地址) -> 找到函数内容
  上述流程我们唯一不清楚的是怎么通过sel找到imp的
  下面就分析方法编号是如何绑定函数指针地址的

二、objc_msgSend解析

• 打开objc源码，搜索objc_msgsend，发现objc_msgsend是汇编语言写的。原因是：一是整个程序方法很多，调用极其频繁的，所以要求速度快。二是参数的不确定性，如果用C/C++，它们是静态性的，速度会很慢。总体来说还是为了性能更好。
• 还有一个疑问是，objc_msgSend为什么需要需要传入参数消息接受者，这是因为消息接受者里有isa，isa->类/元类->cache_t（方法缓存）->methodlist(存在bits里）
• imp的查找分为2个阶段，快速查找（从缓存cache中查找，汇编语言编写）和慢速查找(方法列表methodTable中，c/c++编写)，今天先分析快速查找
• 打开objc源码，搜索objc_msgsend，选择arm64真机环境进行探索(其他环境也是类似），找到objc_msgSend入口

ENTRY _objc_msgSend
    UNWIND _objc_msgSend, NoFrame
//p0 和空对比，即判断接收者是否存在，其中p0是objc_msgSend的第一个参数-消息接收者receiver
    cmp p0, #0          // nil check and tagged pointer check
#if SUPPORT_TAGGED_POINTERS//支持taggedpointer（小对象类型）的流程
    b.le    LNilOrTagged//判断是否是小对象或者为nil，则跳转到LNilOrTagged//  (MSB tagged pointer looks negative)//
#else
    b.eq    LReturnZero//p0 等于 0 时，直接返回 空
#endif
//p0即receiver 肯定存在的消息的流程
//根据对象内存，首地址是isa，拿出isa ，即从x0寄存器指向的地址 取出 isa，存入 p13寄存器
    ldr p13, [x0]       // p13 = isa
//p16 = isa（p13） & ISA_MASK，得到class
    GetClassFromIsa_p16 p13     // p16 = class
LGetIsaDone://获取完毕
    // calls imp or objc_msgSend_uncached
    CacheLookup NORMAL, _objc_msgSend//在缓存中寻找IMP

以上步骤： 1、判断objc_msgSend 的第一个参数，即接受者是否为空。如果为空：则跳转到 LReturnZero流程，赋值为空。如果是TAGGED_POINTERS（小对象：如nsstring、nsnumber等类型，它们本身就是值，），则跳转到LNilOrTagged，如果小对象为空，则也跳转到LReturnZero，赋值为空；如果不为空，则跳转步骤2。如果既不为空，也不是小对象，则取出isa，存入p13寄存器，执行GetClassFromIsa_p16：也是步骤2
2、

#if SUPPORT_INDEXED_ISA
    .align 3
    .globl _objc_indexed_classes
_objc_indexed_classes:
    .fill ISA_INDEX_COUNT, PTRSIZE, 0
#endif

.macro GetClassFromIsa_p16 /* src */

#if SUPPORT_INDEXED_ISA
    // Indexed isa
//将isa的值存入p16寄存器
    mov p16, $0         // optimistically set dst = src
//判断是否是 nonapointer isa
    tbz p16, #ISA_INDEX_IS_NPI_BIT, 1f  // done if not non-pointer isa
    // isa in p16 is indexed
//将_objc_indexed_classes所在的页的基址 读入x10寄存器 ：
    adrp    x10, _objc_indexed_classes@PAGE
//x10基址 根据 偏移量 进行 内存偏移：x10 = x10 + _objc_indexed_classes(page中的偏移量)
    add x10, x10, _objc_indexed_classes@PAGEOFF
//从p16的第ISA_INDEX_SHIFT位开始，提取 ISA_INDEX_BITS 位 到 p16寄存器，剩余的高位用0补充
    ubfx    p16, p16, #ISA_INDEX_SHIFT, #ISA_INDEX_BITS  // extract index
//将x10+p16PTRSHIFT字节存到p16中
    ldr p16, [x10, p16, UXTP #PTRSHIFT] // load class from array
1:

#elif __LP64__//用于64位系统
    // 64-bit packed isa
//p16 = isa & ISA_MASK(位运算 & 即获取isa中的shiftcls信息)= class
    and p16, $0, #ISA_MASK

#else
    // 32-bit raw isa
//用于32位系统
    mov p16, $0

#endif

.endmacro

3、第二步结束后，就执行到CacheLookup NORMAL, _objc_msgSend（快速查找流程），搜索CacheLookup，objc-msg-arm64.s汇编文件中搜索CacheLookup，找到.macro CacheLookup定义处

.macro CacheLookup
    //
    // Restart protocol:
    //
    //   As soon as we're past the LLookupStart$1 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$1,
    //   then our PC will be reset to LLookupRecover$1 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
    //
LLookupStart$1:
//---- p1 = SEL, p16 = isa --- #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位）
    // p1 = SEL, p16 = isa
    ldr p11, [x16, #CACHE]              // p11 = mask|buckets
////---- 64位真机
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
//--- p11(cache) & 0x0000ffffffffffff ，mask高16位抹零，得到buckets 存入p10寄存器-- 即去掉mask，留下buckets
    and p10, p11, #0x0000ffffffffffff   // p10 = buckets
//--- p11(cache)右移48位，得到mask（即p11 存储mask），mask & p1(msgSend的第二个参数 cmd-sel) ，得到sel-imp的下标index（即搜索下标） 存入p12（cache insert写入时的哈希下标计算是 通过 sel & mask，读取时也需要通过这种方式）
    and p12, p1, p11, LSR #48       // x12 = _cmd & mask
//--- 非64位真机
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
    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

//--- p12是下标 p10是buckets数组首地址，下标 * 1<<4(即16) 得到实际内存的偏移量，通过buckets的首地址偏移，获取bucket存入p12寄存器
//--- LSL #(1+PTRSHIFT)-- 实际含义就是得到一个bucket占用的内存大小 -- 相当于mask = occupied -1-- _cmd & mask -- 取余数
    add p12, p10, p12, LSL #(1+PTRSHIFT)
                     // p12 = buckets + ((_cmd & mask) << (1+PTRSHIFT))
//--- 从x12（即p12）中取出 bucket 分别将imp和sel 存入 p17（存储imp） 和 p9（存储sel）
    ldp p17, p9, [x12]      // {imp, sel} = *bucket
////--- 比较 sel 与 p1（传入的参数cmd）
1:  cmp p9, p1          // if (bucket->sel != _cmd)
////--- 如果不相等，即没有找到，请跳转至 2f
    b.ne    2f          //     scan more
//--- 如果相等 即cacheHit 缓存命中，直接返回imp
    CacheHit $0         // call or return imp
    
2:  // not hit: p12 = not-hit bucket
//--- 如果一直都找不到，则CheckMiss， 因为是normal ，跳转至__objc_msgSend_uncached
    CheckMiss $0            // miss if bucket->sel == 0
//--- 判断p12（下标对应的bucket） 是否 等于 p10（buckets数组第一个元素，），如果等于，则跳转至第3步
    cmp p12, p10        // wrap if bucket == buckets
    b.eq    3f
//-- 从x12（即p12 buckets首地址）- 实际需要平移的内存大小BUCKET_SIZE，得到得到第二个bucket元素，imp-sel分别存入p17-p9，即向前查找
    ldp p17, p9, [x12, #-BUCKET_SIZE]!  // {imp, sel} = *--bucket
////--- 跳转至第1步，继续对比 sel 与 cmd
    b   1b          // loop

3:  // wrap: p12 = first bucket, w11 = mask
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
//--- 设置到最后一个元素
//--- p11（mask）右移44位 相当于mask左移4位，直接定位到buckets的最后一个元素，缓存查找顺序是向前查找
    add p12, p12, p11, LSR #(48 - (1+PTRSHIFT))
                    // p12 = buckets + (mask << 1+PTRSHIFT)
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
    add p12, p12, p11, LSL #(1+PTRSHIFT)
                    // p12 = buckets + (mask << 1+PTRSHIFT)
#else
#error Unsupported cache mask storage for ARM64.
#endif

    // Clone scanning loop to miss instead of hang when cache is corrupt.
    // The slow path may detect any corruption and halt later.
//--- 再查找一遍缓存()
//--- 拿到x12（即p12）bucket中的 imp-sel 分别存入 p17-p9
    ldp p17, p9, [x12]      // {imp, sel} = *bucket
//--- 比较 sel 与 p1（传入的参数cmd）
1:  cmp p9, p1          // if (bucket->sel != _cmd)
//--- 如果不相等，即走到第二步
    b.ne    2f          //     scan more
//--- 如果相等 即命中，直接返回imp
    CacheHit $0         // call or return imp
    
2:  // not hit: p12 = not-hit bucket
//--- 如果还是没找不到，则CheckMiss
    CheckMiss $0            // miss if bucket->sel == 0
//--- 判断p12（下标对应的bucket） 是否 等于 p10（buckets数组第一个元素）-- 表示前面已经没有了，但是还是没有找到
    cmp p12, p10        // wrap if bucket == buckets
////如果等于，跳转至第3步
    b.eq    3f
//--- 从x12（即p12 buckets首地址）- 实际需要平移的内存大小BUCKET_SIZE，得到得到第二个bucket元素，imp-sel分别存入p17-p9，即向前查找
    ldp p17, p9, [x12, #-BUCKET_SIZE]!  // {imp, sel} = *--bucket
//--- 跳转至第1步，继续对比 sel 与 cmd
    b   1b          // loop

LLookupEnd$1:
LLookupRecover$1:
3:  // double wrap
//--- 跳转至JumpMiss 因为是normal ，跳转至__objc_msgSend_uncached
    JumpMiss $0

.endmacro

以上其中CacheLookup NORMAL流程主要分为以下几个步骤

• 通过类首地址平移16字节（因为在objc_class中，首地址距离cache正好16字节，isa占8字节，superClass占8字节），得到cahce，cache中高16位存mask，低48位存buckets，即p11 = cache
• 从cache中分别取出buckets和mask，并由mask根据哈希算法计算出哈希下标；通过cache和掩码（即0x0000ffffffffffff（二进制是前16位为0，后48位为1）的 & 运算，将高16位mask抹零，得到buckets指针地址，即p10 = buckets
• 将cache右移48位，得到mask，即p11 = mask
• 将objc_msgSend的参数p1（即第二个参数_cmd）& mask,通过哈希算法，得到需要查找存储sel-imp的bucket下标index，即p12 = index = _cmd & mask,用这个算法，是因为在存储sel-imp时，也是通过同样哈希算法计算哈希下标进行存储的。
• 根据下标，在buckets里根据index*16内存偏移（一个bucket的大小）得到对应存储的bucket，并拿出其中的sel（p9）和_cmd进行比较， 如果相等，说明命中了，则跳转到CacheHit，寻找imp

缓存命中@2x.png

如果不相等，有两种情况
一、如果一直都找不到，直接跳转至CheckMiss，因为是normal，会跳转至__objc_msgSend_uncached，进入慢速查找流程
二、【1】如果根据当前获取到的bucket 等于 buckets的第一个元素，则人为的将当前bucket设置为buckets的最后一个元素（通过buckets首地址+mask右移44位（左移4位）直接定位到buckets的最后一个元素），然后继续进行递归循环，即【3】
【2】如果当前bucket不等于buckets的第一个元素，则p12向前移一个bucket位置，进入第一次递归循环。
【3】第二次递归循环：重复【2】的操作，如果当前的bucket还是等于 buckets的第一个元素，则直接跳转至JumpMiss，到__objc_msgSend_uncached，也进入慢速查找流程
CheckMiss和JumpMiss具体实现如下，

缓存没命中@2x.png

都进入到__objc_msgSend_uncached，即慢速查找流程
具体实现

[email protected]

以上即是整个方法快速查找流程
整个流程图流程图如下

慢速流程@2x.png