Main函数之前的Load

整个运行时初始化时 _objc_init 注册的回调

dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized, 0/not batch/, &load_images);

每当有新的镜像加载之后,都会执行 load_images 方法进行回调,并传入最新镜像的信息列表 infoList:

那么,什么是镜像?

镜像并不是一个 Objective-C 的代码文件,它应该是一个 target 的编译产物。这里注意了 这里用词 编译产物,理所当然的想到了 动态库,下面的打印镜像的信息,镜像的路径,我们看到了动态库


const char *  load_images(enum dyld_image_states state, uint32_t infoCount,

const struct dyld_image_info infoList[])

{

        bool found;

        // Return without taking locks if there are no +load methods here. 

        found = false;

        for (uint32_t i = 0; i < infoCount; i++) {

     //Quick scan Load     无论是ClassList还是CategoryList,真就返回,停止遍历

              if (hasLoadMethods((const headerType *)infoList[i].imageLoadAddress)) {

                       found = true;

                        break;

                }

            }

           if (!found) return nil;

           recursive_mutex_locker_t lock(loadMethodLock);

            // Discover load methods

{

      rwlock_writer_t lock2(runtimeLock);  

       found = load_images_nolock(state, infoCount, infoList);

}

      //上面完成了添加类及分类到loadable_classes及loadable_categories,然后开始执行方法

             // Call +load methods

            if (found) {

             call_load_methods();

            }

      return nil;

}


bool load_images_nolock(enum dyld_image_states state,uint32_t infoCount,

const struct dyld_image_info infoList[])

{

       bool found = NO;

       uint32_t i;

        i = infoCount;

        while (i--) {

                const headerType *mhdr = (headerType*)infoList[i].imageLoadAddress;

             if (!hasLoadMethods(mhdr)) continue;

//对infoList遍历,如果没有Load方法,继续循环,有就对load 方法的调用进行准备

                 prepare_load_methods(mhdr);

                 found = YES;

       }

       return found;

}



void prepare_load_methods(const headerType *mhdr)

{

      size_t count, i;

      runtimeLock.assertWriting();

      //通过 _getObjc2NonlazyClassList 获取所有的类的列表之后

      classref_t *classlist = _getObjc2NonlazyClassList(mhdr, &count);

// 通过 remapClass 获取类对应的指针,调用 schedule_class_load 递归地安排当前类和没有调用 + load 父类进入列表。

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

          schedule_class_load(remapClass(classlist[i]));

        }

     // 这里,类与其load方法添加到loadable_classes数组

    // 然后添加分类到对应数组

     category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);

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

           category_t *cat = categorylist[i];

           Class cls = remapClass(cat->cls);

            if (!cls) continue;  // category for ignored weak-linked class

             realizeClass(cls);

             assert(cls->ISA()->isRealized());

             add_category_to_loadable_list(cat);实现几乎与 add_class_to_loadable_list 完全相同

       }

// 这里我们完成了向loadable_classes及loadable_categories添加类/分类及其load方法

}



static void schedule_class_load(Class cls)

{

        if (!cls) return;

       assert(cls->isRealized());

       if (cls->data()->flags & RW_LOADED) return; 父类如果已经调用 + load 父类则返回

        schedule_class_load(cls->superclass); //递归,父类

        add_class_to_loadable_list(cls); // 添加将类加入 loadable_classes 集合

         // 通过递归,我们知道父类与其load添加在子类之前。

         cls->setInfo(RW_LOADED);

}



void call_load_methods(void)

{

       static bool loading = NO;

       bool more_categories;

       loadMethodLock.assertLocked();

       if (loading) return;

       loading = YES;

         void *pool = objc_autoreleasePoolPush();

/*

不停调用类的 + load 方法,直到 loadable_classes 为空

调用一次 call_category_loads 加载分类

如果有 loadable_classes 或者更多的分类,继续循环调用 load 方法

*/

         do {

               while (loadable_classes_used > 0) {

                     call_class_loads(); 从 loadable_classes 中取出对应类和方法,执行 load。

                }

                 more_categories = call_category_loads();

         } while (loadable_classes_used > 0  ||  more_categories);

          objc_autoreleasePoolPop(pool); 

         loading = NO;

}



static void call_class_loads(void)

{

       int i;

        struct loadable_class *classes = loadable_classes;

        int used = loadable_classes_used;

        loadable_classes = nil;

        loadable_classes_allocated = 0;

        loadable_classes_used = 0;

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

                 Class cls = classes[i].cls;

                  load_method_t load_method = (load_method_t)classes[i].method;

              if (!cls) continue;

                (*load_method)(cls, SEL_load);  // 调用 +[XXObject load] 方法。

         }

if (classes) free(classes);

}

static bool call_category_loads(void)

{

int i, shift;

bool new_categories_added = NO;

// 1. 获取当前可以加载的分类列表

struct loadable_category *cats = loadable_categories;

int used = loadable_categories_used;

int allocated = loadable_categories_allocated;

loadable_categories = nil;

loadable_categories_allocated = 0;

loadable_categories_used = 0;

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

Category cat = cats[i].cat;

load_method_t load_method = (load_method_t)cats[i].method;

Class cls;

if (!cat) continue;

cls = _category_getClass(cat);

if (cls  &&  cls->isLoadable()) {

// 2. 如果当前类是可加载的 cls  &&  cls->isLoadable() (可能分类的镜像在类的镜像之前加载到运行时,需要判断类是否已经加载到内存中(调用 load 方法)  保证类的Load方法调用在分类之前)

(*load_method)(cls, SEL_load);  // 调用分类的 load 方法

cats[i].cat = nil;

}

}

// 3. 将所有加载过的分类移除 loadable_categories` 列表

将移除cat = nil的元素

shift = 0;

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

if (cats[i].cat) {

cats[i-shift] = cats[i];

} else {

shift++;

}

}

used -= shift;

// 4. 为 `loadable_categories` 重新分配内存,并重新设置它的值

new_categories_added = (loadable_categories_used > 0);

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

if (used == allocated) {

allocated = allocated*2 + 16;

cats = (struct loadable_category *)

realloc(cats, allocated *

sizeof(struct loadable_category));

}

cats[used++] = loadable_categories[i];

}

if (loadable_categories) free(loadable_categories);

if (used) {

loadable_categories = cats;

loadable_categories_used = used;

loadable_categories_allocated = allocated;

} else {

if (cats) free(cats);

loadable_categories = nil;

loadable_categories_used = 0;

loadable_categories_allocated = 0;

}

return new_categories_added;

}

总结

1 当 Objective-C 运行时初始化的时候,会通过 dyld_register_image_state_change_handler 在每次有新的镜像加入运行时的时候,进行回调。

2 执行 load_images 将所有包含 load 方法的文件加入列表 loadable_classes ,然后从这个列表中找到对应的 load 方法的实现,调用 load 方法

这里我们看到,逻辑很简单先添加类到loadable_classes,然后分类添加到loadable_categories

3 添加顺序(schedule_class_load),父类先于子类,类先于分类,而调用时因为数组有序,父类先于子类调用,又因为代码顺序(call_load_methods),类先于分类调用

你可能感兴趣的:(Main函数之前的Load)