本文的主要目的是理解类的相关信息
是如何加载
到内存
的,其中重点关注map_images
和load_images
_read_images 源码实现
_read_images
主要是主要是加载类信息
,即类、分类、协议等,进入_read_images
源码实现,主要分为以下几部分:
-
1、条件控制进行的一次加载
-
2、修复预编译阶段的@selector的混乱问题
-
3、错误混乱的类处理
-
4、修复重映射一些没有被镜像文件加载进来的类
-
5、修复一些消息
-
6、当类里面有协议时:readProtocol 读取协议
-
7、修复没有被加载的协议
-
8、分类处理
-
9、类的加载处理
-
10、没有被处理的类,优化那些被侵犯的类
我们需要重点关注的是3中的readClass
以及9中realizeClassWithoutSwift
两个方法
readClass:读取类
readClass
主要是读取类
,在未调用该方法前,cls
只是一个地址
,执行该方法后,cls
是类的名称
,其源码实现如下,关键代码是addNamedClass
和addClassTableEntry
,源码实现如下
Class readClass(Class cls, bool headerIsBundle, bool headerIsPreoptimized)
{
const char *mangledName = cls->mangledName();//名字
// **CJL写的** ----如果想进入自定义,自己加一个判断
const char *LGPersonName = "LGPerson";
if (strcmp(mangledName, LGPersonName) == 0) {
auto kc_ro = (const class_ro_t *)cls->data();
printf("%s -- 研究重点--%s\n", __func__,mangledName);
}
//当前类的父类中若有丢失的weak-linked类,则返回nil
if (missingWeakSuperclass(cls)) {
// No superclass (probably weak-linked).
// Disavow any knowledge of this subclass.
if (PrintConnecting) {
_objc_inform("CLASS: IGNORING class '%s' with "
"missing weak-linked superclass",
cls->nameForLogging());
}
addRemappedClass(cls, nil);
cls->superclass = nil;
return nil;
}
cls->fixupBackwardDeployingStableSwift();
//判断是不是后期要处理的类
//正常情况下,不会走到popFutureNamedClass,因为这是专门针对未来待处理的类的操作
//通过断点调试,不会走到if流程里面,因此也不会对ro、rw进行操作
Class replacing = nil;
if (Class newCls = popFutureNamedClass(mangledName)) {
// This name was previously allocated as a future class.
// Copy objc_class to future class's struct.
// Preserve future's rw data block.
if (newCls->isAnySwift()) {
_objc_fatal("Can't complete future class request for '%s' "
"because the real class is too big.",
cls->nameForLogging());
}
//读取class的data,设置ro、rw
//经过调试,并不会走到这里
class_rw_t *rw = newCls->data();
const class_ro_t *old_ro = rw->ro();
memcpy(newCls, cls, sizeof(objc_class));
rw->set_ro((class_ro_t *)newCls->data());
newCls->setData(rw);
freeIfMutable((char *)old_ro->name);
free((void *)old_ro);
addRemappedClass(cls, newCls);
replacing = cls;
cls = newCls;
}
//判断是否类是否已经加载到内存
if (headerIsPreoptimized && !replacing) {
// class list built in shared cache
// fixme strict assert doesn't work because of duplicates
// ASSERT(cls == getClass(name));
ASSERT(getClassExceptSomeSwift(mangledName));
} else {
addNamedClass(cls, mangledName, replacing);//加载共享缓存中的类
addClassTableEntry(cls);//插入表,即相当于从mach-O文件 读取到 内存 中
}
// for future reference: shared cache never contains MH_BUNDLEs
if (headerIsBundle) {
cls->data()->flags |= RO_FROM_BUNDLE;
cls->ISA()->data()->flags |= RO_FROM_BUNDLE;
}
return cls;
}
通过源码实现,主要分为以下几步:
-
通过
mangledName
获取类的名字,其中mangledName
方法的源码实现如下
const char *mangledName() {
// fixme can't assert locks here
ASSERT(this);
if (isRealized() || isFuture()) { //这个初始化判断在lookupImp也有类似的
return data()->ro()->name;//如果已经实例化,则从ro中获取name
} else {
return ((const class_ro_t *)data())->name;//反之,从mach-O的数据data中获取name
}
}
-
当前类的父类中若有丢失的
weak-linked
类,则返回nil
-
判断是不是后期需要处理的类,在正常情况下,不会走到
popFutureNamedClass
,因为这是专门针对未来待处理的类的操作
,也可以通过断点调试,可知不会走到if流程
里面,因此也不会对ro、rw
进行操作-
data
是mach-O
的数据,并不在class的内存
中 -
ro
的赋值
是从mach-O中的data强转赋值
的 -
rw里的ro
是从ro复制过去
的
-
-
通过
addNamedClass
将当前类添加到已经创建好的gdb_objc_realized_classes
哈希表,该表用于存放所有类
/***********************************************************************
* addNamedClass 加载共享缓存中的类 插入表
* Adds name => cls to the named non-meta class map. 将name=> cls添加到命名的非元类映射
* Warns about duplicate class names and keeps the old mapping.
* Locking: runtimeLock must be held by the caller
**********************************************************************/
static void addNamedClass(Class cls, const char *name, Class replacing = nil)
{
runtimeLock.assertLocked();
Class old;
if ((old = getClassExceptSomeSwift(name)) && old != replacing) {
inform_duplicate(name, old, cls);
// getMaybeUnrealizedNonMetaClass uses name lookups.
// Classes not found by name lookup must be in the
// secondary meta->nonmeta table.
addNonMetaClass(cls);
} else {
//添加到gdb_objc_realized_classes哈希表
NXMapInsert(gdb_objc_realized_classes, name, cls);
}
ASSERT(!(cls->data()->flags & RO_META));
// wrong: constructed classes are already realized when they get here
// ASSERT(!cls->isRealized());
}
-
通过
addClassTableEntry
,将初始化的类添加到allocatedClasses
表,这个表在iOS-底层原理 16:dyld与objc的关联文章中提及过,是在_objc_init
中的runtime_init
就创建了allocatedClasses
表
/***********************************************************************
* addClassTableEntry 将一个类添加到所有类的表中
* Add a class to the table of all classes. If addMeta is true,
* automatically adds the metaclass of the class as well.
* Locking: runtimeLock must be held by the caller.
**********************************************************************/
static void
addClassTableEntry(Class cls, bool addMeta = true)
{
runtimeLock.assertLocked();
// This class is allowed to be a known class via the shared cache or via
// data segments, but it is not allowed to be in the dynamic table already.
auto &set = objc::allocatedClasses.get();//开辟的类的表,在objc_init中的runtime_init就创建了表
ASSERT(set.find(cls) == set.end());
if (!isKnownClass(cls))
set.insert(cls);
if (addMeta)
//添加到allocatedClasses哈希表
addClassTableEntry(cls->ISA(), false);
}
如果我们想在readClass
源码中想定位到自定义的类
,可以自定义加if判断
总结
所以综上所述,readClass
的主要作用就是将Mach
-O中的类读取到内存
,即插入表
中,但是目前的类仅有两个信息:地址
以及名称
,而mach-O
的其中的data
数据还未读取出来
realizeClassWithoutSwift:实现类
realizeClassWithoutSwift
方法中有ro、rw
的相关操作,这个方法在消息流程的慢速查找
中有所提及,方法路径为:慢速查找(lookUpImpOrForward
) -- realizeClassMaybeSwiftAndLeaveLocked
-- realizeClassMaybeSwiftMaybeRelock
-- realizeClassWithoutSwift
(实现类)
realizeClassWithoutSwift
方法主要作用是实现类
,将类的data
数据加载到内存
中,主要有以下几部分操作:
-
【第一步】读取
data
数据,并设置ro、rw
-
【第二步】递归调用
realizeClassWithoutSwift
完善继承链
-
【第三步】通过
methodizeClass
方法化类
第一步:读取data数据
读取class
的data
数据,并将其强转为ro
,以及rw初始化
和ro拷贝一份到rw中的ro
-
ro
表示readOnly
,即只读
,其在编译时就已经确定了内存,包含类名称、方法、协议和实例变量的信息,由于是只读的,所以属于Clean Memory
,而Clean Memory
是指加载后不会发生更改的内存
-
rw
表示readWrite
,即可读可写
,由于其动态性,可能会往类中添加属性、方法、添加协议,在最新的2020的WWDC
的对内存优化
的说明Advancements in the Objective-C runtime - WWDC 2020 - Videos - Apple Developer中,提到rw
,其实在rw
中只有10%的类真正的更改了它们的方法,所以有了rwe
,即类的额外信息
。对于那些确实需要额外信息的类,可以分配rwe扩展记录中的一个,并将其滑入类中供其使用。其中rw
就属于dirty memory
,而dirty memory
是指在进程运行时会发生更改的内存
,类结构
一经使用
就会变成ditry memory
,因为运行时会向它写入新数据,例如 创建一个新的方法缓存,并从类中指向它
// fixme verify class is not in an un-dlopened part of the shared cache?
//读取class的data(),以及ro/rw创建
auto ro = (const class_ro_t *)cls->data(); //读取类结构的bits属性、//ro -- clean memory,在编译时就已经确定了内存
auto isMeta = ro->flags & RO_META; //判断元类
if (ro->flags & RO_FUTURE) {
// This was a future class. rw data is already allocated.
rw = cls->data(); //dirty memory 进行赋值
ro = cls->data()->ro();
ASSERT(!isMeta);
cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
} else { //此时将数据读取进来了,也赋值完毕了
// Normal class. Allocate writeable class data.
rw = objc::zalloc<class_rw_t>(); //申请开辟zalloc -- rw
rw->set_ro(ro);//rw中的ro设置为临时变量ro
rw->flags = RW_REALIZED|RW_REALIZING|isMeta;
cls->setData(rw);//将cls的data赋值为rw形式
}
【第二步】递归调用 realizeClassWithoutSwift 完善 继承链
递归调用realizeClassWithoutSwift
完善继承链
,并设置当前类、父类、元类的rw
-
递归调用
realizeClassWithoutSwift
设置父类、元类
-
设置
父类和元类的isa指向
-
通过
addSubclass 和 addRootClass
设置父子的双向链表指向关系,即父类中可以找到子类,子类中可以找到父类
// Realize superclass and metaclass, if they aren't already.
// This needs to be done after RW_REALIZED is set above, for root classes.
// This needs to be done after class index is chosen, for root metaclasses.
// This assumes that none of those classes have Swift contents,
// or that Swift's initializers have already been called.
// fixme that assumption will be wrong if we add support
// for ObjC subclasses of Swift classes. --
//递归调用realizeClassWithoutSwift完善继承链,并处理当前类的父类、元类
//递归实现 设置当前类、父类、元类的 rw,主要目的是确定继承链 (类继承链、元类继承链)
//实现元类、父类
//当isa找到根元类之后,根元类的isa是指向自己的,不会返回nil从而导致死循环——remapClass中对类在表中进行查找的操作,如果表中已有该类,则返回一个空值;如果没有则返回当前类,这样保证了类只加载一次并结束递归
supercls = realizeClassWithoutSwift(remapClass(cls->superclass), nil);
metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil);
...
// Update superclass and metaclass in case of remapping -- class 是 双向链表结构 即父子关系都确认了
// 将父类和元类给我们的类 分别是isa和父类的对应值
cls->superclass = supercls;
cls->initClassIsa(metacls);
...
// Connect this class to its superclass's subclass lists
//双向链表指向关系 父类中可以找到子类 子类中也可以找到父类
//通过addSubclass把当前类放到父类的子类列表中去
if (supercls) {
addSubclass(supercls, cls);
} else {
addRootClass(cls);
}
这里有一个问题,realizeClassWithoutSwift
递归调用时,isa
找到根元类
之后,根元类的isa
是指向自己
,并不会返回nil
,所以有以下递归终止条件,其目的是保证类只加载一次
-
在
realizeClassWithoutSwift
中-
如果类
不存在
,则返回nil
-
如果类
已经实现
,则直接返回cls
-
static Class realizeClassWithoutSwift(Class cls, Class previously)
{
runtimeLock.assertLocked();
//如果类不存在,则返回nil
if (!cls) return nil;
如果类已经实现,则直接返回cls
if (cls->isRealized()) return cls;
ASSERT(cls == remapClass(cls));
...
}
-
在
remapClass
方法中,如果cls
不存在,则直接返回nil
/***********************************************************************
* remapClass
* Returns the live class pointer for cls, which may be pointing to
* a class struct that has been reallocated.
* Returns nil if cls is ignored because of weak linking.
* Locking: runtimeLock must be read- or write-locked by the caller
**********************************************************************/
static Class remapClass(Class cls)
{
runtimeLock.assertLocked();
if (!cls) return nil;//如果cls不存在,则返回nil
auto *map = remappedClasses(NO);
if (!map)
return cls;
auto iterator = map->find(cls);
if (iterator == map->end())
return cls;
return std::get<1>(*iterator);
}
【第三步】通过 methodizeClass 方法化类
通过methodizeClass
方法,从ro
中读取方法列表
(包括分类中的方法)、属性列表、协议列表赋值给rw
,并返回cls
// Attach categories 附加类别 -- 疑问:ro中也有方法列表 rw中也有方法列表,下面这个方法可以说明
//将ro数据写入到rw
methodizeClass(cls, previously);
return cls;
断点调试 realizeClassWithoutSwift
如果我们需要跟踪自定义类,同样需要_read_images
方法中的第九步的realizeClassWithoutSwift
调用前,以及realizeClassWithoutSwift
方法中增加自定义逻辑,主要是为了方便调试自定义类
-
_read_images
方法中的第九步的realizeClassWithoutSwift
调用前增加自定义逻辑
-
_read_images第九步增加自定义逻辑
-
realizeClassWithoutSwift
方法中增加自定义逻辑
下面,开启我们的断点调试
-
在
LGPerson
中重写+load
函数
-
重新运行程序,我们就走到了
_read_images
的第九步
中的自定义逻辑部分
-
通过源码可知
ro
的获取
主要分两种情况:有没有运行时
,-
如果
有运行时
,从rw
中读取 -
反之,如果没有运行时,从
ro
中读取
-
methodizeClass:方法化类
其中methodizeClass
的源码实现如下,主要分为几部分:
-
将
属性列表、方法列表、协议列表
等贴到rwe
中 -
附加
分类
中的方法
rwe的逻辑
方法列表
加入rwe
的逻辑如下:
-
获取
ro
的baseMethods
-
通过
prepareMethodLists
方法排序 -
对
rwe
进行处理即通过attachLists
插入
方法如何排序
在消息流程的慢速查找流程
iOS-底层原理 13:消息流程分析之慢速查找文章中,方法的查找算法是通过二分查找算法
,说明sel-imp是有排序的,那么是如何排序的呢?
-
进入
prepareMethodLists
的源码实现,其内部是通过fixupMethodList
方法排序
-
进入
fixupMethodList
源码实现,是根据selector address
排序
attachToClass方法
在methodlist
方法主要是将分类添加到主类
中
因为attachToClass
中的外部循环是找到一个分类就会进到attachCategories
一次,即找一个就循环一次
attachCategories方法
在attachCategories
方法中准备分类的数据
-
在
auto rwe = cls->data()->extAllocIfNeeded();
是进行rwe的创建,那么为什么要在这里进行rwe的初始化
??因为我们现在要做一件事:往本类
中添加属性、方法、协议
等,即对原来的 clean memory要进行处理了-
进入
extAllocIfNeeded
方法的源码实现,判断rwe是否存在,如果存在则直接获取,如果不存在则开辟 -
进入
extAlloc
源码实现,即对rwe 0-1的过程,在此过程中,就将本类的data数据
加载进去了
-
-
其中关键代码是
rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
即存入mlists的末尾,mlists
的数据来源前面的for循环
-
在调试运行时,发现
category_t
中的name
编译时是LGPerson
(参考clang编译时的那么),运行时是LGA
即分类的名字 -
代码
mlists[ATTACH_BUFSIZ - ++mcount] = mlist;
,经过调试发现此时的mcount
等于1
,即可以理解为倒序插入
,64
的原因是允许容纳64个(最多64个分类)
总结:本类 中 需要添加属性、方法等,所以需要初始化rwe
,rwe的初始化主要涉及:分类、addMethod、addProperty、addprotocol
, 即对原始类进行修改或者处理时,才会进行rwe的初始化
attachLists方法:插入
针对情况3
,这里的lists是指分类
memmove和memcpy的区别
rwe 数据加载
rwe -- 本类的数据加载【重点!!!】
下面通过调试来验证rwe数据0-1的过程
,即添加类的方法列表
-
其中
方法、属性
继承于entsize_list_tt
,协议
则是类似entsize_list_tt
实现,都是二维数组
-
从源码可以得知,
插入表
主要分为三种情况: -
【情况1:
多对多
】如果当前调用attachLists
的list_array_tt
二维数组中有多个一维数组
-
计算数组中
旧lists
的大小 -
计算新的容量大小 =
旧数据大小+新数据大小
-
根据新的容量大小,开辟一个数组,类型是
array_t
,通过array()
获取 -
设置数组大小
-
旧的数据
从 addedCount 数组下标开始 存放旧的lists
,大小为旧数据大小 * 单个旧list大小
,即整段平移
,可以简单理解为原来的数据移动到后面
,即指针偏移
-
新数据
从数组 首位置开始存储,存放新的lists
,大小为新数据大小 * 单个list大小
,可以简单理解为越晚加进来,越在前面,越在前面,调用时则优先调用
-
-
【情况2:
0对一
】如果调用attachLists
的list_array_tt
二维数组为空且新增大小数目为 1
-
直接赋值
addedList
的第一个list
-
-
【情况3:
一对多
】如果当前调用attachLists
的list_array_tt
二维数组只有一个一维数组
-
获取旧的list
-
计算
容量和 = 旧list个数+新lists的个数
-
开辟一个容量和大小的集合,类型是
array_t
,即创建一个数组,放到array
中,通过array()
获取 -
设置数组的大小
-
判断old是否存在,old肯定是存在的,将
旧的list放入到数组的末尾
-
memcpy(开始位置,放什么,放多大)
是内存平移
,从数组起始位置开始存入新的list
,其中array()->lists
表示首位元素位置
-
-
这是日常开发中,为什么
子类实现父类方法会把父类方法覆盖
的原因 -
同理,对于同名方法,
分类方法覆盖类方法
的原因 -
这个操作来自一个算法思维
LRU即最近最少使用
,加这个newlist的目的是由于要使用这个newlist中的方法
,这个newlist
对于用户的价值要高,即优先调用
-
会来到
1对多
的原因 ,主要是有分类的添加
,即旧的元素在后面,新的元素在前面 ,究其根本原因主要是优先调用category
,这也是分类的意义所在 -
在不知道需要平移的内存大小时,需要
memmove
进行内存平移
,保证安全
-
memcpy
从原内存地址的起始位置开始拷贝若干个字节到目标内存地址中,速度快
-
在
attachCategories -> extAllocIfNeeded -> extAlloc
增加自定义逻辑,运行,并断住,从堆栈信息可以看出是从attachCategories
方法中auto rwe = cls->data()->extAllocIfNeeded();
过来的,这里的作用是开辟rwe
,-
那么为什么要在这里进行
rwe的初始化
?因为我们现在要做一件事:往本类
中添加属性、方法、协议
等,即对原来的clean memory
要进行处理了 -
rwe
是在分类处理
时才会进行处理,即rwe初始化,且有以下几个方法会涉及rwe的初始化 ,分别是:分类 + addMethod + addPro + addProtocol
总结:如果本类只
有一个分类
,则会走到情况3,即1对多
的情况rwe -- LGB分类数据加载【重点!!!】
如果再加一个
分类LGB
,走到第三种情况,即多对多
-
再次走到
attachCategories -- if (mcount > 0) {
,进入attachLists
,走到 多对多的情况总结
综上所述,
attachLists
方法主要是将类 和 分类 的数据加载到rwe
中 -
首先
加载本类的data数据
,此时的rwe没有数据为空
,走0对1流程
-
当
加入一个分类
时,此时的rwe仅有一个list
,即本类的list,走1对多流程
-
如下图所示
-
再加入一个分类时,此时的
rwe中有两个list
,即本类+分类的list
,走多对多流程
-