iOS—OC方法查找流程

下边的图是查看Runtime源码（objc-756），概括出来的大概的OC 方法查找流程。

sel-IMP查找流程

首先你需要知道一些基本的知识，了解一个alloc 出来的对象，它都包含什么？
你要了解 ISA走位图，superclass的走位图。

知道：对象分为：实例对象（Instance Object），类对象（Class Object），元类对象（Meta Class）
-实例方法存放在类对象里，+类方法存放在元类对象里

知道：Runtime是由汇编语言C C++语言编成的，提供运行时功能的库。

知道：OC对象的本质是在C层面，它是一个Struct，方法调用，是发送消息。

知道：将下面代码转译成C++代码，clang -rewrite-objc main.m，转译生成main.cpp文件后，方法是objc_msgSend

LGTeacher *p = [LGTeacher alloc];
[p sayHello];

OC方法查找可大概分为慢速查找和快速查找。

开启Xcode debug 汇编模式，断点方法调用，会找到_objc_msgSend汇编代码。

1:在objc-msg-arm64.s中找到 ENTRY _objc_msgSend,

    ENTRY _objc_msgSend
    UNWIND _objc_msgSend, NoFrame

    cmp p0, #0          // nil check and tagged pointer check
#if SUPPORT_TAGGED_POINTERS
    b.le    LNilOrTagged        //  (MSB tagged pointer looks negative)
#else
    b.eq    LReturnZero
#endif
    ldr p13, [x0]       // p13 = isa
    GetClassFromIsa_p16 p13     // p16 = class
LGetIsaDone:
    // calls imp or objc_msgSend_uncached
    CacheLookup NORMAL, _objc_msgSend
......

其上，会发现，进入_objc_msgSend，会进行
1：Tagged Pointer 判定
2：isa 与 class 绑定
3：然后CacheLookup NORMAL（// calls imp or 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

.macro MethodTableLookup
    ....

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

CacheLookup or objc_msgSend_uncached，若找到imp 则返回IMP，否则进入慢速查找lookUpImpOrForward

2:在objc-runtime-new.mm找到lookUpImpOrForward

IMP lookUpImpOrForward(Class cls, SEL sel, id inst, 
                       bool initialize, bool cache, bool resolver)
{
    IMP imp = nil;
    bool triedResolver = NO;

    runtimeLock.assertUnlocked();

    // Optimistic cache lookup
    if (cache) {//缓存返回imp
        imp = cache_getImp(cls, sel);
        if (imp) return imp;
    }
    runtimeLock.lock();// 多个sel 查找，需要加锁
    checkIsKnownClass(cls);// check unKnown cls

    if (!cls->isRealized()) {//检测类是否 已实现（构建）
        realizeClass(cls);//实现类（构建类）
    }

    if (initialize  &&  !cls->isInitialized()) {//初始化 cls
        runtimeLock.unlock();
        _class_initialize (_class_getNonMetaClass(cls, inst));
        runtimeLock.lock();
        // If sel == initialize, _class_initialize will send +initialize and 
        // then the messenger will send +initialize again after this 
        // procedure finishes. Of course, if this is not being called 
        // from the messenger then it won't happen. 2778172
    }

    
 retry:    
    runtimeLock.assertLocked();

    // Try this class's cache.

    imp = cache_getImp(cls, sel);//缓存查找
    if (imp) goto done;
    // 1: 查找当前cls的方法list
    // Try this class's method lists.
    {
        Method meth = getMethodNoSuper_nolock(cls, sel);//方法查找
        if (meth) {
            log_and_fill_cache(cls, meth->imp, sel, inst, cls);//缓存
            imp = meth->imp;
            goto done;
        }
    }
    // 2:查找父类的缓存和方法list
    // Try superclass caches and method lists.
    {
        unsigned attempts = unreasonableClassCount();
        for (Class curClass = cls->superclass;
             curClass != nil;
             curClass = curClass->superclass)
        {
            // Halt if there is a cycle in the superclass chain.
            if (--attempts == 0) {
                _objc_fatal("Memory corruption in class list.");
            }
            
            // Superclass cache.
            imp = cache_getImp(curClass, sel);
            if (imp) {
                if (imp != (IMP)_objc_msgForward_impcache) {
                    // Found the method in a superclass. Cache it in this class.
                    log_and_fill_cache(cls, imp, sel, inst, curClass);
                    goto done;
                }
                else {
                    // Found a forward:: entry in a superclass.
                    // Stop searching, but don't cache yet; call method 
                    // resolver for this class first.
                    break;
                }
            }
            
            // Superclass method list.
            Method meth = getMethodNoSuper_nolock(curClass, sel);
            if (meth) {
                log_and_fill_cache(cls, meth->imp, sel, inst, curClass);
                imp = meth->imp;
                goto done;
            }
        }
    }
    // 3: 没有找到实现，尝试方法 resolver once
    // No implementation found. Try method resolver once.

    if (resolver  &&  !triedResolver) {
        runtimeLock.unlock();
        _class_resolveMethod(cls, sel, inst);
        runtimeLock.lock();
        // Don't cache the result; we don't hold the lock so it may have 
        // changed already. Re-do the search from scratch instead.
        triedResolver = YES;
        goto retry;
    }

    // No implementation found, and method resolver didn't help. 
    // Use forwarding.
    // 4: 实现没有找到，resolver method 没实现，进行消息转发
    imp = (IMP)_objc_msgForward_impcache;
    cache_fill(cls, sel, imp, inst);//进行缓存

 done:
    runtimeLock.unlock();

    return imp;
}

慢速查找流程大体如下：
1：cache_getImp，缓存确认，返回imp
2：try 当前cls的 method list
3：try父类cache和method list
4：没找到 --> try method resolver one
5： no resolver -> try Use forwarding（消息转发）
6：依然没找到，cache_fill()