上一期中，我们研究了objc_msgSend()中的快速查找流程，在流程最后除了命中缓存的CacheHit以外，会转入CheckMiss或者JumpMiss流程

但不管是CheckMiss还是JumpMiss，最终都会走到 __objc_msgSend_uncached函数中。

__objc_msgSend_uncached

STATIC_ENTRY __objc_msgSend_uncached
UNWIND __objc_msgSend_uncached, FrameWithNoSaves

// THIS IS NOT A CALLABLE C FUNCTION
// Out-of-band p16 is the class to search
    
MethodTableLookup
TailCallFunctionPointer x17

END_ENTRY __objc_msgSend_uncached

其中主要包含的方法就是MethodTableLookup方法表查找。

其汇编源码实现为

.macro MethodTableLookup
    
    // push frame
    SignLR
    stp fp, lr, [sp, #-16]!
    mov fp, sp

    // save parameter registers: x0..x8, q0..q7
    sub sp, sp, #(10*8 + 8*16)
    stp q0, q1, [sp, #(0*16)]
    stp q2, q3, [sp, #(2*16)]
    stp q4, q5, [sp, #(4*16)]
    stp q6, q7, [sp, #(6*16)]
    stp x0, x1, [sp, #(8*16+0*8)]
    stp x2, x3, [sp, #(8*16+2*8)]
    stp x4, x5, [sp, #(8*16+4*8)]
    stp x6, x7, [sp, #(8*16+6*8)]
    str x8,     [sp, #(8*16+8*8)]

    // lookUpImpOrForward(obj, sel, cls, LOOKUP_INITIALIZE | LOOKUP_RESOLVER)
    // receiver and selector already in x0 and x1
    mov x2, x16
    mov x3, #3
    bl  _lookUpImpOrForward

    // IMP in x0
    mov x17, x0
    
    // restore registers and return
    ldp q0, q1, [sp, #(0*16)]
    ldp q2, q3, [sp, #(2*16)]
    ldp q4, q5, [sp, #(4*16)]
    ldp q6, q7, [sp, #(6*16)]
    ldp x0, x1, [sp, #(8*16+0*8)]
    ldp x2, x3, [sp, #(8*16+2*8)]
    ldp x4, x5, [sp, #(8*16+4*8)]
    ldp x6, x7, [sp, #(8*16+6*8)]
    ldr x8,     [sp, #(8*16+8*8)]

    mov sp, fp
    ldp fp, lr, [sp], #16
    AuthenticateLR

.endmacro

除了一下寄存器的读取指令外，我们看到流程进入了一个方法_lookUpImpOrForward，接下来研究一下这个_lookUpImpOrForward方法。

为了确定流程没有找错，我们先代码验证一下

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        FQPerson *person = [FQPerson alloc];
        [person sayHelloWorld];
    }
    return 0;
}

断点设在[person sayHelloWorld];上
此时，我们在之前并没有调用过方法，所以cache中应该没有缓存的方法记录，所以应该会走到我们之前提到的__objc_msgSend_uncached中

打开汇编调试debug->debugWorkflow->allways show Disassembly

运行程序

慢速查找流程验证1.jpg

按住control 点击step into 进入objc_msgSend 流程

慢速查找流程验证2.jpg

进入 _objc_msgSend_uncached流程

慢速查找流程验证3.jpg

清楚显示了代码会走到lookUpImpOrForward流程中同时，源码在objc-runtime-new.mm第6095行。

下一步

我们来研究一下这个lookUpImpOrForward；

lookUpImpOrForward

IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    const IMP forward_imp = (IMP)_objc_msgForward_impcache;
    IMP imp = nil;
    Class curClass;

    runtimeLock.assertUnlocked();

    // 进行一次快速查找，目的，如果此时有多线程存入了方法，就能快速拿到数据，无需后续的慢速查找流程
    if (fastpath(behavior & LOOKUP_CACHE)) {
        imp = cache_getImp(cls, sel);
        if (imp) goto done_nolock;
    }

    // 加锁，线程安全
    runtimeLock.lock();

    checkIsKnownClass(cls);

    //判断类是否实现， 如果没有，先实现类。
    if (slowpath(!cls->isRealized())) {
        cls = realizeClassMaybeSwiftAndLeaveLocked(cls, runtimeLock);
    }

    //判断是否初始化，如果没有，先初始化
    if (slowpath((behavior & LOOKUP_INITIALIZE) && !cls->isInitialized())) {
        cls = initializeAndLeaveLocked(cls, inst, runtimeLock);
    }

    runtimeLock.assertLocked();
    curClass = cls;


    for (unsigned attempts = unreasonableClassCount();;) {
        // 当前类的方法列表  二分法查找方法 如果找到，则返回imp ,将方法存入cache中。
        Method meth = getMethodNoSuper_nolock(curClass, sel);
        if (meth) {
            imp = meth->imp;
            goto done;
        }
        //讲类的父类赋值给当前类 并判空
        if (slowpath((curClass = curClass->superclass) == nil)) {
            ///父类为空 则此时说明在继承链中也未找到该方法。
            imp = forward_imp;
            break;
        }


        if (slowpath(--attempts == 0)) {
            _objc_fatal("Memory corruption in class list.");
        }

        //查找父类方法缓存
        imp = cache_getImp(curClass, sel);
        if (slowpath(imp == forward_imp)) {

            //如果在父类中找到了forward，则停止查找，且不缓存，首先调用此类的方法解析器
            break;
        }
        if (fastpath(imp)) {
            //如果在父类的缓存中找到，将其储存到cache中
            goto done;
        }
    }


    if (slowpath(behavior & LOOKUP_RESOLVER)) {
        behavior ^= LOOKUP_RESOLVER;
        //动态方法决议
        return resolveMethod_locked(inst, sel, cls, behavior);
    }

 done:
    //加缓存
    log_and_fill_cache(cls, imp, sel, inst, curClass);
    //解锁
    runtimeLock.unlock();
 done_nolock:
    if (slowpath((behavior & LOOKUP_NIL) && imp == forward_imp)) {
        return nil;
    }
    return imp;
}

其简化流程图为

慢速查找流程.png

其中主要流程为

进入lookUpImpOrForward后回先进入一次快速查找流程，如果其他线程在此前插入缓存数据的话，则可以直接在这里找到返回
判断类 包括类是否有效，是否被实现，是否被初始化为后续的继承链做准备
循环查找

通过二分法查找当前类的方法列表 如果找到跳到完成步骤
将当前类的父类当成当前类，判断当前类是否为nil，为空则终止递归进入动态决议步骤
在当前类（即父类）的缓存中查找方法，如果找到跳到完成步骤。
如果没找到，循环回到分步1，开始二分法查找。

动态决议 如果没有执行过动态决议，则进入动态决议，如果执行过，则进入消息转发流程
完成将方法存入cache ，解锁， 返回 imp

findMethodInSortedMethodList(SEL key, const method_list_t *list) 二分法查找方法

在Method meth = getMethodNoSuper_nolock(curClass, sel);时，我们提到了这是通过二分法查找其中的method。

我们来研究一下这个二分法查找的流程

源码

ALWAYS_INLINE static method_t *
findMethodInSortedMethodList(SEL key, const method_list_t *list)
{
    ASSERT(list);

    const method_t * const first = &list->first;
    const method_t *base = first;//方法列表中的第一个方法
    const method_t *probe;
    uintptr_t keyValue = (uintptr_t)key;
    uint32_t count;
    //每循环一次count 右移一位 即折半一次，当count = 1 循环结束
    for (count = list->count; count != 0; count >>= 1) {
        probe = base + (count >> 1);
        
        uintptr_t probeValue = (uintptr_t)probe->name;
        
        if (keyValue == probeValue) 
        {            
           // 如果相等，匹配名称
            while (probe > first && keyValue == (uintptr_t)probe[-1].name) {
                probe--;
            }
            return (method_t *)probe;
        }
        //不相等时将probe+1位设为base
        if (keyValue > probeValue) {
            base = probe + 1;
            count--;
        }
    }
    
    return nil;
}

示意图

二分法查找流程.png

慢速查找中我们还提到了动态决议，下次我们接着探索。

iOS底层探索 -- objc_msgSend() 慢速查找流程

iOS底层探索 -- objc_msgSend() 慢速查找流程

__objc_msgSend_uncached

lookUpImpOrForward

findMethodInSortedMethodList(SEL key, const method_list_t *list) 二分法查找方法