一、`objc_msgSend` 彙編補充

我們知道，之所以使用匯編來實現 objc_msgSend 有兩個原因:

因爲 C 無法通過寫一個函數來保留未知的參數並且跳轉到一個任意的函數指針。
objc_msgSend 必須足夠快。

1.1 `objc_msgSend` 流程

ENTRY _objc_msgSend
對消息接收者進行判斷、處理 (id self, sel _cmd)
taggedPointer 判斷處理
GetClassFromIsa_p16 isa 指針處理拿到 class
CacheLookup 查找緩存
cache_t 處理 bucket 以及內存哈希處理
- 找不到遞歸下一個 bucket
- 找到了就返回 {imp, sel} = *bucket->imp\
- 遇到意外就重試
- 找不到就跳到 junpMiss
__objc_msgSend_uncached 找不到緩存 imp
STATIC ENTRY __objc_msgSend_uncached
MethodTableLookup 方法表查找
- save parameters registers
- self 以及 _cmd 準備
- _class_lookupMethodAndLoadCache3 調用

二、通過彙編找到下一流程

我們在探索 objc_msgSend 的時候，當找不到緩存的時候，會來到一個地方叫做 objc_msgSend_uncached，然後會來到 MethodTableLookup，然後會有一個核心的查找方法 __class_lookupMethodAndLoadCache3。但是我們知道其實已經要進入 C/C++ 的流程了，所以我們還可以彙編來定位。
我們打開 Always Show Disassembly選項

然後我們進入 objc_msgSend 內部

然後我們進入 _objc_msgSend_uncached 的內部

我們會來到 _class_lookupMethodAndLoadCache3，這就是真正的方法查找實現。

三、代碼分析方法查找流程

3.1 對象方法測試

對象的實例方法 - 自己有
對象的實例方法 - 自己沒有 - 找父類的
對象的實例方法 - 自己沒有 - 父類也沒有 - 找父類的父類 - NSObject
對象的實例方法 - 自己沒有 - 父類也沒有 - 找父類的父類 - NSObject也沒有 - 崩潰

3.2 類方法測試

類方法 - 自己有
類方法 - 自己沒有 - 找父類的
類方法 - 自己沒有 - 父類也沒有 - 找父類的父類 - NSObject
類方法 - 自己沒有 - 父類也沒有 - 找父類的父類 - NSObject也沒有 - 崩潰
類方法 - 自己沒有 - 父類也沒有 - 找父類的父類 - NSObject也沒有 - 但是有對象方法

四、源碼分析方法查找流程

我們直接定位到 _class_lookupMethodAndLoadCache3 源碼處:

IMP _class_lookupMethodAndLoadCache3(id obj, SEL sel, Class cls)
{
    return lookUpImpOrForward(cls, sel, obj, 
                              YES/*initialize*/, NO/*cache*/, YES/*resolver*/);
}

接着我們進入 lookUpImpOrForward，這裏注意一下， cache 是傳的 NO，因爲來到這裏已經說明緩存不存在，所以需要進行方法查找。

4.1 lookUpImpOrForward

我們接着定位到 lookUpImpOrForward 的源碼處：

IMP lookUpImpOrForward(Class cls, SEL sel, id inst, 
                       bool initialize, bool cache, bool resolver)

由該方法的參數我們可以知道，lookUpImpOrForward 應該是個公共方法，initialize 和 cache 分別代表是否避免 +initialize 和是否從緩存中查找。

// Optimistic cache lookup
    if (cache) {
        imp = cache_getImp(cls, sel);
        if (imp) return imp;
    }

如果 cache 爲 YES，那麼就直接調用 cache_getImp 來從 cls 的緩存中獲取 sel 對應的 IMP，如果找到了就返回。

if (!cls->isRealized()) {
        realizeClass(cls);
    }

判斷當前要查找的 cls 是否已經完成了準備工作，如果沒有，則需要進行一下類的 realize。

4.2 從當前類上查找

// 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;
        }
    }

上面的方法很顯然，是從類的方法列表中查找 IMP。這裏加兩個大括號的目的是形成局部作用域，讓命名不會不想衝突。通過 getMethodNoSuper_nolock 查找 Method，找到了之後就調用 log_and_fill_cache 進行緩存的填充，然後返回 imp。

4.2.1 getMethodNoSuper_nolock

static method_t *
getMethodNoSuper_nolock(Class cls, SEL sel)
{
    runtimeLock.assertLocked();

    assert(cls->isRealized());
    // fixme nil cls? 
    // fixme nil sel?

    for (auto mlists = cls->data()->methods.beginLists(), 
              end = cls->data()->methods.endLists(); 
         mlists != end;
         ++mlists)
    {
        method_t *m = search_method_list(*mlists, sel);
        if (m) return m;
    }

    return nil;
}

static method_t *search_method_list(const method_list_t *mlist, SEL sel)
{
    int methodListIsFixedUp = mlist->isFixedUp();
    int methodListHasExpectedSize = mlist->entsize() == sizeof(method_t);
    
    if (__builtin_expect(methodListIsFixedUp && methodListHasExpectedSize, 1)) {
        return findMethodInSortedMethodList(sel, mlist);
    } else {
        // Linear search of unsorted method list
        for (auto& meth : *mlist) {
            if (meth.name == sel) return &meth;
        }
    }

#if DEBUG
    // sanity-check negative results
    if (mlist->isFixedUp()) {
        for (auto& meth : *mlist) {
            if (meth.name == sel) {
                _objc_fatal("linear search worked when binary search did not");
            }
        }
    }
#endif

    return nil;
}

getMethodNoSuper_nolock 實現很簡單，就是從 cls 的 data() 中進行遍歷，然後對遍歷到的 method_list_t 結構體指針再次調用 search_method_list 與 sel 進行匹配。這裏的 findMethodInSortedMethodList 我們再接着往下探索。

4.2.2 findMethodInSortedMethodList

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;
    
    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;
}

findMethodInSortedMethodList 的核心邏輯是二分查找，這種算法的前提是有序的集合。

4.3 從父類中查找

源碼如下:

// 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;
            }
        }
    }

// Superclass cache.
            imp = cache_getImp(curClass, sel);

在父類中查找的時候，和在當前類查找有一點不同的是需要檢查緩存。

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;
                }

如果在父類中找到了 IMP，同時判斷是否是消息轉發的入口，如果不是消息轉發，那麼就把找到的 IMP 通過 log_and_fill_cache 緩存到當前類的緩存中；如果是消息轉發，就退出循環。

// 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;
            }

如果父類緩存中沒有找到，那麼就查找父類的方法列表，這裏和上面在當前類中的方法列表中查找是異曲同工之妙，就不再贅述了。

4.4 方法解析

// 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;
    }

如果在類和父類中都沒有找到，Runtime 給了我們一個機會來進行動態方法解析。

/***********************************************************************
* _class_resolveMethod
* Call +resolveClassMethod or +resolveInstanceMethod.
* Returns nothing; any result would be potentially out-of-date already.
* Does not check if the method already exists.
**********************************************************************/
void _class_resolveMethod(Class cls, SEL sel, id inst)
{
    if (! cls->isMetaClass()) {
        // try [cls resolveInstanceMethod:sel]

        _class_resolveInstanceMethod(cls, sel, inst);
    } 
    else {
        // try [nonMetaClass resolveClassMethod:sel]
        // and [cls resolveInstanceMethod:sel]
        _class_resolveClassMethod(cls, sel, inst);
        if (!lookUpImpOrNil(cls, sel, inst, 
                            NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
        {
            _class_resolveInstanceMethod(cls, sel, inst);
        }
    }
}

我們來分析一下 _class_resolveMethod:

if (! cls->isMetaClass()) {
        // try [cls resolveInstanceMethod:sel]

        _class_resolveInstanceMethod(cls, sel, inst);
    } 
    else {
        // try [nonMetaClass resolveClassMethod:sel]
        // and [cls resolveInstanceMethod:sel]
        _class_resolveClassMethod(cls, sel, inst);
        if (!lookUpImpOrNil(cls, sel, inst, 
                            NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
        {
            _class_resolveInstanceMethod(cls, sel, inst);
        }
    }

判斷當前類是否是元類，如果不是的話，調用 _class_resolveInstanceMethod。
如果是元類的話，說明要查找的是類方法，調用 _class_resolveClassMethod。

4.4.1 _class_resolveInstanceMethod

首先我們分析動態解析對象方法:

static void _class_resolveInstanceMethod(Class cls, SEL sel, id inst)
{
    if (! lookUpImpOrNil(cls->ISA(), SEL_resolveInstanceMethod, cls, 
                         NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
    {
        // Resolver not implemented.
        return;
    }

    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(cls, SEL_resolveInstanceMethod, sel);

    // Cache the result (good or bad) so the resolver doesn't fire next time.
    // +resolveInstanceMethod adds to self a.k.a. cls
    IMP imp = lookUpImpOrNil(cls, sel, inst, 
                             NO/*initialize*/, YES/*cache*/, NO/*resolver*/);

    if (resolved  &&  PrintResolving) {
        if (imp) {
            _objc_inform("RESOLVE: method %c[%s %s] "
                         "dynamically resolved to %p", 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel), imp);
        }
        else {
            // Method resolver didn't add anything?
            _objc_inform("RESOLVE: +[%s resolveInstanceMethod:%s] returned YES"
                         ", but no new implementation of %c[%s %s] was found",
                         cls->nameForLogging(), sel_getName(sel), 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel));
        }
    }
}

IMP lookUpImpOrNil(Class cls, SEL sel, id inst, 
                   bool initialize, bool cache, bool resolver)
{
    IMP imp = lookUpImpOrForward(cls, sel, inst, initialize, cache, resolver);
    if (imp == _objc_msgForward_impcache) return nil;
    else return imp;
}

這裏還有一個注意點：

bool resolved = msg(cls, SEL_resolveInstanceMethod, sel);

對當前 cls 發送 SEL_resolveInstanceMethod 消息，如果返回的是 YES，那說明當前類是實現了動態方法解析。

由上面的代碼可知動態方法解析到最後會回到 lookUpImpOrForward。注意這裏的傳參:
cache 是 YES，resolver 是 NO，什麼意思呢?

Cache the result (good or bad) so the resolver doesn’t fire next time.
緩存查找的結果，所以解析器下一次就不會被觸發，其實本質上就是打破遞歸。

4.4.2 _class_resolveClassMethod

我們接着分析動態解析類方法:

static void _class_resolveClassMethod(Class cls, SEL sel, id inst)
{
    assert(cls->isMetaClass());

    if (! lookUpImpOrNil(cls, SEL_resolveClassMethod, inst, 
                         NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
    {
        // Resolver not implemented.
        return;
    }

    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(_class_getNonMetaClass(cls, inst), 
                        SEL_resolveClassMethod, sel);

    // Cache the result (good or bad) so the resolver doesn't fire next time.
    // +resolveClassMethod adds to self->ISA() a.k.a. cls
    IMP imp = lookUpImpOrNil(cls, sel, inst, 
                             NO/*initialize*/, YES/*cache*/, NO/*resolver*/);

    if (resolved  &&  PrintResolving) {
        if (imp) {
            _objc_inform("RESOLVE: method %c[%s %s] "
                         "dynamically resolved to %p", 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel), imp);
        }
        else {
            // Method resolver didn't add anything?
            _objc_inform("RESOLVE: +[%s resolveClassMethod:%s] returned YES"
                         ", but no new implementation of %c[%s %s] was found",
                         cls->nameForLogging(), sel_getName(sel), 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel));
        }
    }
}

這裏有一個注意點：傳進來的 cls 必須是元類，因爲類方法存在元類的緩存或方法列表中。

// 對象方法動態解析
bool resolved = msg(cls, SEL_resolveInstanceMethod, sel);

// 類方法動態解析
bool resolved = msg(_class_getNonMetaClass(cls, inst), 
                        SEL_resolveClassMethod, sel);

這裏 msg 方法的第一個參數就明顯不同，解析對象方法的時候傳的是當前類，而解析類方法的時候傳的是 _class_getNonMetaClass(cls, inst) 的結果。我們進入 _class_getNonMetaClass 內部:

Class _class_getNonMetaClass(Class cls, id obj)
{
    mutex_locker_t lock(runtimeLock);
    cls = getNonMetaClass(cls, obj);
    assert(cls->isRealized());
    return cls;
}

接着進入 getNonMetaClass，這個方法的目的就是通過元類獲取類，我們去除一些干擾信息:

static Class getNonMetaClass(Class metacls, id inst)
{
    static int total, named, secondary, sharedcache;
    realizeClass(metacls);

    total++;

    // 如果已經不是元類的，那就直接返回
    if (!metacls->isMetaClass()) return metacls;

    // metacls really is a metaclass

    // 根元類的特殊情況，這裏回憶一下，根元類的isa指向的是自己
    // where inst == inst->ISA() == metacls is possible
    if (metacls->ISA() == metacls) {
        Class cls = metacls->superclass;
        assert(cls->isRealized());
        assert(!cls->isMetaClass());
        assert(cls->ISA() == metacls);
        if (cls->ISA() == metacls) return cls;
    }

    // 如果實例不爲空
    if (inst) {
        Class cls = (Class)inst;
        realizeClass(cls);
        // cls 可能是一個子類，這裏通過實例獲取到類對象，
        // 然後通過一個 while 循環來遍歷判斷類對象的 isa 是否是元類
        // 如果是元類的話，就跳出循環；如果不是接着獲取類對象的父類
        // cls may be a subclass - find the real class for metacls
        while (cls  &&  cls->ISA() != metacls) {
            cls = cls->superclass;
            realizeClass(cls);
        }
        // 說明已經找到了當前元類所匹配的類
        if (cls) {
            assert(!cls->isMetaClass());
            assert(cls->ISA() == metacls);
            return cls;
        }
#if DEBUG
        _objc_fatal("cls is not an instance of metacls");
#else
        // release build: be forgiving and fall through to slow lookups
#endif
    }

    // 嘗試命名查詢
    {
        Class cls = getClass(metacls->mangledName());
        if (cls->ISA() == metacls) {
            named++;
            if (PrintInitializing) {
                _objc_inform("INITIALIZE: %d/%d (%g%%) "
                             "successful by-name metaclass lookups",
                             named, total, named*100.0/total);
            }

            realizeClass(cls);
            return cls;
        }
    }

    // 嘗試 NXMapGet
    {
        Class cls = (Class)NXMapGet(nonMetaClasses(), metacls);
        if (cls) {
            secondary++;
            if (PrintInitializing) {
                _objc_inform("INITIALIZE: %d/%d (%g%%) "
                             "successful secondary metaclass lookups",
                             secondary, total, secondary*100.0/total);
            }

            assert(cls->ISA() == metacls);            
            realizeClass(cls);
            return cls;
        }
    }

    // try any duplicates in the dyld shared cache
    // 嘗試從 dyld 動態共享緩存庫中查詢
    {
        Class cls = nil;

        int count;
        Class *classes = copyPreoptimizedClasses(metacls->mangledName(),&count);
        if (classes) {
            for (int i = 0; i < count; i++) {
                if (classes[i]->ISA() == metacls) {
                    cls = classes[i];
                    break;
                }
            }
            free(classes);
        }

        if (cls) {
            sharedcache++;
            if (PrintInitializing) {
                _objc_inform("INITIALIZE: %d/%d (%g%%) "
                             "successful shared cache metaclass lookups",
                             sharedcache, total, sharedcache*100.0/total);
            }

            realizeClass(cls);
            return cls;
        }
    }

    _objc_fatal("no class for metaclass %p", (void*)metacls);
}

4.5 消息轉發

// No implementation found, and method resolver didn't help. 
    // Use forwarding.

    imp = (IMP)_objc_msgForward_impcache;
    cache_fill(cls, sel, imp, inst);

如果動態消息解析仍然失敗，那麼就會來到消息查找的最後一步了，消息轉發。

此時會返回一個類型爲 _objc_msgForward_impcache 的 IMP，然後填充到 cls 中的 cache_t 裏面。至此，我們的消息查找流程就此結束了。

五、總結

方法查找或者說消息查找，起始於 _class_lookupMethodAndLoadCache3。
_class_lookupMethodAndLoadCache3 的核心實現是 lookUpImpOrForward。
從 _class_lookupMethodAndLoadCache3 進入的話，是忽略緩存直接從方法列表中查找。
查找之前會確保類已經完成諸如屬性、方法、協議等內容的 attach。
先從當前類的方法列表中查找，找到了返回，找不到交給父類。
先從父類的緩存中查找，如果找到返回，如果沒有查找方法列表，找到了返回，找不到進行動態方法解析。
根據當前是類還是元類來進行對象方法動態解析和類方法動態解析。
如果解析成功，則返回，如果失敗，進入消息轉發流程。

我們今天一起探索了消息查找的底層，下一章我們將會沿着今天的方向再往下探索方法轉發的流程。敬請期待~

iOS 底層探索 - 消息查找

一、`objc_msgSend` 彙編補充

1.1 `objc_msgSend` 流程

二、通過彙編找到下一流程

三、代碼分析方法查找流程

3.1 對象方法測試

3.2 類方法測試

四、源碼分析方法查找流程

4.1 lookUpImpOrForward

4.2 從當前類上查找

4.2.1 getMethodNoSuper_nolock

4.2.2 findMethodInSortedMethodList

4.3 從父類中查找

4.4 方法解析

4.4.1 _class_resolveInstanceMethod

4.4.2 _class_resolveClassMethod

4.5 消息轉發

五、總結

iOS 底層探索 - 應用加載

iOS 底層探索 - 方法

iOS 底層探索 - alloc & init

iOS 底層探索 - cache_t

iOS 底層探索 - 類

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

iOS 底層探索 - 消息查找

一、objc_msgSend 彙編補充

1.1 objc_msgSend 流程

二、通過彙編找到下一流程

三、代碼分析方法查找流程

3.1 對象方法測試

3.2 類方法測試

四、源碼分析方法查找流程

4.1 lookUpImpOrForward

4.2 從當前類上查找

4.2.1 getMethodNoSuper_nolock

4.2.2 findMethodInSortedMethodList

4.3 從父類中查找

4.4 方法解析

4.4.1 _class_resolveInstanceMethod

4.4.2 _class_resolveClassMethod

4.5 消息轉發

五、總結

一、`objc_msgSend` 彙編補充

1.1 `objc_msgSend` 流程