iOS 底层探索篇 —— 方法的查找流程

时间 2020-01-06

标签 ios 底层探索方法查找流程栏目 iOS 繁體版

原文原文链接

前言c++

iOS 底层探索篇 —— alloc、init、new的探索

iOS 底层探索篇 —— 内存字节对齐分析

iOS 底层探索篇 —— 对象的本质

iOS 底层探索篇 —— isa的初始化&指向分析

iOS 底层探索篇 —— 类的结构分析

iOS 底层探索篇 —— cache_t分析

消息发送的本质

1. 咱们在`main.m`文件里面定义一个`sayHello`方法

int main(int argc, const char * argv[]) {
        @autoreleasepool {
        XDPerson *person = [XDPerson alloc];
        [person sayHello];
      }
      return 0;
}
复制代码

2. `clang`这个`main.m`文件以后，咱们能够在相应的`main.cpp`文件里面能够看到

int main(int argc, const char * argv[]) {
        /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
          XDPerson *person = ((XDPerson *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("XDPerson"), sel_registerName("alloc"));

          ((void (*)(id, SEL))(void *)objc_msgSend)((id)person, sel_registerName("sayHello"));
        }
        return 0;
}
复制代码

3. 咱们把第2步的`main`函数里面的`sayHello`函数抽出来而后精简一下

objc_msgSend(person,sel_registerName("sayHello"));算法

结论：缓存

消息发送的本质就是调用objc_msgSend函数;
objc_msgSend函数的参数，对象(或者是类对象) + 方法名。

`objc_msgSend`的查找流程

objc_msgSend查找流程由如下两部分组成：bash

快速查找流程;
慢速查找流程;

快速查找流程

1. 查找主线流程

汇编断点查看,能够看到在汇编底层在call objc_msgSend。

XDTest`main:
    0x100000d40 <+0>:   pushq  %rbp
    ...省略部分信息...
    0x100000d8b <+75>:  callq  *0x27f(%rip)   ; (void *)0x0000000100343bc0: objc_msgSend
    ...省略部分信息...
    0x100000db0 <+112>: popq   %rbp
    0x100000db1 <+113>: retq  
复制代码

全局搜索能够再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:
    CacheLookup NORMAL
复制代码

主线流程介绍：多线程

cmp p0, #0检查是否为空，或者是否taggedPointer。SUPPORT_TAGGED_POINTERS在__LP64__宏定义的值为1。 b.le LNilOrTagged实质上就是去check，可是咱们知道确定不会为Nill，而且是nontaggedpointer（后面会介绍）。
ldr p13, [x0]把x0就是isa给到p13。
GetClassFromIsa_p16 p13 顾名思义就是经过p13找到class。
LGetIsaDone完成了以后就开始CacheLookup，传入的参数是NORMAl。

2. 主线流程深刻

GetClassFromIsa_p16 p13探索

.macro GetClassFromIsa_p16 /* src */
#if SUPPORT_INDEXED_ISA
    ...省略部分信息...
#elif __LP64__
    // 64-bit packed isa
    and p16, $0, #ISA_MASK
#else
    ...省略部分信息...
#endif
.endmacro
复制代码

SUPPORT_INDEXED_ISA查找宏定义就能够知道值为0。
and p16, $0, #ISA_MASK实际的入口就是这里。意思就是将第一个参数（即上面传入的isa）&ISA_MASK 以后赋值给p16，这就很明显的取到了咱们的目标类（元类）了。

LGetIsaDone取isa咱们已经完成，开始CacheLookup入参NORMAL

.macro CacheLookup        
    // p1 = SEL, p16 = isa
    ldp p10, p11, [x16, #CACHE] // p10 = buckets, p11 = occupied|mask
#if !__LP64__
    and w11, w11, 0xffff    // p11 = mask
#endif
    and w12, w1, w11        // x12 = _cmd & mask
    add p12, p10, p12, LSL #(1+PTRSHIFT)
                     // p12 = buckets + ((_cmd & mask) << (1+PTRSHIFT))

    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

3:  // wrap: p12 = first bucket, w11 = mask              
    add p12, p12, w11, UXTW #(1+PTRSHIFT)
                                // p12 = buckets + (mask << 1+PTRSHIFT)

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

3:  // double wrap
    JumpMiss $0
    
.endmacro
复制代码

看到这里咱们头皮发麻，不要慌，咱们开始对第2阶段一步一步分析。函数

2.1 ldp p10, p11, [x16, #CACHE]，咱们经过平移指针的地址16个字节以后能够找到objc_class结构体里面的cache_t指针。这里能够经过iOS 底层探索篇 —— isa的初始化&指向分析分析这个章节看到结构体的相关信息与介绍。oop

#CACHE是一个宏定义且值为8，而后一分为两个内存段。post

0000 1222 就给p10实际上就是buckets指针赋值。

0023 0033 就给p11实际上就是occupied|mask赋值。mask属性在结构体里面是在occupied属性的前面，可是赋值在后面的缘由是由于iOS是小端模式

2.2 经过hash函数、平移、取值一列操做,找打当前sel对应hash表里面的imp。ui

and w12, w1, w11        // x12 = _cmd & mask
    add p12, p10, p12, LSL #(1+PTRSHIFT)
                     // p12 = buckets + ((_cmd & mask) << (1+PTRSHIFT))
    ldp p17, p9, [x12]      // {imp, sel} = *bucket
复制代码

2.3 接下来的流程就和cache_t里面的查找流程相同，找不到就开始递归查找，直到找到为止。上面咱们能够看到会有两次123这样的流程，第二次123就是防止多线程调用的时候给的一次容错机会。this

2.4 咱们主要看cacheHit cacheMiss JumpMiss

cacheHit 缓存命中，表示找到了sel对应的imp，直接返回imp。

cacheMiss当前对应的bucket没找到，继续递归查找。

JumpMiss递归查找介绍，没有缓存命中，跳出当前流程。

2.5 JumpMiss 流程参数$0就是NORMAL

.macro JumpMiss
.if $0 == GETIMP
    b   LGetImpMiss
.elseif $0 == NORMAL
    b   __objc_msgSend_uncached
.elseif $0 == LOOKUP
    b   __objc_msgLookup_uncached
.else
.abort oops
.endif
.endmacro
复制代码

咱们看直接进入__objc_msgSend_uncached

2.6 __objc_msgSend_uncached探索

STATIC_ENTRY __objc_msgSend_uncached      
    UNWIND __objc_msgSend_uncached, FrameWithNoSaves

    MethodTableLookup       
    TailCallFunctionPointer x17

    END_ENTRY __objc_msgSend_uncached
复制代码

MethodTableLookup查找

2.7 MethodTableLookup探索

.macro MethodTableLookup
    
    // push frame
    ...省略部分信息...

    // save parameter registers: x0..x8, q0..q7
    ...省略部分信息...

    // receiver and selector already in x0 and x1
    mov x2, x16
    bl  __class_lookupMethodAndLoadCache3  

    // IMP in x0
    mov x17, x0
    
    // restore registers and return
    ...省略部分信息...
    AuthenticateLR

.endmacro
复制代码

一顿疯狂的汇编操做，最后的流程就是到了__class_lookupMethodAndLoadCache3这个函数里面，这个时候咱们就继续搜索这么一个函数，会发现搜索不到它了。

其实到这里为止，汇编的快速查找流程已经结束了。下面附上快速查找主线流程图。

慢速查找流程

1. 查找主线流程

函数的入口定位

在上面快速查找流程中，没有缓存命名就会走__class_lookupMethodAndLoadCache3这个函数里面，那么它对应在慢速查找流程中的哪一个函数呢，下面咱们经过汇编调试

libobjc.A.dylib`_objc_msgSend_uncached:
    0x100344610 <+0>:   pushq  %rbp
    ...省略部分信息...
->  0x10034464f <+63>:  callq  0x100344ad0   ; ::_class_lookupMethodAndLoadCache3(id, SEL, Class) at objc-runtime-new.mm:5246
...省略部分信息...
复制代码

经过调试咱们看到了c++函数_class_lookupMethodAndLoadCache3

加下来咱们开始探索_class_lookupMethodAndLoadCache3

查看objc源码

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

看lookUpImpOrForward，这是什么意思？查找imp或者forward转发

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 = cache_getImp(cls, sel);
        if (imp) return imp;
    }

    runtimeLock.lock();
    checkIsKnownClass(cls);

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

    if (initialize  &&  !cls->isInitialized()) {
        runtimeLock.unlock();
        _class_initialize (_class_getNonMetaClass(cls, inst));
        runtimeLock.lock();
    }

 retry:    
    runtimeLock.assertLocked();

    imp = cache_getImp(cls, sel);
    if (imp) goto done;

    // Try this class is 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;
        }
    }

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

    // No implementation found. Try method resolver once.

    if (resolver  &&  !triedResolver) {
        runtimeLock.unlock();
        _class_resolveMethod(cls, sel, inst);
        runtimeLock.lock();
        triedResolver = YES;
        goto retry;
    }

    // No implementation found, and method resolver did not help. 
    // Use forwarding.

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

 done:
    runtimeLock.unlock();

    return imp;
}
复制代码

这一步就是咱们消息慢速查找的流程，接下来对第2步咱们逐步分析。

2. 主线流程深刻

先看是否有缓存，有就直接返回

if (cache) {
        imp = cache_getImp(cls, sel);
        if (imp) return imp;
    }
复制代码

runtimeLock.lock()分析这里加锁的缘由

防止查找方法A的时候，查找方法B进来，致使返回imp错误。

检查和准备类

checkIsKnownClass(cls);

    if (!cls->isRealized()) {
        realizeClass(cls);
    }
复制代码

checkIsKnownClass(cls)检查类是否在内存中存在

realizeClass(cls)准备该类的方法，并准备到class_rw_t这个结构体里面，这里就不贴相应的代码了，能够本身去查看。

准备就绪，开始从类里面去查找方法

{
        Method meth = getMethodNoSuper_nolock(cls, sel);
        if (meth) {
            log_and_fill_cache(cls, meth->imp, sel, inst, cls);
            imp = meth->imp;
            goto done;
        }
}
复制代码

{}这里括号表明局部做用域；

从当前类里面找，找到以后cache起来；

getMethodNoSuper_nolock ，log_and_fill_cache会在下面介绍。

本身方法里面没有找到就开始从父类里面去查找了。

// Try superclass caches and method lists.
{
  ...省略部分信息...
}
复制代码

代码部分省略，和第4步的流程相同，这里咱们要熟记isa的指向分析与类的继承关系，会很好的帮助到咱们的理解，在iOS 底层探索篇 —— isa的初始化&指向分析这篇文章里面已经作了介绍。

到这里为止慢速查找的流程已经结束了。如今咱们对第4步中两个重要的函数分析。

getMethodNoSuper_nolock 两个入参cls sel

static method_t *
getMethodNoSuper_nolock(Class cls, SEL 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;
}
复制代码

对class_rw_t结构体的methods开始遍历

分析search_method_list

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

    return nil;
}
复制代码

这里分了两步

findMethodInSortedMethodList有序查找,有序查找对应的算法是二分法，一样也是根据name来判断。

else里面是针对无序的结构，直接遍历查找，name相同直接返回。

log_and_fill_cache分析

static void
log_and_fill_cache(Class cls, IMP imp, SEL sel, id receiver, Class implementer)
{
#if SUPPORT_MESSAGE_LOGGING
    if (objcMsgLogEnabled) {
        bool cacheIt = logMessageSend(implementer->isMetaClass(), 
                                      cls->nameForLogging(),
                                      implementer->nameForLogging(), 
                                      sel);
        if (!cacheIt) return;
    }
#endif
    cache_fill (cls, sel, imp, receiver);
}
复制代码

SUPPORT_MESSAGE_LOGGING宏定义在咱们iOS的状况下为存在的，只是objcMsgLogEnabled这个条件默认为false，日志打印就不会开启。走向cache_fill，这里就与iOS 底层探索篇 —— cache_t分析这篇文章的分析衔接上来了。

到这里咱们的慢速查找流程结束了，下面附上慢速查找主线流程图。

接下来就要开始forward消息转发的流程，将在下一篇文章中继续探索。

iOS 底层探索篇 —— 方法的查找流程

消息发送的本质

1. 咱们在main.m文件里面定义一个sayHello方法

2. clang这个main.m文件以后，咱们能够在相应的main.cpp文件里面能够看到

3. 咱们把第2步的main函数里面的sayHello函数抽出来而后精简一下

objc_msgSend的查找流程

快速查找流程

1. 查找主线流程

2. 主线流程深刻

慢速查找流程

1. 查找主线流程

2. 主线流程深刻

1. 咱们在`main.m`文件里面定义一个`sayHello`方法

2. `clang`这个`main.m`文件以后，咱们能够在相应的`main.cpp`文件里面能够看到

3. 咱们把第2步的`main`函数里面的`sayHello`函数抽出来而后精简一下

`objc_msgSend`的查找流程