OC底层探索(十六): 类的加载(四)

所用版本:

• 处理器: Intel Core i9
• MacOS 12.3.1
• Xcode 13.3.1
• objc4-838

建议先看下
OC底层探索(十三): 类的加载(一)
OC底层探索(十四): 类的加载(二)
OC底层探索(十五): 类的加载(三)

看下分类的加载情况, 我们创建一个分类, 断点进行看一下。创建分类可参考: OC 创建分类

分类的加载

分类加载有4种情况,

• 分类, 主类都有 +load方法
• 分类有 +load方法, 主类无
• 主类有 +load方法, 分类无
• 两者皆无

针对这四种情况, 我们依次探索下分类加载链

分类, 主类都有 +load方法

• load_images → loadAllCategories → load_categories_nolock → attachCategories

跟断点走可发现, 并没有出现在_dyld_objc_notify_register(&map_images, load_images, unmap_image);第一个参数 &map_images 去处理, 而是在load_images中进行。

map链

看打印信息或者走断点也能看出map_images链先于load_images完成.

确保分类进入

当然我们也为了确保是我们创建的分类进入, 断点读取下, 也可发现类型为我们自定义分类"SRTestCategory"。 因为有+load, 当前类已经变为非懒加载类, 所以会走if (cls->isRealized())判断中的attachCategories。 关于load_categories_nolock方法

load_categories_nolock

static void load_categories_nolock(header_info *hi) {
    
    // header_info: Images in the shared cache will have an empty array here while those
    // allocated at run time will allocate a single entry.
    // 在共享缓存中的镜像, 将有一个空数组，而在运行时分配的将分配一个条目。
    
    // ...
    // header_info_rw rw_data[];
    //} header_info;

    bool hasClassProperties = hi->info()->hasCategoryClassProperties();

    size_t count;
    // 遍历分类列表添加分类
    // 留意下这个方法是定一个闭包
    auto processCatlist = [&](category_t * const *catlist) {
        for (unsigned i = 0; i < count; i++) {
            category_t *cat = catlist[I];
            Class cls = remapClass(cat->cls);

            //将cat和hi包装成 locstamped_category_t
            locstamped_category_t lc{cat, hi};

            // 如果当前类不存在, 忽略分类
            if (!cls) {
                // Category's target class is missing (probably weak-linked).
                // Ignore the category.
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class",
                                 cat->name, cat);
                }
                continue;
            }

            // Process this category.
            // 处理分类
            if (cls->isStubClass()) {
                // Stub classes are never realized. Stub classes
                // don't know their metaclass until they're
                // initialized, so we have to add categories with
                // class methods or properties to the stub itself.
                // methodizeClass() will find them and add them to
                // the metaclass as appropriate.
                
                // Stub classes 存根类不会被实现.
                // 存根类在初始化之前不知道其元类，
                // 因此我们必须向存根本身添加具有类方法或属性的类别。
                // methodizeClass（）将找到它们，并根据需要将它们添加到元类中。
                
                // 其中: category_t *cat = catlist[I];
                if (cat->instanceMethods ||
                    cat->protocols ||
                    cat->instanceProperties ||
                    cat->classMethods ||
                    cat->protocols ||
                    (hasClassProperties && cat->_classProperties))
                {
                    objc::unattachedCategories.addForClass(lc, cls);
                }
            } else {
                // First, register the category with its target class.
                // Then, rebuild the class's method lists (etc) if
                // the class is realized.
                
                // 首先，注册分类在其目标类。
                // 然后，如果类已实现，则重建该类的方法列表（etc）。
                
                // 实例
                if (cat->instanceMethods ||  cat->protocols
                    ||  cat->instanceProperties)
                {
                    
                    if (cls->isRealized()) {
                        // 非懒加载类
                        attachCategories(cls, &lc, 1, ATTACH_EXISTING);
                    } else {
                        // 懒加载类
                        objc::unattachedCategories.addForClass(lc, cls);
                    }
                }

                // 类
                if (cat->classMethods  ||  cat->protocols
                    ||  (hasClassProperties && cat->_classProperties))
                {
                    // 元类非懒加载
                    if (cls->ISA()->isRealized()) {
                        attachCategories(cls->ISA(), &lc, 1, ATTACH_EXISTING | ATTACH_METACLASS);
                    } else {
                        // 懒加载
                        objc::unattachedCategories.addForClass(lc, cls->ISA());
                    }
                }
            }
        }
    };

    // 处理Catlist, 实际是从mach-o中__objc_catlist, __objc_catlist2获取分类
    // GETSECT(_getObjc2CategoryList,        category_t * const,    "__objc_catlist");
    // GETSECT(_getObjc2CategoryList2,       category_t * const,    "__objc_catlist2");
    // 闭包的调用
    processCatlist(hi->catlist(&count)); 
    processCatlist(hi->catlist2(&count));
}

• 先留意下这个外层auto processCatlist = [&](category_t * const *catlist) { }, 是一个闭包, 我们也可以当成block. 调用是最后2句

    // 闭包的调用
    processCatlist(hi->catlist(&count)); 
    processCatlist(hi->catlist2(&count));

类似以调用block(实际上是调用闭包), &count这个参数是传进去的。执行顺序也是先 processCatlist(hi->catlist(&count));再执行processCatlist里面的操作。emmm......话说苹果为何单写一个方法分出去 ( -_- ! )

接着看下闭包内部

• 现有category_t。
  category_t

关于category_t, 也可以通过Clang命令转成cpp文件查看底部实际执行

clang -rewrite-objc 分类.m

cpp

可看到包含:

• 名字
• 所属类
• 实例方法列表
• 类方法列表
• 协议
• 属性(无set, get 方法)

分类实例方法 实例/类方法

因为我添加了3个实例方法1个类方法, 看底层也能看出分类没有元类那套概念。关于属性, 我们新增一个属性看下。

分类属性 分类属性

可看出虽然写了属性, 但是系统并不会自动创建set, get方法。所以想给分类添加属性还得靠关联对象方式。

• 关于processCatlist和header_info数据结构
  

  processCatlist数据结构

• 关于cat数据结构
  

  cat数据结构

其实load_categories_nolock主要做了

• 定义一个闭包的分类列表processCatlist
• 外层调用, mach-o中取数据, 按照 规定 处理好的分类信息加进processCatlist

那么是怎样个规定 添加的, 继续跟断点走到attachCategories

attachCategories

attachCategories

进入attachCategories

attachCategories

// Attach method lists and properties and protocols from categories to a class.
// Assumes the categories in cats are all loaded and sorted by load order, 
// oldest categories first.

// 将分类方法列表/属性/协议搬到类中.
// 假设分类在cats中, 都是按加载顺序加载和排序的，旧分类优先

static void
attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,
                 int flags)
{    
...

    /*
     * Only a few classes have more than 64 categories during launch.
     * This uses a little stack, and avoids malloc.
     *
     * Categories must be added in the proper order, which is back
     * to front. To do that with the chunking, we iterate cats_list
     * from front to back, build up the local buffers backwards,
     * and call attachLists on the chunks. attachLists prepends the
     * lists, so the final result is in the expected order.
     
     * 只有少数分类在发布期间超过64个类别。
     * 这使用栈，避免了malloc。
     * 分类必须按从后到前的正确顺序添加。
     * 为了实现拆分，我们从前到后迭代cats_list，向后构建本地缓冲区，并调用块上的attachLists。
     * attachLists 方法预先列出了list，最终结果按预期顺序排列。
     */
    constexpr uint32_t ATTACH_BUFSIZ = 64;
    method_list_t   *mlists[ATTACH_BUFSIZ];
    property_list_t *proplists[ATTACH_BUFSIZ];
    protocol_list_t *protolists[ATTACH_BUFSIZ];

    uint32_t mcount = 0;
    uint32_t propcount = 0;
    uint32_t protocount = 0;
    bool fromBundle = NO;
    bool isMeta = (flags & ATTACH_METACLASS);
    auto rwe = cls->data()->extAllocIfNeeded();

    for (uint32_t i = 0; i < cats_count; i++) {
        auto& entry = cats_list[I];

        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {

            // 判断有没有超出最大64
            // constexpr uint32_t ATTACH_BUFSIZ = 64;
            if (mcount == ATTACH_BUFSIZ) {
                prepareMethodLists(cls, mlists, mcount, NO, fromBundle, __func__);
                rwe->methods.attachLists(mlists, mcount);
                mcount = 0;
            }
            mlists[ATTACH_BUFSIZ - ++mcount] = mlist;
            fromBundle |= entry.hi->isBundle();
        }

        property_list_t *proplist =
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            if (propcount == ATTACH_BUFSIZ) {
                rwe->properties.attachLists(proplists, propcount);
                propcount = 0;
            }
            proplists[ATTACH_BUFSIZ - ++propcount] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta);
        if (protolist) {
            if (protocount == ATTACH_BUFSIZ) {
                rwe->protocols.attachLists(protolists, protocount);
                protocount = 0;
            }
            protolists[ATTACH_BUFSIZ - ++protocount] = protolist;
        }
    }

    if (mcount > 0) {
        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount,
                           NO, fromBundle, __func__);
        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
       ...
    }

    rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);

    rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);
}

• cls中获取rwe, auto rwe = cls->data()->extAllocIfNeeded();
• rwe将分类 方法 / 属性 / 协议 添加进主类方法中

拿方法列表举例跟一遍流程:

mlist

• 初始uint32_t mcount = 0;, constexpr uint32_t ATTACH_BUFSIZ = 64;
• 循环取method_list_t, 留意下是个*即地址
• 插入mlists, mlists[ATTACH_BUFSIZ - ++mcount] = mlist;. 首次 mlists[64 - (0 + 1)] = mlists[63] = mlist

验证一下

验证 验证

mlist是我们分类列表, 里面3个方法, 地址: 0x0000000100008028, 看下赋值之后mlists最后一个mlist[63]也为0x0000000100008028

image.png

extAllocIfNeeded

关于取rwe方法 auto rwe = cls->data()->extAllocIfNeeded(); 看一下

    class_rw_ext_t *extAllocIfNeeded() {
        auto v = get_ro_or_rwe();
        if (fastpath(v.is<class_rw_ext_t *>())) {
            return v.get<class_rw_ext_t *>(&ro_or_rw_ext);
        } else {
            return extAlloc(v.get<const class_ro_t *>(&ro_or_rw_ext));
        }
    }

class_rw_ext_t *
class_rw_t::extAlloc(const class_ro_t *ro, bool deepCopy)
{
    runtimeLock.assertLocked();
    // 开辟内存空间, 底层还是alloc
    auto rwe = objc::zalloc<class_rw_ext_t>();
    // 设置版本 元类-7, 非元类-0
    rwe->version = (ro->flags & RO_META) ? 7 : 0;
    // 获取ro方法列表
    method_list_t *list = ro->baseMethods;
    if (list) {
        if (deepCopy) list = list->duplicate();
        // 将ro的方法列表放入rwe中。
        rwe->methods.attachLists(&list, 1);
    }

    // 获取属性
    property_list_t *proplist = ro->baseProperties;
    if (proplist) {
        rwe->properties.attachLists(&proplist, 1);
    }

   // 获取协议
    protocol_list_t *protolist = ro->baseProtocols;
    if (protolist) {
        rwe->protocols.attachLists(&protolist, 1);
    }
     //设置rwe, rwe->ro = ro;
    set_ro_or_rwe(rwe, ro);
    return rwe;
}

    void set_ro_or_rwe(class_rw_ext_t *rwe, const class_ro_t *ro) {
        // the release barrier is so that the class_rw_ext_t::ro initialization
        // is visible to lockless readers
        rwe->ro = ro;
        ro_or_rw_ext_t{rwe, &ro_or_rw_ext}.storeAt(ro_or_rw_ext, memory_order_release);
    }

• 通过zalloc创建rwe。但是实际还是调用alloc创建内存空间

template<class T>
T *zalloc()
{
    return Zone<T, sizeof(T) % MALLOC_ALIGNMENT == 0>::alloc();
}

• rwe获取方法/属性/协议列表
• 设置rwe, 令 rwe->ro = ro;

接着往下走, 走到prepareMethodLists和rwe赋值地方, 其中mlists + ATTACH_BUFSIZ - mcount实际上是内存地址平移, mlists + 64 - 1 = 首地址 + 63 平移即新添加的mslit的指针的地址(指针的指针) 进入下一个关键方法attachLists

attachLists

    void attachLists(List* const * addedLists, uint32_t addedCount) {
        
        // 没有新增直接返回,
        // 话说addedCount = 0 无需新增, 之前直接不调用不就好了么 :)
        if (addedCount == 0) return;

        if (hasArray()) {
            // many lists -> many lists
            
            // 定义一些初始值
            uint32_t oldCount = array()->count;
            uint32_t newCount = oldCount + addedCount;
            array_t *newArray = (array_t *)malloc(array_t::byteSize(newCount));
            newArray->count = newCount;
            array()->count = newCount;

            // 将旧的数组插入新的数组中。
            // 从留意下: i 初始: oldCount - 1 从后往前插入
            for (int i = oldCount - 1; i >= 0; I--)
                newArray->lists[i + addedCount] = array()->lists[I];
            
            // 新数组插在旧数组前面
            // 从前往后插入 addedLists
            for (unsigned i = 0; i < addedCount; I++)
                newArray->lists[i] = addedLists[I];
            
            // 释放旧数组, 设置新数组
            free(array());
            setArray(newArray);
            validate();
        }
        else if (!list  &&  addedCount == 1) {
            // 本类没有方法的时候走这个逻辑
            // 0 lists -> 1 list
            list = addedLists[0];
            validate();
        } 
        else {
            
            
            // 1 list -> many lists
            Ptr<List> oldList = list;
            uint32_t oldCount = oldList ? 1 : 0;
            uint32_t newCount = oldCount + addedCount;
            // 开辟新内存空间, 设置数组
            setArray((array_t *)malloc(array_t::byteSize(newCount)));
            array()->count = newCount;
            // 如果oldList存在，array[endIndex] 最后一个元素为 oldList指针。
            if (oldList) array()->lists[addedCount] = oldList;
            // 循环将新加入的放到list前面。从前往后一个一个放。留意下这里都是指针。
            for (unsigned i = 0; i < addedCount; I++)
                array()->lists[i] = addedLists[I];
            validate();
        }
    }

留意下 addedLists 实际操作的指针, 是**这样一个结构, 看图

例子

addedLists实际插入的是list的指针, 如果这个时候又有新的addedLists插入, 则有

addedLists

综上, 主类与分类都有+load 分类加载情况执行:

• load_images → loadAllCategories → load_categories_nolock → attachCategories

分类有 +load方法, 当前类无

主类有 +load方法, 分类无

这个2中情况是一样的

map_images → _read_images → realizeClassWithoutSwift
分类已在data()中完成加载。首先, 这2种情况, 主类类都变成了非懒加载类()

• 主类有 +load 方法, 分类无 : 变懒加载
• 分类有 +load 方法, 主类无 : 分类变懒加载, 主类同时也变懒加载

验证一下

验证 打印 主类 分类

realizeClassWithoutSwift方法读取下ro (留意下要ro赋值完成), 读取其方法列表之后我们能发现, 分类在realizeClassWithoutSwift之前已经有了, 系统编译时在data()中早已完成处理 (mach-o中就已处理好 )。

主分类两者皆无

类alloc → objc_alloc → lookupimpOrForward → realizeClassWithoutSwift → methodizeClass
推迟到主类alloc之后, 第一次消息发送时候进行, 数据已经在data()中(mach -o已经给处理好了)。验证一下

验证

多分类情况都有+load

• 主类实现 +load:
  • 1个分类含有 +load : load_images → loadAllCategories → load_categories_nolock → attachCategories (map_images链正常走)

举例验证一下:

4个分类
顺序
建立4个分类, 其中主类和SRTestCategoryC加了 +load, 顺序最好也留意一下, 运行: realizeClassWithoutSwift
realizeClassWithoutSwift

首先在realizeClassWithoutSwift中 ro中读取下信息发现, 说明data()中没处理分类

load_categories_nolock load_categories_nolock

在load_image链可以发现处理了, 在load_categories_nolock中打印cat信息, 可以发现有分类信息, 接下来会走attachCategories去处理添加分类。但是留意下会发现, 为什么没有+load的分类SRTestCategoryC呢? 继续运行

load_categories_nolock

可发现, 在第二次循环中才处理SRTestCategoryC相关。 就你叫夏洛啊(就你有+load), 好, 单独处理处理你。之后继续走attachCategories。有类方法的话类方法的attachCategories也走。

• 主类实现 +load:

  • 多个分类含有 +load : load_images → loadAllCategories → load_categories_nolock → attachCategories (map_images正常走)

举例验证一下:

4个分类
顺序
建立4个分类, 其中主类和SRTestCategoryA, SRTestCategoryC加了 +load, 顺序最好也留意一下, 运行: 验证 验证

跟单个加分类类似, 加载分类在load_images链, processCatlist中循环添加, 先处理所有不含+load分类, 在依次处理+load分类

• 主类不实现 +load:

  • 分类1个含有 +load : map_images → _read_images → realizeClassWithoutSwift 跟之前类似mach-o系统已经处理, 存在data()中。

验证, 读的 realizeClassWithoutSwift 中 ro

• 多个分类含有 +load : load_images → loadAllCategories → load_categories_nolock → objc::unattachedCategories.addForClass (map_images不正常走)

主类实现链: map_images → _read_images → load_images → prepare_load_methods → prepare_load_methods →
realizeClassWithoutSwift → methodizeClass

懒加载添加 addForClass

跟主类实现链路类似, 最后分类走懒加载方法objc::unattachedCategories.addForClass

但是留意下, 此时主类链会在map_images → _read_images → load_images → prepare_load_methods → prepare_load_methods →
realizeClassWithoutSwift → methodizeClass

map链路区别 map链路区别 map链路区别

读一下realizeClassWithoutSwift中的ro, 可发现只有主类相关, 没有分类

总结

分类加载链路情况:

• 主类实现+load:

  • 没有分类实现 : map_images → _read_images → realizeClassWithoutSwift

  • 一个分类实现 : load_images → loadAllCategories → load_categories_nolock → attachCategories

  • 多个分类实现 : load_images → loadAllCategories → load_categories_nolock → attachCategories
    

• 主类不实现+load:

  • 没有分类实现 : 类alloc → objc_alloc → lookupimpOrForward → realizeClassWithoutSwift → methodizeClass

  • 一个分类实现 : +load : map_images → _read_images → realizeClassWithoutSwift

  • 多个分类实现 : load_images → loadAllCategories → load_categories_nolock → objc::unattachedCategories.addForClass

示意图

分类存放情况:

• 主类实现+load:
  • 没有分类实现 : ro, rwe
  • 一个分类实现 : rwe, ro无
  • 多个分类实现 : rwe, ro无
• 主类不实现+load:
  • 没有分类实现 : ro, rwe
  • 一个分类实现 : ro, rwe
  • 多个分类实现 : rwe, ro无