一、objc_msgSend流程简介

Objective-C是一门面向对象的语言，每一个Objective-C对象都拥有一个类，每个类Class都有自己的方法列表。每一个方法都拥有选择子SEL、一个指向方法实现的函数指针IMP和一些原数据metadata。objc_msgsend的工作就是使用对象和选择子来查询对应的函数指针，从而跳转到该方法的实现位置中。

查找方法的过程可能十分复杂。如果一个方法在当前类中没有找到，那么可能需要递归的在其父类中继续查询。如果在父类中也没有找到，则开始调用runtime中的消息转发机制。

一般情况下，查找的方法需要迅速完成。这似乎与其复杂的查找机制有矛盾。

实际上Objective-C中利用方法缓存(Method Cache)来解决这个矛盾。每一个类都有一个缓存，它将方法存储为一组选择子和函数指针，在Objective-C中称为(IMP)。缓存的数据结构是通过哈希表来实现的，所以查找的速度十分迅速。当我们需要查找方法时，runtime首先会去查询缓存。如果方法没有被命中，则开始那一套复杂的查询过程，找到之后返回并且将结果存储到缓存中，以便下次快速查询。

objc_msgSend是使用汇编语言编写的。其原因是：首先是使用纯C语言是无法编写一个携带未知参数并跳转到任意函数指针的方法。此外，对于objc_msgSend来说速度是十分重要的，只用汇编来实现是非常高效率的。

当然，我们也不希望所有的查询过程都是通过汇编来实现的。一旦使用了非汇编语言那么就会降低速度。所以我们将消息分成了两个部分，即objc_msgSend的高速路径 (fast path ) ，此处所有的实现使用的是汇编语言，以及慢速路径(slow path )部分，此处的实现方式均为C语言。在高速路径中我们可以查询方法的缓存表，如果找到则直接跳转。否则，则通过C语言慢速路径来处理查询。

因此，整个objc_msgSend的过程大体如下：
1、获取传入对象所属的类
2、获取该类的方法缓存表
3、使用传入的sel选择子在缓存中查询
4、如果缓存中不存在，则开始慢速查找流程
5、如果找到，则跳转到IMP映射位置的方法

具体是如何实现的呢？下面开始分析整个流程。

二、方法的本质探索

Objective-C程序中有三种途径和运行时系统runtime交互：
1、Objective-C代码： @selector()
2、NSObject的方法： NSSelectorFromString()
3、runtime函数：sel_registerName()

  Person *person = [Person alloc];
  [person sayHi];
  test();

把 main.m文件使用如下clang编译命令转为cpp文件，会得到下面main.cpp文件

 clang -rewrite-objc main.m -o main.cpp

main.cpp 文件

Person *person = ((Person *(*)(id, SEL))(void *)objc_msgSend).     

((id)objc_getClass("Person"), sel_registerName("alloc"));
((void (*)(id, SEL))(void *)objc_msgSend)((id)person,    
sel_registerName("sayHi"));

test();

然后我们就可以使用objc_msgSend来实现sayHello方法的调用，使用objc_msgSend的时候，需要将Xcode中build setting中Enbale Strict of Checking of objc_msgSend Calls设置为NO，这样才不会报警告。

objc_msgSend(objc_getClass("Person"), sel_registerName("alloc"));
objc_msgSend(person, sel_registerName("sayHi"));

test();

不管是alloc方法还是sayHi方法，底层都是通过objc_msgSend函数来实现的。因此OC方法的本质就是通过objc_msgSend来发送消息。
objc_msgSend(id _Nullable self, SEL _Nonnull op, ...)包含有方法的调用的两个隐藏参数：id self（消息接收者）和SEL sel（方法编号）。
sel_registerName等同于OC中的@selector()
C函数test方法直接执行了，并没有通过objc_msgSend进行消息发送

方法调用（消息发送）的几种情况

1.实例方法的调用

objc_msgSend(person, sel_registerName("sayHi"));

2.类方法的调用

objc_msgSend(objc_getClass("Person"), sel_registerName("alloc"));

3.父类实例方法的调用

 @interface  LGPerson : NSObject 
 -(void)sayHi;
 @end


 @interface LGStudent : LGPerson
 @end
 

 LGStudent *s = [LGStudent alloc];
 [s sayHi];

struct objc_super lgSuper;
lgSuper.receiver = s;
lgSuper.super_class = [LGPerson class];
objc_msgSendSuper(&lgSuper, @selector(sayHi));

4.父类类方法的调用

@interface LGPerson : NSObject 
+(void)sayGoodBye;
@end

@interface LGStudent : LGPerson
@end

LGStudent *s = [LGStudent alloc];
[s sayGoodBye];

struct objc_super myClassSuper;
myClassSuper.receiver = [s class];
myClassSuper.super_class = class_getSuperclass(object_getClass([s   class]));// 元类
objc_msgSendSuper(&myClassSuper, sel_registerName("sayGoodBye"));

三、objc_msgSend流程分析

objc_msgSend的快速查找流程是用汇编实现的，主要原因有

C语言不可能通过写一个函数来保留未知的参数并且跳转到任意一个函数指针。C语言没有满足做这件事情的必要特性。
性能更高，汇编是更接近系统底层的语言。

3.1 _objc_msgSend

打开objc源码，搜索objc_msgSend，直接来到objc_msg_arm64.s的ENTRY _objc_msgSend 中

读取x0的首地址存入p13。x0位第一个参数，就是我们的消息接收者，不管它是类还是对象，它的第一个成员都是isa，所以取x0的首地址，即可得到isa，将isa存入p13.这里取isa的原因是因为，不管是对象方法还是类方法，我们都可以通过isa的指向在类或元类的缓存或方法列表中去查找。所以接下来就是要通过isa取到类或者元类。

此时对isa的处理已经完成，找到了当前类，接下来就是去缓存里面找方法，如果找到则直接返回对象的IMP，CacheLookup的参数分为三种，NORMAL（正常的去查找）、 GETIMP（直接返回 IMP）和 LOOKUP（主动的慢速去查找）。

ENTRY _objc_msgSend
UNWIND _objc_msgSend, NoFrame //没窗口
//对比p0寄存器是否为空，其中x0-x7是参数，x0可能会是返回值
cmp p0, #0          // nil check and tagged pointer check
#if SUPPORT_TAGGED_POINTERS
//如果是LNilOrTagged返回空
b.le    LNilOrTagged        //  (MSB tagged pointer looks negative)
#else
b.eq    LReturnZero
#endif
//ldr是数据读取指令，将x0中的数据读取到p13中
ldr p13, [x0]       // p13 = isa
//根据isa拿到类。
GetClassFromIsa_p16 p13     // p16 = class  GetClassFromIsa_p16是一个宏，取面具，isa & ISA_MASK，得到当前类-获取传入对象所属的类
LGetIsaDone:
//开始缓存查找指针
CacheLookup NORMAL      // calls imp or objc_msgSend_uncached

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

// tagged
adrp    x10, _objc_debug_taggedpointer_classes@PAGE
add x10, x10, _objc_debug_taggedpointer_classes@PAGEOFF
ubfx    x11, x0, #60, #4
ldr x16, [x10, x11, LSL #3]
adrp    x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGE
add x10, x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGEOFF
cmp x10, x16
b.ne    LGetIsaDone

// ext tagged
adrp    x10, _objc_debug_taggedpointer_ext_classes@PAGE
add x10, x10, _objc_debug_taggedpointer_ext_classes@PAGEOFF
ubfx    x11, x0, #52, #8
ldr x16, [x10, x11, LSL #3]
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 + 函数名
END_ENTRY _objc_msgSend

3.2GetClassFromIsa_p16

isa & ISA_MASK，得到当前类

.macro GetClassFromIsa_p16 /* src */

#if SUPPORT_INDEXED_ISA   //苹果手表Watch支持
// Indexed isa
mov p16, $0         // 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:

#elif __LP64__   //64位系统
// 64-bit packed isa
and p16, $0, #ISA_MASK //p16 = $0 & #ISA_MASK

#else
// 32-bit raw isa
mov p16, $0

#endif

.endmacro

3.3CacheLookup 缓存查找

这一步是查找方法缓存，如果命中缓存就走 CacheHit，没找到走 CheckMiss

/********************************************************************
*
* CacheLookup NORMAL|GETIMP|LOOKUP
* 
* Locate the implementation for a selector in a class method cache.
*
* Takes:
*   x1 = selector
*   x16 = class to be searched
*
* Kills:
*   x9,x10,x11,x12, x17
*
* On exit: (found) calls or returns IMP
*                  with x16 = class, x17 = IMP
*          (not found) jumps to LCacheMiss
*
********************************************************************/
.macro CacheLookup

LLookupStart$1:

// p1 = SEL, p16 = isa --- 
// x16代表 class，#CACHE 是一个宏定义 #define CACHE (2 * __SIZEOF_POINTER__)，代表16个字节
// class 平移 CACHE(也就是16个字节)得到 cache_t，然后将 cache_t里面的 buckets|mask 赋值给p11
ldr p11, [x16, #CACHE]              // p11 = mask|buckets (前16位为mask,后48位为buckets)

#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
and p10, p11, #0x0000ffffffffffff   //  0x0000ffffffffffff代表前16位为0，后48位为1， p10 = p11& 0x0000ffffffffffff,得到bucket,  p10 = buckets
and p12, p1, p11, LSR #48       // p11逻辑右移48位，得到mask, x12 = _cmd & mask ，得到方法下标，解析请看3.4 _cmd & mask
#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


add p12, p10, p12, LSL #(1+PTRSHIFT)
                 // p12 = buckets + ((_cmd & mask) << (1+PTRSHIFT))，buckets偏移方法下标（index）* bucket大小（SEL和IMP共16字节），PTRSHIFT 宏定义为3，左移1+3=4位等于16字节，乘以index,相当于得到对应index的bucket， 拿到下标对应的bucket

ldp p17, p9, [x12]      // {imp, sel} = *bucket  判断对应下标的bucket的sel和查找的sel是否相同
//这个地方是p9和P1进行对比  判断是否匹配到缓存
1:  cmp p9, p1          // if (bucket->sel != _cmd)
//b是跳转的意思 .ne是notEquel的意思  也就是如果p9和p1不匹配就跳转下面2，如果匹配就往下走
b.ne    2f          //     scan more
//如果找到就调用并返回CacheHit，缓存命中，传的参数是$0,也就是CacheLookup的参数NORMAL
CacheHit $0         // call or return imp  

2:  // not hit: p12 = not-hit bucket
//没找到就进行CheckMiss操作,传的参数是$0,也就是CacheLookup的参数NORMAL
CheckMiss $0            // miss if bucket->sel == 0
//比较p12和p10 也就是比较取出的bucket和buckets首个元素
cmp p12, p10        // wrap if bucket == buckets
//如果相等 说明我们已经遍历完了buckets 去跳转执行3方法 
b.eq    3f
//这一句递归更上面递归呼应
ldp p17, p9, [x12, #-BUCKET_SIZE]!  // {imp, sel} = *--bucket
b   1b          // loop

3:  // wrap: p12 = first bucket, w11 = mask
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
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.
//再查找一遍缓存 由于多线程的原因，可能当前调用的方法这时可能已经在别的线程调用结束了，也就是说现在可能缓存中已经有了方法的缓存了，这时我们再遍历一遍，也算是再给缓存查找一次机会吧
ldp p17, p9, [x12]      // {imp, sel} = *bucket
1:  cmp p9, p1          // if (bucket->sel != _cmd)
b.ne    2f          //     scan more
CacheHit $0         // call or return imp

2:  // not hit: p12 = not-hit bucket
CheckMiss $0            // miss if bucket->sel == 0
cmp p12, p10        // wrap if bucket == buckets
b.eq    3f
ldp p17, p9, [x12, #-BUCKET_SIZE]!  // {imp, sel} = *--bucket
b   1b          // loop

LLookupEnd$1:
LLookupRecover$1:
3:  // double wrap
JumpMiss $0

.endmacro

3.4 _cmd & mask 获取方法下标

方法下标 = _cmd & mask

获取方法下标.png

3.5 CacheHit

如果命中了，找到了方法我们就调用 CacheHit 函数

.macro CacheHit
.if $0 == NORMAL //传进来的参数是NORMAL,所以调用.   TailCallCachedImp，直接将方法缓存起来然后进行调用就OK了
TailCallCachedImp x17, x12, x1, x16 // authenticate and call imp
.elseif $0 == GETIMP
mov p0, p17
cbz p0, 9f          // don't ptrauth a nil imp
AuthAndResignAsIMP x0, x12, x1, x16 // authenticate imp and re-      sign as IMP
9:  ret             // return IMP
.elseif $0 == LOOKUP
// No nil check for ptrauth: the caller would crash anyway when they
// jump to a nil IMP. We don't care if that jump also fails ptrauth.
AuthAndResignAsIMP x17, x12, x1, x16    // authenticate imp and re-sign as IMP
ret             // return imp via x17
.else
.abort oops
.endif
.endmacro

3.6 CheckMiss

如果没命中，就调用 CheckMiss 函数：

.macro CheckMiss
// miss if bucket->sel == 0
.if $0 == GETIMP
cbz p9, LGetImpMiss
.elseif $0 == NORMAL //传进来的是NORMAL,所以走这里
cbz p9, __objc_msgSend_uncached
.elseif $0 == LOOKUP
cbz p9, __objc_msgLookup_uncached
.else
.abort oops
.endif
.endmacro

四、小结

4.1 伪代码

我们把汇编流程总结为了如下伪代码形式，方便理解整个流程。

// sayHello的 sel 和 从方法缓存找到对应方法index 的 bucket 的 sel 是否相同
[person sayHello]  -> imp ( cache -> bucket (sel imp)) 

// 获取当前的对象
id person = 0x10000
// 获取isa
isa_t isa = 0x000000
// isa -> class -> cache
cache_t cache = isa + 16字节

// arm64
// mask|buckets 在一起的
buckets = cache & 0x0000ffffffffffff
// 获取mask
mask = cache LSR #48
// 下标 = mask & sel
index = mask & p1

// bucket 从 buckets 遍历的开始 (起始查询的bucket)
bucket = buckets + index * 16 (sel imp = 16)


int count = 0
// CheckMiss $0
do{
if ((bucket == buckets) && (count == 0)){ // 进入第二层判断
    // bucket == 第一个元素
    // bucket人为设置到最后一个元素
    bucket = buckets + mask * 16
    count++;      
}else if (count == 1) goto CheckMiss        
// {imp, sel} = *--bucket
// 缓存的查找的顺序是: 向前查找
bucket--;
imp = bucket.imp;
sel = bucket.sel;

}while (bucket.sel != _cmd)  //  // bucket里面的sel 是否匹配_cmd

 // CacheHit $0
 return imp

 CheckMiss:
 CheckMiss(normal)

4.2 _objc_msgSend流程分析图

objc_msgSend流程分析.png

4.3 objc_msgSend流程总结

方法的本质就是消息发送，消息发送是通过 objc_msgSend 以及其派生函数来实现的。
objc_msgSend 是使用汇编写的，主要是速度够快，够灵活（C 语言做不到写一个函数来保留未知的参数并且跳转到任意的函数指针）
objc_msgSend首先通过汇编快速查找方法缓存，如果找到，调用 TailCallCachedImp 直接将方法缓存起来然后进行调用就OK了，如果查找不到就跳到 CheckMiss ，然后走到iOS objc_msgSend慢速查找流程分析。

objc_msgSend-快速查找流程