iOS dyld加载流程

dyld加载的详细流程可以参考文章 iOS dyld加载流程
本章用以分析dyld加载过程中关键函数_dyld_objc_notify_register、main、constructor等函数的调用逻辑
dyld源码

一、dyld加载流程以及main函数的调用

1. _dyld_start
   1.1 dyldbootstrap::start
   1.2 dyld::_main
   1.3 instantiateFromLoadedImage 实例化主程序image
   1.4 loadInsertedDylib 加载动态库
   1.5 link 主程序
   1.6 循环递归link动态库
   1.7 initializeMainExecutable 初始化image
   1.8 sMainExecutable->getEntryFromLC_MAIN 获取主程序main函数并返回
2. _dyld_start 执行main函数

二、Image的初始化以及Objc中的_objc_init 和 attribute((constructor))的调用逻辑

在dyld加载流程中，且在main函数调用之前会先初始化所有加载进来的Image

void initializeMainExecutable()
{
    // 1. run initialzers for any inserted dylibs
    ImageLoader::InitializerTimingList initializerTimes[allImagesCount()];
    initializerTimes[0].count = 0;
    const size_t rootCount = sImageRoots.size();
    if ( rootCount > 1 ) {
        for(size_t i=1; i < rootCount; ++i) {
            sImageRoots[i]->runInitializers(gLinkContext, initializerTimes[0]);
        }
    }
    
    // 2. run initializers for main executable and everything it brings up 
    sMainExecutable->runInitializers(gLinkContext, initializerTimes[0]);
}

1. run initialzers for any inserted dylibs 初始化所有image
2. run initializers for main executable and everything it brings up 初始化主程序

runInitializers 函数调用过程

1. runInitializers
2. processInitializers

void ImageLoader::processInitializers(const LinkContext& context, mach_port_t thisThread,
                                     InitializerTimingList& timingInfo, ImageLoader::UninitedUpwards& images)
{
    ...
    // Calling recursive init on all images in images list, building a new list of
    // uninitialized upward dependencies.
    for (uintptr_t i=0; i < images.count; ++i) {
        images.imagesAndPaths[i].first->recursiveInitialization(context, thisThread, images.imagesAndPaths[i].second, timingInfo, ups);
    }

}

在processInitializers中，循环对所有image执行了recursiveInitialization函数

void ImageLoader::recursiveInitialization(const LinkContext& context, mach_port_t this_thread, const char* pathToInitialize,
                                          InitializerTimingList& timingInfo, UninitedUpwards& uninitUps)
{
  // 1. let objc know we are about to initialize this image
  uint64_t t1 = mach_absolute_time();
  fState = dyld_image_state_dependents_initialized;
  oldState = fState;
  context.notifySingle(dyld_image_state_dependents_initialized, this, &timingInfo);
  // 2.  initialize this image
  bool hasInitializers = this->doInitialization(context);
  // 3. let anyone know we finished initializing this image
  fState = dyld_image_state_initialized;
  oldState = fState;
  context.notifySingle(dyld_image_state_initialized, this, NULL);
}

1. let objc know we are about to initialize this image 通知objc将要初始化这个image
2. initialize this image 初始化image
3. let anyone know we finished initializing this image 通知所有监听者这个image已经初始化完成
   这里是触发Objc回调load_images的地方，具体请看第三节的分析

doInitialization 函数调用过程

bool ImageLoaderMachO::doInitialization(const LinkContext& context)
{
    CRSetCrashLogMessage2(this->getPath());

    // mach-o has -init and static initializers
    doImageInit(context);
    doModInitFunctions(context);
    
    CRSetCrashLogMessage2(NULL);
    
    return (fHasDashInit || fHasInitializers);
}

这里面有两个关键的函数

1. doImageInit
   image.png

当链接器加入-init选项时，LC_ROUTINES就会被加入到LoadCommands中，描述该dylib的入口。
遍历所有LoadCommands，通过LC_ROUTINES_COMMAND找到入口函数并执行，
通过第 2266 行代码可以得知，系统会保证libSystem最先被初始化

2. doModInitFunctions
   遍历mach-o中所有的segment、section，找到__mod_init_funcs section(存储所有__attribute__((constructor))函数的地方)，遍历执行里面的所有的C++静态方法
   这里也可以通过在__attribute__((constructor))函数的调用栈中来验证
   image.png

我们在Objc源码的_objc_init打上断点，可以看到调用栈为下图：

image.png
可以发现Objc的初始化方法_objc_init也是在这里被触发，并且由libSystem初始化时所调用
由于libSystem是第一个被初始化的库，所以_objc_init会比自定义添加的__attribute__((constructor))函数先被调用

三、_dyld_objc_notify_register调用逻辑

在Objc的初始化函数_objc_init函数中使用了_dyld_objc_notify_register注册了一个回调

void _objc_init(void)
{
    static bool initialized = false;
    if (initialized) return;
    initialized = true;
    
    // fixme defer initialization until an objc-using image is found?
    environ_init();
    tls_init();
    static_init();
    runtime_init();
    exception_init();
    cache_init();
    _imp_implementationWithBlock_init();

    _dyld_objc_notify_register(&map_images, load_images, unmap_image);
}

了解过Load函数执行过程的都应该知道，Load函数是被load_images这个回调函数所触发的（关于load函数的执行过程可以参考+load 和 +initialize）
而且这里注册的回调函数load_images正是被dyld执行流程中的recursiveInitialization所触发的。

image.png
在recursiveInitialization中，image的初始化前后通过notifySingle发了两个通知

static void notifySingle(dyld_image_states state, const ImageLoader* image, ImageLoader::InitializerTimingList* timingInfo)
{
....
    if ( (state == dyld_image_state_dependents_initialized) && (sNotifyObjCInit != NULL) && image->notifyObjC() ) {
        uint64_t t0 = mach_absolute_time();
        dyld3::ScopedTimer timer(DBG_DYLD_TIMING_OBJC_INIT, (uint64_t)image->machHeader(), 0, 0);
        (*sNotifyObjCInit)(image->getRealPath(), image->machHeader());
        uint64_t t1 = mach_absolute_time();
        uint64_t t2 = mach_absolute_time();
        uint64_t timeInObjC = t1-t0;
        uint64_t emptyTime = (t2-t1)*100;
        if ( (timeInObjC > emptyTime) && (timingInfo != NULL) ) {
            timingInfo->addTime(image->getShortName(), timeInObjC);
        }
    }
}

通过代码可以看到内部调用了sNotifyObjCInit函数

void _dyld_objc_notify_register(_dyld_objc_notify_mapped    mapped,
                                _dyld_objc_notify_init      init,
                                _dyld_objc_notify_unmapped  unmapped)
{
    dyld::registerObjCNotifiers(mapped, init, unmapped);
}

void registerObjCNotifiers(_dyld_objc_notify_mapped mapped, _dyld_objc_notify_init init, _dyld_objc_notify_unmapped unmapped)
{
    // record functions to call
    sNotifyObjCMapped   = mapped;
    sNotifyObjCInit     = init;
    sNotifyObjCUnmapped = unmapped;
....
}

通过源码可以看到sNotifyObjCInit正是在_objc_init中传入的load_images。

image.png
通过load函数的调用栈也可以看到load函数正是被notifySingle函数触发的。