手撕iOS底层15 -- 方法慢速的查找

一次发生message send的过程就是一次方法的调用过程。发送message只需要指定SEL和receiver， Runtime的objc_msgSend就会根据id self的isa获取class，在class中的cache中走快速查找找method，cache中找不到 ，转而走在class中的rw的methods以c方式慢速查找方法， 找到方法，返回该方法的IMP去调用，从而完成方法的调用，这个流程是能找到的情况。

在上一篇objc_msgSend通过汇编来查找方法缓存的流程。但没有分析未找到缓存的c方法慢速查找，这篇继上一篇开启方法的慢速查找流程。

最近考虑换工作，有坑位的望推荐啊哈，base 北京

0x00 - 汇编跟流程分析objc_msgSend

通过上一篇文章的流程图得知，在CheckMiss NORMAL或者JumpMiss NORMAL都会进入__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

__objc_msgSend_uncached做的事情也很少，就是调用MethodTableLookup进行方法查找

// 方法查找
.macro MethodTableLookup

// 保存寄存器
SAVE_REGS

// lookUpImpOrForward(obj, sel, cls, LOOKUP_INITIALIZE | LOOKUP_RESOLVER)
// receiver and selector already in x0 and x1

// 第 3 个参数是 cls，x16 中保存了 cls
mov  x2, x16

// LOOKUP_INITIALIZE = 1, LOOKUP_RESOLVER = 2, 两者或运算 = 3
mov  x3, #3

// 调用 _lookUpImpOrForward 进行查找，最后查找到的 imp 放到 x0 中
bl  _lookUpImpOrForward

// IMP in x0
// 将 imp 放到 x17
mov  x17, x0

// 恢复寄存器
RESTORE_REGS

.endmacro

• 保存寄存器
• 给_lookUpImpOrForward函数设置需要的参数，函数前8个参数保存在x0到x7中
• 跳转到_lookUpImpOrForward方法执行查找
• 将返回到函数返回的IMP放到x17中，和之前缓存查找放的位置保持一致
• 恢复寄存器

之后调用TailCallFunctionPointer x17执行 最后一步

.macro TailCallFunctionPointer

// $0 = function pointer value
br  $0

.endmacro

TailCallFunctionPointer 也只是通过br指令执行传进来的参数IMP。 到这里就汇编部分就执行完了， 今天我们主要深入探索_lookUpImpOrForward 。

汇编验证

还是先通过代码实操来演示上述的流程

在sayHello上打个断点，把断点停到这里

开启汇编显示， 打开Always Show Disassembly，

进入到汇编，把断点停到objc_msgSend这里

点control跳进消息流程

顶部显示进入到流程

在底部看到_obj_msgSend_uncached，这里和汇编代码看到的是一样的

还是点按control进到里边的流程

进入到缓存未命中的流程，开启方法的慢速查找流程，即调用lookUpImpOrForward方法

0x01 - 底层慢速查找流程

打开一份objc-781的源码，根据上一步分析的结果，去搜索_lookUpImpOrForward到这里

😄从汇编到c++少一个_，从c++到c再少一个_

IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior) 进入到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();

    // 快速查找，如果找到则直接返回imp
    //目的：防止多线程操作时，刚好调用函数，此时缓存进来了
    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;

    //----查找类的缓存
    
    // unreasonableClassCount -- 表示类的迭代的上限
    //（猜测这里递归的原因是attempts在第一次循环时作了减一操作，然后再次循环时,仍在上限的范围内，所以可以继续递归）
    for (unsigned attempts = unreasonableClassCount();;) { 
        //---当前类方法列表（采用二分查找算法），如果找到，则返回，将方法缓存到cache中
        Method meth = getMethodNoSuper_nolock(curClass, sel);
        if (meth) {
            imp = meth->imp;
            goto done;
        }
        //当前类 = 当前类的父类，并判断父类是否为nil
        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;
}

---

主要有以下几步:

• checkIsKnownClass(cls);

ALWAYS_INLINE
static void
checkIsKnownClass(Class cls)
{
    if (slowpath(!isKnownClass(cls))) {
        _objc_fatal("Attempt to use unknown class %p.", cls);
    }
}

检查这个类是否正确的加载，在runtime中能否感知到这个类，如果可以返回true， 识别不了这个类，则报错误Attempt to use unknown class

• 根据条件是否执行realizeClassMaybeSwiftAndLeaveLocked 和initializeAndLeaveLocked实现和初始化类的一些信息，如确定继承链，因为后续的流程必须要有这个，所以在走流程前需要检查类的这些信息。
• 把curClass设置为当前要搜索的类
• 第一步：在for循环里，首先在getMethodNoSuper_nolock(curClass, sel); 这里找imp， 也就是现在自己的类的方法列表找，这里寻找的方法用了二分查找. 按照类继承链，或者元类继承链来找，如果找到，直接goto done，开始做缓存的插入log_and_fill_cache和返回IMP。
• 第二步：如果自己类的方法列表没找到，把if (slowpath((curClass = curClass->superclass) == nil)) ,也就是把curClass设置为父类，如果父类是nil， 就会把imp=forward_imp。
• 然后通过cache_getImp 走汇编快速查找流程，可以看上一篇写的快速查找流程，唯一不一样的地方是，这里的JumpMiss $0和CheckMiss 走的是GETIMP，返回LGetImpMiss

LGetImpMiss:
	mov	p0, #0
	ret

• 接着判断imp是否是forward_imp，如果是，就break循环
• 最后判断是否是在父类找到imp.
• 接着回到第一步继续循环，直到父类为nil

可以结合示例代码和我画的长长长流程图来理解。

0x02 - 二分查找 Binary Search也叫half-interval search

二分查找算法，也叫折半查找算法，属于区间查找(Interval Search)，分治思想的很好例证。二分查找针对一个有序的集合，每次都是通过跟中间元素的对比，将查找的区间缩小一半，直到找到要查找的元素，或者区间缩小为0.

• 针对有序数据
• 数据量太小不适合用
• 数据量太大也不适合

在getMethodNoSuper_nolock查找方法中，使用了二分查找方法来搜索方法的IMP

/***********************************************************************
 * search_method_list_inline
 **********************************************************************/
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;
    
    /**
     二分查找
     sel 排序问题
     */
    for (count = list->count; count != 0; count >>= 1) {
        probe = base + (count >> 1);
        
        uintptr_t probeValue = (uintptr_t)probe->name;
        
        if (keyValue == probeValue) {
            // `probe` is a match.
            // Rewind looking for the *first* occurrence of this value.
            // This is required for correct category overrides.
            while (probe > first && keyValue == (uintptr_t)probe[-1].name) {
                probe--;
            }
            return (method_t *)probe;
        }
        
        if (keyValue > probeValue) {
            base = probe + 1;
            count--;
        }
    }
    
    return nil;
}

如果找到了 if (keyValue == probeValue)，也就是这里的条件为真了，

 //如果查找的key的keyvalue等于中间位置（probe）的probeValue，则直接返回中间位置
        if (keyValue == probeValue) { 
            // -- while 平移 -- 排除分类重名方法
            while (probe > first && keyValue == (uintptr_t)probe[-1].name) {
                //排除分类重名方法（方法的存储是先存储类方法，在存储分类---按照先进后出的原则，分类方法最先出，而我们要取的类方法，所以需要先排除分类方法）
                //如果是两个分类，就看谁先进行加载
                probe--;
            }
            return (method_t *)probe;
        }

这里是把指针往前减了1，是因为如果有分类同名的方法，分类方法后入栈的，所以往前减1找到类方法返回。

这个就很好理解了，根据下面的例子的就理解上边的了。我是这么做的。

int binarySearch(int arr[], int count, int keyValue) {
    int probeMid;
    int base = 0;
    
    for (int n = count; n != 0; n >>= 1) {
        probeMid = base + (n >> 1);
        int probeValue = arr[probeMid];
        if (keyValue == probeValue) {
            return probeValue;
        }
        
        if (keyValue > probeValue) {
            base = probeMid + 1;
            n--;
        }
    }
    return -1;
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int arr[] = { 5, 13, 19, 21, 37, 56, 64, 75, 80, 88, 92 };
        int n = sizeof(arr) / sizeof(arr[0]);
        int index = binarySearch(arr, n, 65);
    }
    return 0;
}

---

欢迎大佬留言指正😄，码字不易，觉得好给个赞👍 有任何表达或者理解失误请留言交流；共同进步；