链接: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Introduction/Introduction.html#//apple_ref/doc/uid/TP40008048-CH1-SW1
Objective-C运行时的改进: https://developer.apple.com/videos/play/wwdc2020/10163/

简介

Objective-C一门动态语言, 它能在编译的时候转换为对应的C函数, 而消息的接受者 (reciever) 和接受者执行的方法 selector , 只有在函数运行时才能确定, 所以说它是一门运行时语言. 通过在消息发送之前对函数的两个参数 recever (具体的执行对象)和 selector (执行的方法)进行不同的处理, 就可以实现各种黑魔法效果, 常见的有方法实现体(IMP)替换, 消息转发(Forward message), 同时为了配合运行时的特性, 它为每个方法和类型定义一套编码规则, Objective-C的对象和类型可以转换为Rumtime中指定的类型或这是标志符号, 保证他们都能有一套映射标准。

版本和平台

Runtime一共有2个版本, Objective-C 1.0和Objective-C 2.0, 它们的一个主要的区别就是:
旧版本运行时中，如果更改类中实例变量的布局，则必须重新编译从该类继承的类。
新版本运行时中，如果更改类中实例变量的布局，则不必重新编译继承自该类的类。
支持平台包括 iOS , OS X , 而这些仅使用于苹果相关的应用

交互

• Objective-C程序在三个不同的层次与运行时系统交互：

通过Objective-C源代码；
通过在基础框架的NSObject类中定义的方法；
通过直接调用运行时函数。

• 通过编译器生成对应的源代码

在大多数情况下运行时胸在后台自动工作, 只需要编写和编译源代码就能使用它, 通常这些都是由Xcode来完成, 编译包含Objective-C类和方法的代码时，编译器将创建实现语言动态特性的数据结构和函数调用。数据结构捕获类和类别定义以及协议声明中的信息；它们包括在用Objective-C编程语言定义类和协议时讨论的类和协议对象，以及方法选择器、实例变量模板和从源代码中提取的其他信息。主运行时函数是发送消息的函数，如消息传递中所述。它由源代码消息表达式调用。

• 直接调用NSObject中相关的方法

在Cocoa中的绝大部分对象都是基于 NSObject 生成的子类, 因此大部分类都继承了它的基本方法(NSProxy是一个另外), 同时也提供依稀诶抽象的模版方法, 如 description , 则需要子类去实现. 因为每个类的具体内容不大一样, 主要是为了方便 GDB print object命令 , 默认情况下它只包括一个类名称和地址。部分的 NSObject 方法只是查询运行时的系统信息, 这些方法可以对类型进行安全性检查

isKindOfClass
isMemenberOfClass
respondsToSelecctor
cconformsToProtocol
methodForSelector

• 通过Runtime提供的函数调用

Swift工程中的api介绍
Source Code
提供了封装的函数调用,包括获取类的信息,添加类,获取实例对象的相关信息,获取类的定义,实例变量操作,对象关联,方法操作,库操作,方法选择器操作,协议操作,属性操作,还有 Objective-C 语言特有的功能,如bloc,weak操作。

发送消息

• 在Objective-C中的方法调用 [Object method] 编译之后它objc_msgSend(receiver, selector) 这样的,此外还有 objc_msgSend(receiver, selector, arg1, arg2, ...) 带参数发送.Object 作为 recevier , method 作为 selector 参数.

• 首先它会在 recevier(object)中查找 selector`(方法选择器)的函数实现体,然后找到之后根据换入的参数执行该方法,最后将函数的返回值作为自己的返回值

• 从上面的例子可以看出消息传递的关键在于 reciever 的类和它的结构,一个类主要包括2个关键的结构父类的指针,一个class的调度表,此表中的维持了一个方法选择器和它的实现函数关联的索引. selector-address.

• 它有一个默认隐藏参数: 在编译时, reciver 和 selector 会自动被捕获做为 objc_msgSend 的两个参数,在代码中可以通过提供的关键字 _cmd 代表当前代码执行的方法.里用这些特性可以实现对方法和对象的校验,下面的官方simple给出的一个例子,它用于校验当前的method是否为 strange .以及target是否为当前对象本省.

* strange {

    id  target = getTheReceiver();
    SEL method = getTheMethod();
 
    if ( target == self || method == _cmd )
        return nil;
    return [target performSelector:method];
}

• 获取方法的地址

规避动态绑定的唯一方法是获取方法的地址, 然后像调用函数一样去调用它, 当一个特定的方法被连续执行很多次的时候, 动态调用就会带来一定消息转发的开销, 会比较浪费性能, 我们可以通过获取函数地址直接调用, 这样和可以节省消息转发的开销

void (*setter)(id, SEL, BOOL); 
int i; 

setter = (void (*)(id, SEL, BOOL))[target

    methodForSelector:@selector(setFilled:)]; //methodForSelector由Runtime System提供,获取具体的方法地址,及函数指针

for ( i = 0 ; i < 1000 ; i++ ) {

    setter(targetList[i], @selector(setFilled:), YES); //通过直接执行函数,效率更高,减少循环带来的开销

}  

动态方法解析

• 在某些特殊的场合我们可能需要实现方法的动态调用,利于在某些类不包含某个方法的时候,我们需要将其转发给特定的类处理来做一些异常搜集工作. Objective-C Runtime 提供了动态属性的的申明指令( @dynamic dirctive)。它会在编译的时候告诉编译器需要动态的查找和解析该属性.此外还可以通过实现以下2个方法来动态解析对应的 selector .

@implementation MyClass

* (BOOL)resolveInstanceMethod:(SEL)aSEL //这里也可以是实例方法,当这个类没有对应 `selector` 实现的时候就会找到这个方法,通过拦截它就可以对该方法做一些默认的处理.

{
    if (aSEL == @selector(resolveThisMethodDynamically)) {
          //为该方法做一些默认的实现操作,将它的实现写在 `dynamicMethodIMP` 方法中
          class_addMethod([self class], aSEL, (IMP) dynamicMethodIMP, "v@:");
          return YES;
    }
    return [super resolveInstanceMethod:aSEL];
}

void dynamicMethodIMP(id self, SEL _cmd) {
    // implementation ....
}
@end

• 动态loading

Objective-C程序可以在运行时加载和链接新的类和类别。新代码被合并到程序中，并与开始时加载的类和类别相同。
在Cocoa环境中，通常使用动态加载来定制应用程序,其他人编译的程序在运行时加载的模块,就像 Interface Builder 加载自己定义的调色板和OSX新系统首选项应用程序加载自定义的首选模块以下.
尽管一个运行时函数可以在Mach-O文件中(objc_loadModules,在objc/objcload.h中定义)中执行 Objective-C 模块动态加载,但是 Cocoa 的NSBundle类为动态加载提供了一个非常方便的接口,该接口面向对象并与相关的服务集成,可以参考 NSBundle 的相关使用方法,通过NSBundle我们可以动态的加载 framework 而不必在启动时加载,可以大幅度的减少冷启动的时候,但也有它自己的弊端,很多的方法需要对 selector 进行减少以防程序崩溃,使用时需要根据具体的场景考量。

常用的方法如下:

* (NSArray *)allBundles
* (NSArray *)allFrameworks
* (NSBundle *)bundleForClass:(Class)aClass
* (BOOL)load //动态的加载bundle的可执行文件代码到引用程序中
* (NSString *)localizedStringForKey:(NSString *)key value:(NSString *)value table:(NSString *)tableName

消息转发

想不处理消息的对象发送错误的消息时是错误的。但是, 在宣布错误之前, 运行时系统会给接收对象第二次处理消息的机会。

• 转发消息

当发送一条消息给它不能处理的对象时, Runtime会将该消息内容进行包装, 然后调用对象的 forwardInvocation: 方法, 消息的参数是一个 NSInvocation 对象, 可以在当前对象中实现 forwardInvocation: 方法, 对这条不能处理的消息进行拦截和其他处理, 或者返回一个默认的信息, 在 NSObject 中有定义了 forwardInvocation: 方法的实现, 然鹅它只是简单的调用了 doesNotRecognizeSelector: 并会抛出一个错误, 继承于 NSObject 的子类通过重写 forwardInvocation: 这个方法可以对转发的消息进拦截。

* (void)forwardInvocation:(NSInvocation *)anInvocation

{

    if ([someOtherObject respondsToSelector:
            [anInvocation selector]])
        [anInvocation invokeWithTarget:someOtherObject];
    else
        [super forwardInvocation:anInvocation];

}

• 多重继承实现

利用消息转发这一特性,可以实现多重继承。当子类本身继承某个类之后它还想实现其它类的方法,那就可以通过 forwardInvocation: 来实现消息转发。可以利用 NSProxy 来封装一个通用类,将该类继承的其他对象的方法做一个封装

NS_ROOT_CLASS
@interface NSProxy <NSObject> {
    Class    isa;
}

* (id)alloc;
* (id)allocWithZone:(NSZone *)zone NS_AUTOMATED_REFCOUNT_UNAVAILABLE;
* (Class)class;

* (void)forwardInvocation:(NSInvocation *)invocation;
* (NSMethodSignature *)methodSignatureForSelector:(SEL)sel;
* (void)dealloc;
* (void)finalize;
* (NSString *)description;
* (NSString *)debugDescription;
* (BOOL)respondsToSelector:(SEL)aSelector;

* (BOOL)allowsWeakReference NS_UNAVAILABLE;
* (BOOL)retainWeakReference NS_UNAVAILABLE;

// - (id)forwardingTargetForSelector:(SEL)aSelector;

@end

* (void)forwardInvocation:(NSInvocation *)anInvocation

{
    [proxy forwardInvocation: anInvocation];
}

• 消息封装

在对象转发消息之前, 还需要实现这个方法, 因为 NSInvocation 需要依赖于 NSMethodSignature 来创建。它的类方法是 + invocationWithMethodSignature: , 自带一个 NSMethodSignature 参数。 NSMethodSignature 是对Objective-C的方法参数进行编码。

* (NSMethodSignature*)methodSignatureForSelector:(SEL)selector

{

    NSMethodSignature* signature = [super methodSignatureForSelector:selector];
    if (!signature) {
       signature = [surrogate methodSignatureForSelector:selector];
    }
    return signature;

}
//包装消息
...

    NSMethodSignature *signature = [[self class] instanceMethodSignatureForSelector:aSelector];  
    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
    invocation.target = self;  //参数一
    invocation.selector = aSelector; //参数二
    invocation setArgument:&argument atIndex:2 //参数三  
    ... //其它参数

...

类型编码

为了帮助运行时系统,编译器为每个方法的返回和参数类型进行了编码,并将编码后的字符串于方法选择器进行关联.通过关键字 @encode(type) 注解来实现,它的返回值是一个字符串,runtime定义了他们的每个编码类型如下列表所示,我们也可以通过在工程中使用 print(%s), @encode(type)) 来确认编码后的结果.

特殊类型: {examplestruct=@*i} , {NSObject=#} ,类型大都比较有规律,按照首字母和大写来区分。

Objective-C语言

Objective-C是一种独特的计算机语言,以其独特的方括号表达式让很多学习其他的语言的开发者都很难理解,但它的本质是为了提供复杂的面向对象编程,在早起的C语言中提供的对象只有结构体,和数组,使用操作起来不是很方便,它是对C语言的补充,并有一套自己特有的编译器clang,lvvm旨在打造高效率的面向对象编程语言.并以一种简单明了的方式实现,基本上所有的语法操作都是为绕这 sendMessage来展开的。
主要包括以下几个部分,在此链接中可以找到具体的定义和例子
Objects, Classes, and Messaging
Defining a Class
Protocols
Declared Properties
Categories and Extensions
Associative References
Fast Enumeration
Enabling Static Behavior
Selectors
Exception Handling
Threading

Objective-C编译

• Objective-C之所以被称为运行时语言,是因为它在编译时会翻译成对应的C函数,下面通过它的翻译构建过程来看看它的具体实现过程层.

• 在 ViewController.m 中随便写些代码,然后执行运行,找到 Xcode 的构建历史记录可以看到如下消息从上面的构建记录可以看出,它主要是通过 clang 来完成代码的编译组装成最终的可以执行文件 (.o) , clang在编译时指定了一系列的参数,runtime环境配置,语法检查,中间编译产物的记录。

• clang包含了很多的命令,下面也只是构建中的部分,具体可以参考 clang帮助文档,网上也有很多中文的解释,不过还是得结合具体的应用场景来理解。

...XcodeDefault.xctoolchain/usr/bin/clang  //编译器的执行文件路径
-x objective-c  // 指定编译文件的语言
-target x86_64-apple-ios12.0-simulator //指定需要生成code target,会根据这个arm指令生成查找对应的汇编
-fmessage-length=0 //只是为了控制控制台输出换行打印好看而已
-fdiagnostics-show-note-include-stack //诊断检查信息的提示包括对应的栈信息,提示用
-fmacro-backtrace-limit=0 //限定堆栈信息
-std=gnu11  //指定编译的语言版本
-fobjc-arc //开启Arc,buildSettings有指定,iOS5之后就支持了
-fmodules //Enable the 'modules' language feature,开启指定module的语言支持
-gmodules //Generate debug info with external references to clang modules or precompiled headers,生成clang modules或预编译头文件的debug信息 
...
-DDEBUG=1 //是否是debug环境
-DOBJC_OLD_DISPATCH_PROTOTYPES=0 
-isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator13.7.sdk  // Set the system root directory (usually /)
 .... 
-MMD -MT dependencies -MF /x86_64/ViewController.d  //将依赖输出到指定的 ViewController.d文件,记录的依赖文件的路径
--serialize-diagnostics /x86_64/ViewController.dia //诊断文件
-c  ../ViewController.m  //预处理编译组装,不会自动执行run
-o  ../x86_64/ViewController.o //输出最终的编译产物文件

• 通过Xcode工程文件clang执行的是 -c 命令, 直接输出了目标文件, 要想查看生成的中间文件则需要通过 -rewrite-objc 命令查看, 结合上面的构建步骤挑选出几个必选的命令

clang -rewrite-objc -fobjc-arc -fobjc-runtime=ios-12.0.0 -isysroot /Applications/Xcode-beta.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk ViewController.m , 实际这个文件一般不会产生, 不过它可以更好的帮助我们理解runtime的实现过程, 探究Runtime底层实现必不可少的工具, 下面是翻译之后的 Objective-C (简称OC)代码, 它编程了C++的文件, 二原来用 [] 和 Objective-C 写的那部分代码全部编程了C函数。

...
//用于定义类和类对象的结构
struct __rw_objc_super { 

    struct objc_object *object; 
    struct objc_object *superClass; 
    __rw_objc_super(struct objc_object *o, struct objc_object *s) : object(o), superClass(s) {} 

}; 

// ViewController: controller对象本身
// _cmd代表当前viewController需要执行的方法

static void _I_ViewController_viewDidLoad(ViewController * self, SEL _cmd) {

    
    //这个函数执行分为以下几个步骤
    //1. 创建了 `__rw_objc_super` 的结构体对象,参数1: viewController实例self，ViewController class
    //2. 并向 ViewController中注册了一个 `viewDidLoad` 方法
    //3. 返回了2个参数: self对应的 `__rw_objc_super` 结构体 和 `viewDidLoad` 的 `SEL`
    //4. __rw_objc_super查找viewDidLoad具体实现并执行
    ((void (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)  ((__rw_objc_super) {
       (id)self, (id)class_getSuperclass(objc_getClass("ViewController")) 
    }, sel_registerName("viewDidLoad"));

}
...

objc4-750初探

• NSObject: 它是绝大部分的Objective-C的基类,封装了runtime最基本的实现,暴露了runtime最常用的接口,类和对象的安全检查以及消息转发,它包含了一个isa指针.所以对于任何继承于NSObject的子类,它们都可以转化为一个objc_class类型,它们的实例对象就是objc_class的结构体指针,相应的方法,属性,协议都能在objc_class和它相关的属性中找到.

OBJC_ROOT_CLASS
OBJC_EXPORT
@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}

• Class是一个objc_class结构体指针类型,在新版本的runtime中,它继承于objc_object,内部提供一个class_rw_t用来记录类初始化中会更新的数据(用class_data_bits_t来保存),很多关键属性通过RO_和RW_开头的宏定义变量来定义,对于比较常的方法通过申明放式在外部单实现,它本省只负责管理一些class基本的操作,内存分配,类型检查,而关于它的方法,属性,协议相关的属性定义class_rw_t中间,由class_data_bits_t专门负责读写。

`typedef struct objc_class *Class;`

struct objc_class : objc_object {
    // Class ISA;
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable

    //保存`class_rw_t`的信息(read and write), 以下方法都是通过`bits`来进行读写更新`class_rw_t`的相关信息
    class_data_bits_t bits;   
    class_rw_t *data() {  ..
    void setData(class_rw_t *newData) { ...
    void setInfo(uint32_t set) { ...
    void clearInfo(uint32_t clear) { ...
    void changeInfo(uint32_t set, uint32_t clear) { ... 
    //引用计数相关的方法检查设置 retain/release/autorelease/retainCount/
    bool hasCustomRR() { 
    void setHasDefaultRR() { //设置默认的引用计数方法
    void setHasCustomRR(bool inherited = false);
    void printCustomRR(bool inherited);
    //检查和设置 alloc/allocWithZone
    bool hasCustomAWZ() {  ...
    void setHasDefaultAWZ() { ...
    void setHasCustomAWZ(bool inherited = false);
    void printCustomAWZ(bool inherited);  
    //requires raw isa
    bool instancesRequireRawIsa() { ..
    void setInstancesRequireRawIsa(bool inherited = false);
    void printInstancesRequireRawIsa(bool inherited);
    ...
    //ARC环境检测
    bool hasAutomaticIvars() { ... 
    bool isARC() { ...
    //对象关联
    bool instancesHaveAssociatedObjects() { ...
    void setInstancesHaveAssociatedObjects() { ... 
    //是否允许增加缓存
    bool shouldGrowCache() {  return true;
    bool isInitializing() {  return getMeta()->data()->flags & RW_INITIALIZING ...
    void setInitializing() {  ISA()->setInfo(RW_INITIALIZING);
    bool isInitialized() {  return getMeta()->data()->flags & RW_INITIALIZED; 
    void setInitialized();
  
    //抽象的实现
    bool isLoadable() {  return true;   ...
    
    //方法申明,代码解耦
    IMP getLoadMethod();

    // Locking: To prevent concurrent realization, hold runtimeLock.
    bool isRealized() {  return data()->flags & RW_REALIZED;

    // Returns true if this is an unrealized future class.
    // Locking: To prevent concurrent realization, hold runtimeLock.
    bool isFuture() {   return data()->flags & RW_FUTURE; ...
   
    //元类检测
    bool isMetaClass() { ... return data()->ro->flags & RO_META; ...
    
    //元类指向它本身,元类就是`objc_class`
    // NOT identical to this->ISA when this is a metaclass
    Class getMeta() {
        if (isMetaClass()) return (Class)this;
        else return this->ISA();
    }
    //当`objc_class`没有super时候的时候它就是`RootClass`
    bool isRootClass() {
        return superclass == nil;
    }
    bool isRootMetaclass() {
        return ISA() == (Class)this;
    }
    //获取class名称
    const char *mangledName() { 
        // fixme can't assert locks here
        assert(this);

        if (isRealized()  ||  isFuture()) {
            return data()->ro->name;
        } else {
            return ((const class_ro_t *)data())->name;
        }
    }
    //
    const char *demangledName(bool realize = false);
    const char *nameForLogging();

    
    uint32_t unalignedInstanceStart() {
        assert(isRealized());
        return data()->ro->instanceStart;
    }

    // 指定指针对齐方式
    uint32_t alignedInstanceStart() { ...
    uint32_t unalignedInstanceSize() {  ...
    uint32_t alignedInstanceSize() {  ...
    //指定初始化对象的大小,至少要求16字节以上
    size_t instanceSize(size_t extraBytes) { ...
    void setInstanceSize(uint32_t newSize) { ...
    void chooseClassArrayIndex();
    // 设置类索引
    void setClassArrayIndex(unsigned Idx) { ...
    unsigned classArrayIndex() { ...
};

• class_rw_t: 维护一个class经常需要变动的内容

//添加propterties/protocols/methods时机
static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    rw->methods.attachLists(mlists, mcount);  ...
    rw->properties.attachLists(proplists, propcount);  ...
    rw->protocols.attachLists(protolists, protocount); ...
    ...
static void methodizeClass(Class cls){ ...

struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint32_t version; 
    //一个只读的class信息管理
    const class_ro_t *ro; 
    //定义动态更新的方法,属性和协议
    method_array_t c;
    property_array_t properties;
    protocol_array_t protocols; 
    //subclass记录,放便数据的快速读取
    Class firstSubclass;
    Class nextSiblingClass; 
    char *demangledName; 
    //flags修改和清除
    void setFlags(uint32_t set)  
    void clearFlags(uint32_t clear)  
    void changeFlags(uint32_t set, uint32_t clear) ...
};

• class_ro_t: 只读class结构体,提供了class load时最原始的信息

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize; 
    const uint8_t * ivarLayout; 
    const char * name;
    method_list_t * baseMethodList;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars;
    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;

    method_list_t *baseMethods() const {
        return baseMethodList;
    }
};

• cache_t: 记录当前类常用的方法列表

struct cache_t {
    struct bucket_t *_buckets;
    mask_t _mask; //用于控制缓存的扩容
    mask_t _occupied; //记录方法的数量(_buckets缓存数量)

public:
    //cache更新
    ...
};
struct bucket_t { //主要负责记录常用的方法并缓存
private:
    // IMP-first is better for arm64e ptrauth and no worse for arm64.
    // SEL-first is better for armv7* and i386 and x86_64.
#if __arm64__
    MethodCacheIMP _imp;
    cache_key_t _key;
#else
    cache_key_t _key;
    MethodCacheIMP _imp;
#endif 

• objc的对象关联,它是通过另外一种方式添加的,通过一个全局的AssociationsHashMap来实现的。同样采用了DISGUISE来包装object指针,防止误检测内存泄漏

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) { ...
        //hash_map<disguised_ptr_t, ObjectAssociationMap *>
        AssociationsHashMap &associations(manager.associations());
       
}

Metal Class

• 元类其实就是一个刚刚初始化的class_rw_t结构体指针,它的flags为RO_META.

static void objc_initializeClassPair_internal(Class superclass, const char *name, Class cls, Class meta){ ...
    //在初始化一个类的时候,会同时创建2个类对象,并同时分配了`class_rw_t`和`class_ro_t`
    class_ro_t *cls_ro_w, *meta_ro_w;
    cls->setData((class_rw_t *)calloc(sizeof(class_rw_t), 1));
    meta->setData((class_rw_t *)calloc(sizeof(class_rw_t), 1));
    cls_ro_w   = (class_ro_t *)calloc(sizeof(class_ro_t), 1);
    //注意此处,元类因为不能被修改,所以它直接采用了`class_ro_t`定义，
    meta_ro_w  = (class_ro_t *)calloc(sizeof(class_ro_t), 1); 
    cls->data()->ro = cls_ro_w;
    meta->data()->ro = meta_ro_w;

    cls->data()->flags = RW_CONSTRUCTING | RW_COPIED_RO | RW_REALIZED | RW_REALIZING;
    meta->data()->flags = RW_CONSTRUCTING | RW_COPIED_RO | RW_REALIZED | RW_REALIZING;
    cls->data()->version = 0;
    meta->data()->version = 7;

    cls_ro_w->flags = 0;
    //指定了元类的flags
    meta_ro_w->flags = RO_META; ....

    ....
    //当前创建的类通过传入了`meta`class来定义
    //此时的`meta`元类只是刚刚初始化的结构体指针,除了runtime定义的基本特征,没有附加任何的其他逻辑
    cls->initClassIsa(meta);
    if (superclass) {
        meta->initClassIsa(superclass->ISA()->ISA());
        cls->superclass = superclass;
        meta->superclass = superclass->ISA();
        addSubclass(superclass, cls);
        addSubclass(superclass->ISA(), meta);
    } else {
        meta->initClassIsa(meta);
        cls->superclass = Nil;
        meta->superclass = cls; //元类的超类就是 rootClass
        addRootClass(cls); 
        addSubclass(cls, meta);
    }
    cls->cache.initializeToEmpty();
    meta->cache.initializeToEmpty();
    
    addClassTableEntry(cls);
}

//结合`object_class`中的原来
    //元类检测,此出flag由类对象分配的时候设置
    bool isMetaClass() { ... return data()->ro->flags & RO_META; ...

//上面执行` cls->initClassIsa(meta);`最终会进到这个方法来
inline void 
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) 
{ 
    assert(!isTaggedPointer()); 
    
    if (!nonpointer) {
        isa.cls = cls; //元类的isa就是它本身 `cls->initClassIsa(meta)`
    } else {
        assert(!DisableNonpointerIsa);
        assert(!cls->instancesRequireRawIsa());

        isa_t newisa(0);

#if SUPPORT_INDEXED_ISA
        assert(cls->classArrayIndex() > 0);
        newisa.bits = ISA_INDEX_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
        newisa.bits = ISA_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.shiftcls = (uintptr_t)cls >> 3;
#endif

        // This write must be performed in a single store in some cases
        // (for example when realizing a class because other threads
        // may simultaneously try to use the class).
        // fixme use atomics here to guarantee single-store and to
        // guarantee memory order w.r.t. the class index table
        // ...but not too atomic because we don't want to hurt instantiation
        isa = newisa;
    }
}

Tagged Point

• Tagged Point是苹果为了提高简单数据类型分配效率和节省内存开销而诞生的,举个栗子64位的空间中如果保存一个大小只占有32位或者空间更小的数据,这个数据是用指针表示,指针表示一个引用,指针比数据的内存大的多,这样通过指针访问就有点得不尝失了,所以就干脆直接把数据保存到指针中.通过对指针的内存空间重新layout得到tagged point

• 用一个标志位tag来表示数据类型，

• payload来指定它所容纳的数据

• extended为扩展字段

适用于NSNumber、NSDate,小的NSString类型,从它的内存分布来看.

__attribute__ 关键字

Attribute官方文档介绍

• 在阅读源码中有发现使用了大量的的 __attribute__ 关键字,它是是 GUN C 提供的,能编译器可以根据 __attribute__ 的定义为函数,类型,对象根据约定的标志进行额外的操作,这样就可以在我们编写代码时对编译规则进行适当的修改.

 __attribute__ ((deprecated)) 
 __attribute__((unavailable))
 __attribute__((unused))
__attribute__((noreturn)) 

int x __attribute__ ((aligned (16))) = 0; //字节对齐,用更小的只来标示该类型,减少空间,最大不能超过链接器的最大对齐字节
struct student
{
    char name[7];
    uint32_t id;
    char subject[5];
} __attribute__ ((aligned(4)));  //总字节应为 12

short array[3] __attribute__ ((aligned (__BIGGEST_ALIGNMENT__))); //最大的机器字节码对齐

struct my_packed_struct
{
     char c;
     int i;
     struct my_unpacked_struct s;
}__attribute__ ((__packed__)); //按类型具体大小对齐,char+int

__attribute__((format (printf, 1, 2))); //对可变参数的函数格式进行校验,(1表示为格式化字符串位置,2表示可变参位置)
attribute__((used))用于告诉编译器在目标文件中保留一个静态函数或者静态变量，即使它没有被引用。
__attribute__((always_inline)) 实现函数内联,对于简短频繁调用的函数,直接放入符号表,减少堆栈开销
__attribute__((constructor)) 修饰的函数在main函数之前执行,配合`__attribute__((destructor))`使用,常用统计库的时间 
__attribute__((objc_designated_initializer)) 指定某个函数为初始化构造器,限制对象的创建接口,这点对于初始化封装内部必须实现的内部逻辑非常有

TODO: