Runtime底层原理--IMP查找流程、动态方法解析、消息转发源码分析

Runtime
底层原理 源码分析
发布日期:   2019-04-10
阅读时长:   9 分

Runtime底层原理

了解了Runtime函数含义，我们就可以直接使用Runtime的API了，那接下来继续探究Runtime的源码，经过源码分析来更加深刻的了解Runtime原理。

开发应用

都知道Runtime很重要，但是有很多小伙伴根本不了解，或者只是知道可以替换方法啊、可以交换两个方法的调用，项目中也用不到，
从进入iOS开始，写了无数个[[objc alloc] init]，这个到底在干嘛？初始化和init？alloc和init到底做了什么？

通过汇编查看方法调用
Person *person = [Person alloc];
Person *person1 = [person init];
Person *person2 = [person init];
NSLog(@"%p-----%p------%p", person, person1, person2);

这里会输出什么呢？

0x10102e1a0-----0x10102e1a0------0x10102e1a0

来，让我们断点看下，alloc和init是怎么调用的

objc_msgSend

我们看到调用alloc和init都调起了objc_msgSend，接下来跟着符号断点走

libobjc

callAlloc

进入libobjc库的dylib之后走+[NSObject alloc]方法，指针调起_objc_rootAlloc，进入_objc_rootAlloc方法，继续调起callAlloc，通过寄存器，可以看到alloc已经通过类创建实例对象

类对象

init按照同样方法 依然可以通过汇编看出方法调用顺序，可以用真机进行测试并打印

通过编译C++

当新的对象被创建时，其内存同时被分配，实例变量也同时被初始化。对象的第一个实例变量是一个指向该对象的类结构的指针，叫做 isa。通过该指针，对象可以访问它对应的类以及相应的父类。在 Objective-C 运行时系统中对象需要有 isa 指针，我们一般创建的从 NSObject 或者 NSProxy 继承的对象都自动包括 isa 变量。接下来看下对象被创建的过程
首先，我们通过clang命令

$ xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o testMain.c++

也可以用clang -rewrite-objc main.m -o test.c++命令，只不过会有很多警告、代码会更长（大概9万多行）。
编译main函数中的OC代码为C++代码
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        Person *p = [[Person alloc] init];
        [p run];
  
    }
    return 0;
}

编译后多一个testMain.c++文件，打开后在代码最后面会发现我们的main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        Person *p = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));
        ((void (*)(id, SEL))(void *)objc_msgSend)((id)p, sel_registerName("run"));

    }
    return 0;
}

可以看出，我们的方法调用会编译成objc_msgSend，

person对象

由此还会发现对象的本质其实就是一个结构体

下层通讯(通过源码查看objc_msgSend内部实现)

首先我们到苹果open source官网下载最新源码
源码

在方法调用的时候，会发送objc_msgSend消息，objc_msgSend会根据sel找到函数实现的指针imp，进而执行函数，那sel是如何找到imp的呢？
objc_msgSend在发送消息时候根据sel查找imp有两种方式

  • 快速（通过汇编的缓存快速查找）
  • 慢速（C配合C++、汇编一起查找）
    先看下objc_class

objc_class

bits中包含各种数据，cache（每个类都有一个）用来存储方法select和imp，select和imp会以哈希表形式存在
objc_msgSend在快速查找的时候，就是通过汇编查找objc_class中的cache，如果找到则直接返回，否则通过C的lookup，找到后再存入cache

汇编部分快速查找

首先调用objc_msgSend会走到ENTRY

ENTRY

先判断p0检查是否为空和tagged pointer（特殊类型）判断，调用LNilOrTagged进行isa处理，通过isa找到相应类class，最后调用LGetIsaDone来执行CacheLookup在缓存中查找imp，如果查找到直接调起imp否则调起objc_msgSend_uncached，objc_msgSend_uncached有两种情况

CacheLookup

首先，第一个是CacheHit，直接调起imp，第二个是CheckMiss，之后调用objc_msgSend_uncached，第三个就是add，下面是CacheHit和CheckMiss的宏

CacheLookup macro

那如果在缓存中没有查找到imp，调起objc_msgSend_uncached，在方法列表中找到imp之后再TailCallFunctionPointer调起imp

   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      // 方法列表中找到imp
TailCallFunctionPointer x17

重点:MethodTableLookup是怎么操作的

小知识点：通过method list查找method，下面是method_t的结构，method其实是一个哈希表，sel和imp是键值对

struct method_t {
    SEL name;
    const char *types;       // 参数类型
    MethodListIMP imp;
    struct SortBySELAddress :
        public std::binary_function<const method_t&,
                                    const method_t&, bool>
    {
        bool operator() (const method_t& lhs,
                         const method_t& rhs)
        { return lhs.name < rhs.name; }
    };
};

进入MethodTableLookup之后，调起了__class_lookupMethodAndLoadCache3，如下图

MethodTableLookup

__class_lookupMethodAndLoadCache3是C方法，再次进入_class_lookupMethodAndLoadCache3方法，注意，因为这里由汇编跳转到C，所以要全局搜索_class_lookupMethodAndLoadCache3，要删去一个"_",下面是_class_lookupMethodAndLoadCache3函数

/***********************************************************************
* _class_lookupMethodAndLoadCache.
* Method lookup for dispatchers ONLY. OTHER CODE SHOULD USE lookUpImp().
* This lookup avoids optimistic cache scan because the dispatcher 
* already tried that.
**********************************************************************/
IMP _class_lookupMethodAndLoadCache3(id obj, SEL sel, Class cls)
{
    return lookUpImpOrForward(cls, sel, obj, 
                              YES/*initialize*/, NO/*cache*/, YES/*resolver*/);
}
C/C++部分查找

调起lookUpImpOrForward，因为当前cls对象已经经过汇编编译到结构，有了isa，并且在cache中没有找到，所以这里的initialize为YES，cache为NO，resolver为YES

image.png

进入lookUpImpOrForward，这里再次判断是否存在cache，如果有则直接快速查找，但是这里是NO，所以不会走。接下来走checkIsKnownClass判断是否是已经声明的类，如果没有则报错”Attempt to use unknown class %p.”，之后走realizeClass判断是否已经实现，如果就相应赋值data。

realizeClass

data赋值后走_class_initialize初始化cls，接下来开始retry操作。
前方高能
再次进行cache_getImp，why？并发啊，还有重映射（在初始化init的时候有个remap（class）第一次通过汇编找不到，但是在加载类的时候对当前类进行重映射）
cache_getImp

接下来开始先在自己的class_rw_t的methods中根据sel查找方法返回method_t

method_t

如果拿到Method后保存到缓存中，保证以后调用可以直接走汇编的CacheHit快速查找，如果拿不到则继续从父类开始查找，直到找到NSObject(因为NSObject的父类为nil)，如果找到imp则一样保存在缓存中，如果到最后还是没有查找到，则进入动态方法解析。
父类查找方法

动态方法解析

如果前面一系列操作还是没有找到方法，那么就会进行动态方法解析，动态方法解析只执行一次

动态方法解析

首先执行_class_resolveMethod，这里会执行+resolveClassMethod 或者 +resolveInstanceMethod。
class resolveMethod

先判断当前cls是否为元类，如果是元类则执行_class_resolveClassMethod，再执行_class_resolveInstanceMethod，如果不是元类则直接执行_class_resolveInstanceMethod，_class_resolveInstanceMethod内部调用objc_msgSend实现消息发送，对cls发送了SEL_resolveInstanceMethod类型的消息，所以在方法中会走到resolveInstanceMethod方法。

class resolveInstanceMethod

为什么元类最后也执行了_class_resolveInstanceMethod方法呢？因为类方法以实例对象的形态存在元类里面，比如类方法中没有找到方法，会去元类中查找，元类中没有再继续去根元类中查找，最后会查到NSObject。

代码示例：

.h实现

- (void)run;
+ (void)eat;

.m实现(没有实现-run方法和+eat方法)
- (void)walk {
    NSLog(@"%s",__func__);
}
+ (void)drink {
    NSLog(@"%s",__func__);
}

// .m没有实现,并且父类也没有,那么我们就开启动态方法解析
//- (void)walk{
//    NSLog(@"%s",__func__);
//}
//+ (void)drink{
//    NSLog(@"%s",__func__);
//}


#pragma mark - 动态方法解析

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    if (sel == @selector(run)) {
        // 我们动态解析我们的 对象方法
        NSLog(@"对象方法解析走这里");
        SEL walkSEL = @selector(walk);
        Method readM= class_getInstanceMethod(self, walkSEL);
        IMP readImp = method_getImplementation(readM);
        const char *type = method_getTypeEncoding(readM);
        return class_addMethod(self, sel, readImp, type);
    }
    return [super resolveInstanceMethod:sel];
}


+ (BOOL)resolveClassMethod:(SEL)sel{
    if (sel == @selector(eat)) {
        // 我们动态解析我们的 对象方法
        NSLog(@"类方法解析走这里");
        SEL drinkSEL = @selector(drink);
        // 类方法就存在我们的元类的方法列表
        // 类 类犯法
        // 元类 对象实例方法
        //        Method hellowordM1= class_getClassMethod(self, hellowordSEL);
        Method drinkM= class_getInstanceMethod(object_getClass(self), drinkSEL);
        IMP drinkImp = method_getImplementation(drinkM);
        const char *type = method_getTypeEncoding(drinkM);
        NSLog(@"%s",type);
        return class_addMethod(object_getClass(self), sel, drinkImp, type);
    }
    return [super resolveClassMethod:sel];
}

消息转发

经历了动态方法决议还没有找到，会进入苹果尚未开源的消息转发，继续查找方法，_objc_msgForward_impcache再次跨域到汇编。

消息转发

走到__objc_msgForward_impcache后执行__objc_msgForward

__objc_msgForward_impcache

没有了源码实现，但是我们可以通过instrumentObjcMessageSends函数来打印调用堆栈信息。可以进入instrumentObjcMessageSends内部看下具体实现。

instrumentObjcMessageSends

先判断了是否可以写入日志信息等，接下来同步日志文件

logMessageSend

所以我们每次运行会在/private/tmp文件下多一个msgSends-xxx文件，里面是所有调用过程

堆栈调用信息

如果还没有找到的话最后会报错调用__objc_forward_handler

__objc_forward_handler

这也是我们在方法报错的时候会报unrecognized selector sent to instance %p " "(no message forward handler is installed)"错误的原因，会提示出元类信息，+或者-方法，方法的名字还有SEL方法编号

代码示例：
#pragma mark - 实例对象消息转发

- (id)forwardingTargetForSelector:(SEL)aSelector{
    NSLog(@"%s",__func__);
    //    if (aSelector == @selector(run)) {
    //        // 转发给Student对象
    //        return [Student new];
    //    }
    return [super forwardingTargetForSelector:aSelector];
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    NSLog(@"%s",__func__);
    if (aSelector == @selector(run)) {
        // forwardingTargetForSelector 没有实现，就只能方法签名了
        return [NSMethodSignature signatureWithObjCTypes:"v@:@"];
    }
    return [super methodSignatureForSelector:aSelector];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    NSLog(@"%s",__func__);
    NSLog(@"------%@-----",anInvocation);
    anInvocation.selector = @selector(walk);
    [anInvocation invoke];
}

#pragma mark - 类消息转发

+ (id)forwardingTargetForSelector:(SEL)aSelector{
    NSLog(@"%s",__func__);
    return [super forwardingTargetForSelector:aSelector];
}
//

+ (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    NSLog(@"%s",__func__);
    if (aSelector == @selector(walk)) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:@"];
    }
    return [super methodSignatureForSelector:aSelector];
}

+ (void)forwardInvocation:(NSInvocation *)anInvocation{
    NSLog(@"%s",__func__);
    
    NSString *sto = @"奔跑吧";
    anInvocation.target = [Student class];
    [anInvocation setArgument:&sto atIndex:2];
    NSLog(@"%@",anInvocation.methodSignature);
    anInvocation.selector = @selector(run:);
    [anInvocation invoke];
}

现在我们应该也知道了为什么objc_msgSend的源码用的汇编，因为汇编可以通过寄存器x0-x31来保留未知参数来跳转到任意的指针，还有汇编更高效一点，而C满足不了。

言而总之，总而言之

Runtime就是C、C++、汇编实现的一套API，给OC增加的一个运行时功能，也就是我们平时所说的运行时。
在运行工程时工程会被装载到内存，来提供运行时功能。

该文章为记录本人的学习路程，希望能够帮助大家！！！

文章作者: Vincent
文章链接: https://jbwblog.com/2019/04/10/imp-yuan-ma-fen-xi/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 Vincent !
Runtime
赏
  目录