上一篇文章《iOS-底层原理13-类的加载上》介绍了类从MachO文件中读取到内存中并和类名进行绑定，并添加到已知类的表中，也就是类转化为名字，但是并没有给ro,rw,rwe中写入数据。
read_images->readClass:地址->name insert MAP
dyld->dylib-objc-init
LGPerson->属性 方法......->编译 - macho -> 内存(表)
MachO文件中能读到data()的数据格式，怎么读取到ro,rw,rwe中呢？
1.程序进入realizeClassWithoutSwift方法,alloc和init方法执行是在本类存在，且完备后，按照此模子初始化实例出来，在realizeClassWithoutSwift没有执行完之前，模子都不存在，无法进行初始化和实例化,此方法中读取了data(),存放到临时变量ro中，再copy一份赋值给rw，那么rwe什么时候赋值的呢？继续往后探索。
static Class realizeClassWithoutSwift(Class cls, Class previously)
{
runtimeLock.assertLocked();
class_rw_t *rw;
Class supercls;
Class metacls;
if (!cls) return nil;
if (cls->isRealized()) return cls;
// fixme verify class is not in an un-dlopened part of the shared cache?
auto ro = (const class_ro_t *)cls->data();
auto isMeta = ro->flags & RO_META;
if (ro->flags & RO_FUTURE) {
// This was a future class. rw data is already allocated.
rw = cls->data();
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>();
rw->set_ro(ro);
rw->flags = RW_REALIZED|RW_REALIZING|isMeta;
cls->setData(rw);
}
supercls = realizeClassWithoutSwift(remapClass(cls->superclass), nil);
metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil);
// Connect this class to its superclass's subclass lists
if (supercls) {
addSubclass(supercls, cls);
} else {
addRootClass(cls);
}
// Attach categories
methodizeClass(cls, previously);
return cls;
}
readonly 干净的内存地址,因为有运行时runtime的存在，要不断的往类中添加和删除属性，方法，协议，categories,对readonly的操作会比较严重，为了防止对原始数据的修改
将原来干净的内存从readonly中copy了一份到rw中，但并不是每一个类都会进行动态的插入，几万个几十万个类可能就只有几个或几十个类进行动态操作，只要你动态处理了，才生成相应的rwe,一般情况下的rw是从ro里面读取的，如果有运行时，则从rwe中读取，取值的逻辑是判断有没有运行时
const class_ro_t *ro() const {
auto v = get_ro_or_rwe();
if (slowpath(v.is<class_rw_ext_t *>())) {
return v.get<class_rw_ext_t *>()->ro;
}
return v.get<const class_ro_t *>();
}
rwe就是所谓的“脏内存”的概念
2.类的信息处理->父类->元类，LGPerson的继承链进行递归supercls = realizeClassWithoutSwift(remapClass(cls->superclass), nil)和metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil)
子类父类元类递归.png
3.realizeClassWithoutSwift方法中尽管看到了data()的读取，强制赋值到临时变量ro，copy一份到了类的rw里面，程序继续往下进入methodizeClass()方法,方法化当前类,在lookupImpForward方法中进行二分查找的时候，methodList是排过序的，是在什么时候排序的呢？
methodizeClass.png
static Class realizeClassWithoutSwift(Class cls, Class previously)
{
runtimeLock.assertLocked();
class_rw_t *rw;
Class supercls;
Class metacls;
if (!cls) return nil;
if (cls->isRealized()) return cls;
ASSERT(cls == remapClass(cls));
auto ro = (const class_ro_t *)cls->data();
auto isMeta = ro->flags & RO_META;
if (ro->flags & RO_FUTURE) {
// This was a future class. rw data is already allocated.
rw = cls->data();
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>();
rw->set_ro(ro);
rw->flags = RW_REALIZED|RW_REALIZING|isMeta;
cls->setData(rw);
}
supercls = realizeClassWithoutSwift(remapClass(cls->superclass), nil);
metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil);
// Attach categories
methodizeClass(cls, previously);
return cls;
}
-
通过lldb读取ro中的方法:得知当前ro中存储了8个方法，程序继续往下执行,
methodizeClass->prepareMethodLists->fixupMethodList->std::stable_sort(mlist->begin(), mlist->end(), sorter),排序通过Sort by selector address，
ro@2x.png
static void methodizeClass(Class cls, Class previously){
// Install methods and properties that the class implements itself.
method_list_t *list = ro->baseMethods();
if (list) {
prepareMethodLists(cls, &list, 1, YES, isBundleClass(cls));
if (rwe) rwe->methods.attachLists(&list, 1);
}
}
static void
prepareMethodLists(Class cls, method_list_t **addedLists, int addedCount,
bool baseMethods, bool methodsFromBundle)
{
// Add method lists to array.
// Reallocate un-fixed method lists.
// The new methods are PREPENDED to the method list array.
for (int i = 0; i < addedCount; i++) {
method_list_t *mlist = addedLists[i];
ASSERT(mlist);
// Fixup selectors if necessary
if (!mlist->isFixedUp()) {
fixupMethodList(mlist, methodsFromBundle, true/*sort*/);
}
}
static void
fixupMethodList(method_list_t *mlist, bool bundleCopy, bool sort)
{
runtimeLock.assertLocked();
ASSERT(!mlist->isFixedUp());
// fixme lock less in attachMethodLists ?
// dyld3 may have already uniqued, but not sorted, the list
if (!mlist->isUniqued()) {
mutex_locker_t lock(selLock);
// Unique selectors in list.
for (auto& meth : *mlist) {
const char *name = sel_cname(meth.name);
meth.name = sel_registerNameNoLock(name, bundleCopy);
}
}
// Sort by selector address.
if (sort) {
method_t::SortBySELAddress sorter;
std::stable_sort(mlist->begin(), mlist->end(), sorter);
}
// Mark method list as uniqued and sorted
mlist->setFixedUp();
}
-
我们将LGPerson类中的方法进行顺序错乱，查看经过排序方法后，排序是否生效
LGPerson中kc_instanceMethod2方法在前@2x.png
LGPerson实现类@2x.png
-
在fixupMethodList方法之前ro中的方法顺序,排序为什么没有生效？实质上排序已经生效了，并不是根据我们以为的方法名字的字符串顺序排序，而是根据selector的地址进行排序,详情在下一篇文章中进行分析。
fixupMethodList方法之前@2x.png
-
在fixupMethodList方法之后ro中的方法顺序
fixupMethodList方法之后ro中方法排序@2x.png
- 方法进行排序后，
if (rwe) rwe->methods.attachLists(&list, 1)将list复制到rwe中，但此时发现rwe为NULL,则方法并没有被拷贝进rwe中，data()->rw->ro->rwe(没有走),为何没有走？
rwe为NULL@2x.png
3.前面read_images中，是怎么进入realizeClassWithoutSwift(cls, nil);方法的呢？下面有一句话说明了原因Realize non-lazy classes (for +load methods and static instances)，非懒加载类和静态实例才会进入下面的realizeClassWithoutSwift方法
懒加载类:懒，别人不动我不动
非懒加载类:实现+(void)load方法,让它提前加载了，load方法在load_images时候就会直接调用，若非懒加载类(实现了load方法的类)没有提前加载，则在load_images中调用所有类的load方法的时候如何调用？？？所以非懒加载类实现了load方法，让它提前加载，进入realizeClassWithoutSwift方法
给LGPerson实现+(void)load方法，则会在main函数之前进入到realizeClassWithoutSwift中进行类的加载
非懒加载类进入realizeClassWithoutSwift方法@2x.png
非懒加载类的加载@2x.png
4.懒加载:只有在第一次调用了这个类中的方法(第一次进行消息发送)的时候才会去实现这个类，从而调用realizeClassWithoutSwift方法，那为什么要懒加载呢？实现这个类的加载的时候有很多的代码，排序，临时变量，如果把所有的类都推迟到main函数启动之前，整个main函数的启动就会非常非常的慢，也有可能实现写进的这个类，从来都没有被调用过，造成内存资源的浪费，还有必要去耗费内存嘛？这也是为什么+(void)load方法尽量不要随便写的原因了。苹果默认是懒加载类，给了开发人员更多自由。
懒加载消息发送@2x.png
alloc消息发送进行加载@2x.png
(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 3.1
* frame #0: 0x000000010013dc03 libobjc.A.dylib`realizeClassWithoutSwift(cls=0x0000000100002240, previously=0x0000000000000000) at objc-runtime-new.mm:2486:17
frame #1: 0x000000010015a460 libobjc.A.dylib`realizeClassMaybeSwiftMaybeRelock(cls=0x0000000100002240, lock=0x0000000100196000, leaveLocked=true) at objc-runtime-new.mm:2759:9
frame #2: 0x0000000100145db2 libobjc.A.dylib`realizeClassMaybeSwiftAndLeaveLocked(cls=0x0000000100002240, lock=0x0000000100196000) at objc-runtime-new.mm:2782:12
frame #3: 0x0000000100145adb libobjc.A.dylib`lookUpImpOrForward(inst=0x0000000100002268, sel="alloc", cls=0x0000000100002240, behavior=3) at objc-runtime-new.mm:6141:15
frame #4: 0x0000000100121159 libobjc.A.dylib`_objc_msgSend_uncached at objc-msg-x86_64.s:1101
frame #5: 0x000000010017c1e5 libobjc.A.dylib`objc_alloc [inlined] callAlloc(cls=LGPerson, checkNil=true, allocWithZone=false) at NSObject.mm:1714:12
frame #6: 0x000000010017c13e libobjc.A.dylib`objc_alloc(cls=LGPerson) at NSObject.mm:1730
frame #7: 0x0000000100000bcb KCObjc`main(argc=1, argv=0x00007ffeefbff4c8) at main.m:14:28 [opt]
frame #8: 0x00007fff69395cc9 libdyld.dylib`start + 1
frame #9: 0x00007fff69395cc9 libdyld.dylib`start + 1
懒加载和非懒加载类@2x.png
5.分类的本质:结构体_category_t
通过clang查看分类的源码clang -rewrite-objc main.m -o main.cpp_category_t中成员如下，分类中的属性没有通过runtime添加，不会生成setter和getter方法
struct _category_t {
const char *name;
struct _class_t *cls;
const struct _method_list_t *instance_methods;
const struct _method_list_t *class_methods;
const struct _protocol_list_t *protocols;
const struct _prop_list_t *properties;
};
分类@2x.png
category_t@2x.png
分类中的方法
static struct /*_method_list_t*/ {
unsigned int entsize; // sizeof(struct _objc_method)
unsigned int method_count;
struct _objc_method method_list[3];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_LGPerson_$_LG __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
3,
{{(struct objc_selector *)"cate_instancedMethod1", "v16@0:8", (void *)_I_LGPerson_LG_cate_instancedMethod1},
{(struct objc_selector *)"cate_instancedMethod3", "v16@0:8", (void *)_I_LGPerson_LG_cate_instancedMethod3},
{(struct objc_selector *)"cate_instancedMethod2", "v16@0:8", (void *)_I_LGPerson_LG_cate_instancedMethod2}}
};
分类中的属性
static struct /*_prop_list_t*/ {
unsigned int entsize; // sizeof(struct _prop_t)
unsigned int count_of_properties;
struct _prop_t prop_list[2];
} _OBJC_$_PROP_LIST_LGPerson_$_LG __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_prop_t),
2,
{{"cate_name","T@\"NSString\",C,N"},
{"cate_age","Ti,N"}}
};
对分类的本质了解，之后，那分类中的方法是怎么加载到类里面的呢？
6.realizeClassWithoutSwift方法之后进入methodizeClass(cls, previously)添加分类，先对类中的方法进行排序，从而进入objc::unattachedCategories.attachToClass方法中
methodizeClass中对方法进行排序@2x.png
添加分类中的方法到类中@2x.png
unattachedCategories@2x.png
objc::unattachedCategories.attachToClass的初始化在runtime_init()方法中
7.objc::unattachedCategories.attachToClass方法主要做了什么?
添加方法到类中，若同时存在对象方法和类方法，则添加两次，若只存在对象方法，则只添加一次，进入到attachCategories方法中，将类中的方法先排序，后以数组中的第64个从后往前插入
attachToClass@2x.png
attachCategories@2x.png
void attachToClass(Class cls, Class previously, int flags)
{
const char *mangledName = cls->mangledName();
const char *LGPersonName = "LGPerson";
if (strcmp(mangledName, LGPersonName) == 0) {
bool kc_isMeta = cls->isMetaClass();
auto kc_rw = cls->data();
auto kc_ro = kc_rw->ro();
if (!kc_isMeta) {
printf("%s: 这个是我要研究的 %s \n",__func__,LGPersonName);
}
}
auto &map = get();
auto it = map.find(previously);
if (it != map.end()) {
category_list &list = it->second;
if (flags & ATTACH_CLASS_AND_METACLASS) {
int otherFlags = flags & ~ATTACH_CLASS_AND_METACLASS;
attachCategories(cls, list.array(), list.count(), otherFlags | ATTACH_CLASS);
attachCategories(cls->ISA(), list.array(), list.count(), otherFlags | ATTACH_METACLASS);
} else {
attachCategories(cls, list.array(), list.count(), flags);
}
map.erase(it);
}
}
8.在objc源码中全局搜索extAllocIfNeeded方法的调用，发现rwe只有在分类、+addMethod、+addProperty、+addProtocol进行添加的时候才会初始化,上面对类中的方法进行添加的时候，先要对rwe进行初始化
rwe初始化@2x.png
rwe@2x.png
网友评论