Runtime

c c++ 汇编一起写成的api，为OC提供运行时。

官方文档

与运行时相对应的是编译时：源代码翻译成机器可识别的语言（汇编），最后翻译成二进制代码。

代码运行起来时，运行时会把可执行文件装载到内存中。

运行时版本：

 Legacy and Modern Versions

Objective-C 2.0 开始就是Modern版本的运行时

 

 

 old 和 new是为了兼容两个版本，现在主要用Modern版本。

 

 

 

在Main函数里面添加代码。打开终端

 

生成 Main.cpp

 

 

打开main.cpp  9万多行代码，前面是为了提供运行环境。

 

 

 

任何方法的调用，都会编译局成objc_msgSend

 RuntimePerson *person = ((RuntimePerson *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("RuntimePerson"), sel_registerName("new"));

 OC对象的本质就是结构体，方法的本质是发送消息。

 

 

 

 

 消息的组成（2个参数）：

 

 

(id)objc_getClass("RuntimePerson") 消息接受者

sel_registerName("new") 方法编号

 

runtime三种调用方式：

runtime api

NSObject api isMemeber isClass

OC上层方法 @selector

这些对象，类，父类是如何发送消息的呢？

导入头文件

#import

((id (*)(id, SEL ))objc_msgSend)(person, NSSelectorFromString(@"run")); //向对象发送消息

 

person 消息接受者

SEL方法编号

 

 ((id (*)(id, SEL ))objc_msgSend)(objc_getClass("RuntimePerson"), NSSelectorFromString(@"walk")); //向类发送消息

 

struct objc_super mySuper;

        mySuper.receiver = student;

        mySuper.super_class = class_getSuperclass([student class]);

        ((id (*)(id, SEL ))objc_msgSendSuper)((__bridge id)(&mySuper), @selector(run)); //向父类发送对象消息

 

struct objc_super myClassSuper;

       myClassSuper.receiver = [student class];

       myClassSuper.super_class = class_getSuperclass(object_getClass([student class]));

       ((id (*)(id, SEL ))objc_msgSendSuper)((__bridge id)(&myClassSuper), @selector(walk));

       //向父类发送类消息（类方法）

 

 

 

注意objc_msgSendSuper传的是结构体指针，是对结构体指针发送的run方法需要注意，结构体指针源码如下：

 

/// Specifies the superclass of an instance. 

struct objc_super {

    /// Specifies an instance of a class.

    __unsafe_unretained _Nonnull id receiver;

 

    /// Specifies the particular superclass of the instance to message. 

#if !defined(__cplusplus)  &&  !__OBJC2__   

    /* For compatibility with old objc-runtime.h header */

    __unsafe_unretained _Nonnull Class class; //如果不是objc2

#else

    __unsafe_unretained _Nonnull Class super_class; //如果是objc2

#endif

    /* super_class is the first class to search */

};

#endif

 

//对象方法存在哪里

//类方法存在哪

//类方法存在原类里面，以什么姿态存在？以实例方法是形式存在原类里面。

 

objc_msgSend  发送消息很快 快速（用汇编在缓存中查找）和慢速（通过C配合C++和汇编一起查找方法）两种方式

 

 

 

cache 存储SEL和IMP

方法查找的时候首先查找cache（哈希表），如果有直接返回。如果没有就通过c语言缓慢查找，如果找到了又会存到cache，方便下次快速查找。如果c语言也没找到，就会经过另外一个复杂的过程。

objc_msgSend为什么要用汇编写？

原因有两个：

1. c语言不可能通过写一个函数，保留未知的参数，跳转到任意的指针。（通过SEL，id，对象传进来，这些都是未知的，只有通过运行时才知道，c语言是无法实现的）

2. 速度快，oc要先转换成c或者c++而 c c++还需要编译，使用汇编可以直接操作寄存器，所以速度会更快。

源码查找汇编代码：

 

_objc_msgSend

选择arm64架构

 

 

 

 

 

 

找到objc_msgSend汇编入口  ENTRY _objc_msgSend

分析源码：

UNWIND _objc_msgSend, NoFrame 窗口为0

 

 

 

tagged pointer是特殊的数据类型，比较小的数据类型例如NSDate类型，没有必要用64位数据去存储，所以使用tagged pointer去存储。

 

b.le LNilOrTagged 跳转到LNilOrTagged

 

 

 

b.eq LReturnZero 如果对象是nil，不需要发送消息，直接返回。

 

从b.ne LGetIsaDone可以看出对isa做了相关处理。

 

 

结束消息发送

 

isa处理完毕后，会调用CacheLookup，NORMAl（缓存中找imp）normal为传的值 后面会出现两种情况直接调用imp或者调用 objc_msgSend_uncached(缓存中没有这个方法)

下面看下CacheLookup:

 

 

 有三种形式NORMAL, GETIMP, LOOKUP

.macro CacheLookup宏定义

 

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.

第三种情况：找到了，add imp到cache里面  

 

.macro CacheHit 宏定义

.if $0 == NORMAL

TailCallCachedImp x17, x12 // authenticate and call imp

如果为normal直接调用imp

 

 

.macro CheckMiss宏定义

如果找不到，并且传了NORMAL __objc_msgSend_uncached 会被调用

 

 

 

UNWIND __objc_msgSend_uncached, FrameWithNoSaves window没必要处理

 

MethodTableLookup 方法列表查找（核心方法）直接操作内存和寄存机非常快 比c快0.5倍到0.8倍

 

bl __class_lookupMethodAndLoadCache3 bl跳转__class_lookupMethodAndLoadCache3，在寻找这个方法的时候会发现找不到容易失去信心。

其实这里是跳转的c语言，需要去掉一个_ 搜索 _class_lookupMethodAndLoadCache3

 

 

name 方法名 imp 方法哈希表 name和imp是键值对

 

 

 这里的YES，NO，YES啥意思，initialize代表已经编译过了，在cache里面没有所以是NO，resolver是yes代表是否实现了这个类

 

下面是 c和c++查找方法的过程 lookUpImpOrForward方法源码：

/***********************************************************************

* lookUpImpOrForward.

* The standard IMP lookup. 

* initialize==NO tries to avoid +initialize (but sometimes fails)

* cache==NO skips optimistic unlocked lookup (but uses cache elsewhere)

* Most callers should use initialize==YES and cache==YES.

* inst is an instance of cls or a subclass thereof, or nil if none is known. 

*   If cls is an un-initialized metaclass then a non-nil inst is faster.

* May return _objc_msgForward_impcache. IMPs destined for external use 

*   must be converted to _objc_msgForward or _objc_msgForward_stret.

*   If you don't want forwarding at all, use lookUpImpOrNil() instead.

**********************************************************************/

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) { // 可能有缓存 -- NO

        imp = cache_getImp(cls, sel);

        if (imp) return imp;

    }

 

    // runtimeLock is held during isRealized and isInitialized checking

    // to prevent races against concurrent realization.

 

    // runtimeLock is held during method search to make

    // method-lookup + cache-fill atomic with respect to method addition.

    // Otherwise, a category could be added but ignored indefinitely because

    // the cache was re-filled with the old value after the cache flush on

    // behalf of the category.

 

    runtimeLock.lock();

    checkIsKnownClass(cls); 判断是否已经声明，或是是一个已知的类，如果是未知的类会报出相应的错误信息

 

    //

    if (!cls->isRealized()) { //如果是已知的类，判断是否已经实现了类，如果没有实现就去实现，给相关的内部DATA赋值

        // DATA

        realizeClass(cls);

    }

 

    if (initialize  &&  !cls->isInitialized()) { //如果需要初始化，并且没有有初始化则进行类初始化。

        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 ? 为什么这样设计？

    // 1. 并发，多线程，资源抢夺，已经更新了cahce

    // remap(cls)这个方法在加载类的手会重映射，可能就有了方法实现，所以要在这里重新cache_getImp

    imp = cache_getImp(cls, sel);

    if (imp) goto done;

 

    // Try this class's method lists. 

    { //首先在自己本类查找是否有相关方法sel

        Method meth = getMethodNoSuper_nolock(cls, sel); //后面有这个方法的分析

        if (meth) {

            log_and_fill_cache(cls, meth->imp, sel, inst, cls); 找到之后直接缓存赋值，下次直接总cache里面汇编查找（CacheHit）。

            imp = meth->imp;

            goto done;

        }

    }

 　　如果从本类里面没有查找到相关方法，那么就查找父类里面是否有相关实现

    // Try superclass caches and method lists.

    {

        unsigned attempts = unreasonableClassCount();

        for (Class curClass = cls->superclass;

             curClass != nil;

             curClass = curClass->superclass) 直到curClass为nil，因为NSObject的superClass 为nil，所以最终直到NSObject

        {

            // 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); 从父类cache里面查找imp

            if (imp) { 如果找到了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;

            }

        }

    }

 

    // No implementation found. Try method resolver once. 如果没有找到imp实现，就会尝试动态方法解析执行一次

    // 类方法的查找 -- 汇编

    // 找父类方法 没有

    // 动态方法解析

    // 类的类方法 = 元类实例方法  -(void)run{} -- NSObject

    // +(void)run{}

    

    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.

 

    imp = (IMP)_objc_msgForward_impcache;

    cache_fill(cls, sel, imp, inst);

 

 done:

    runtimeLock.unlock();

 

    return imp;

}

 

首先判断了cahce是否有缓存，如果传了YES会走这个汇编方法，快速查找方法

 

 

 

查找本类里里面的sel方法：

static method_t *

getMethodNoSuper_nolock(Class cls, SEL sel)

{

    runtimeLock.assertLocked();

 

    assert(cls->isRealized());

    // fixme nil cls? 

    // fixme nil sel?

 

　　//从begin到end遍历查找method，找到返回，没有找到返回nil

    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;

}

 

总结：思维导图

 

 

 

如果汇编和c c++都没有找到方法，那么会走方法动态解析的流程：

/***********************************************************************

* _class_resolveMethod

* Call +resolveClassMethod or +resolveInstanceMethod. 如果方法没有实现就会调用resolveClassMethod(类方法动态解析)，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]

        // LGPERSON(类方法) - 元类(实例) - 根元类(实例) -- NSObject (实例方法)

        _class_resolveClassMethod(cls, sel, inst);

        if (!lookUpImpOrNil(cls, sel, inst, 

                            NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 

        {

            _class_resolveInstanceMethod(cls, sel, inst);

        }

    }

}

 

 

经过尝试，有效，这里出现了一个新的问题就是动态方法解析调用了两次

 

 

 

 

 

 

 第一次发送是在_class_resolveMethod 方法里面通过下面的代码发送第一次消息：

 BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;

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

 

 第二次 从下面的截图可以发现是在forwarding消息转发的时候又调用了一次resolveClassMethod 所以一共调用两次动态解析方法

消息转发流程：在”消息无法处理“的时候又会调用一次resolveINstanceMethod

 

 下面在动态解析方法里面处理添加先未实现的方法：

 

#import "RuntimePerson.h"

 

@implementation RuntimePerson

 

//-(void)run{

//    NSLog(@"%s", __func__);

//    NSLog(@"RuntimePerson -- %s", __func__);

//}

 

//+(void)walk{

//     NSLog(@"RuntimePerson -- %s", __func__);

//}

 

-(void)readBook {

    NSLog(@"读书");

}

 

+(void)helloword {

    NSLog(@"helloword");

}

 

#pragma mark - 动态方法解析

 

+ (BOOL)resolveInstanceMethod:(SEL)sel{

    if(sel == @selector(run)) {

        NSLog(@"对象方法解析走这里");

        SEL readSEL = @selector(readBook);

        Method readM = class_getInstanceMethod(self, readSEL);

        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{

//    NSLog(@"来了 老弟 %s", __func__);

    

    if(sel == @selector(walk)) {

        NSLog(@"类方法解析走这里");

        SEL hellowordSEL = @selector(helloword);

        //类方法就存在我们的原类的方法列表

        Method hellowordM1 = class_getClassMethod(self, hellowordSEL);

        Method hellowordM = class_getInstanceMethod(object_getClass(self), hellowordSEL);

        IMP hellowordImp = method_getImplementation(hellowordM);

        const char *type = method_getTypeEncoding(hellowordM);

        NSLog(@"%s", type);

        return class_addMethod(object_getClass(self), sel, hellowordImp, type);

    }

    return  [super resolveClassMethod:sel];

}

@end

这里发现一个问题，类的类方法和元类的对象方法指针地址是相同的，所以是同一个东西。

 

 

总结：在

 

 这里有个问题就是为什么会再次调用_class_resolveInstanceMethod

 

 

 

 

 

 

 

 

 如果动态方法决议没有成功后面会继续走下层处理(消息转发)：

 

 

 

////对象方法转发

- (id)forwardingTargetForSelector:(SEL)aSelector{

    NSLog(@"%s",__func__);

    if (aSelector == @selector(run)) {

        // 转发给我们的LGStudent 对象

        return [RuntimeDog new];

    }

    return [super forwardingTargetForSelector:aSelector];

}

 

//类方法转发流程  如果这里返回YES，就不会走后面两个方法了

+ (id)forwardingTargetForSelector:(SEL)aSelector {  在这里可以做一系列自定义处理和crash收集，还可以防止奔溃

    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__);

    

 

　　可以在这里打印系统调用堆栈，收集起来，发送给服务器，bugly 友盟等第三方的做法

 

　　另外切面编程（aspect）也会用到这里的消息转发

 

　　或者是数组字典的一些边界和非空校验也可能会用到消息转发

 

　　//转发给person的readBook方法

    NSString *sto = @"奔跑少年";

    anInvocation.target = [RuntimePerson class];

//    [anInvocation setArgument:&sto atIndex:2];

    NSLog(@"%@",anInvocation.methodSignature);

    anInvocation.selector = @selector(readBook); 

    [anInvocation invoke];

    

}

调用顺序

forwardingTargetForSelector -> methodSignatureForSelector(方法签名) -> forwardInvocation(消息转发)

 

下面探索下源码：

 　　imp = (IMP)_objc_msgForward_impcache;

    cache_fill(cls, sel, imp, inst);

 _objc_msgForward_impcache这部分是汇编，需要前面加个_搜索

 

跳转到 __objc_msgForward

 

 

__objc_forward_handler 回调信息，这里就是我们平时方法没有实现报错信息的打印。

 

 

 

 

 

 

 

beq __objc_msgForward 跳转到了__objc_msgForward 方法

 

动态方法解析只有汇编调用，没有源码实现 （是闭源的）

这里使用系统提供的一个函数instrumentObjcMessageSends（一般在系统内部使用） 可以打印所有的调用信息，保存到一个文件中/private/tmp在这个路径下面 

 

在mac APP项目中可以生成，但是在iOS app工程中无法生成（具体原因还不清楚）