OC底层原理15-dyld加载流程

前言

在开发中，我们做的很多事情都是main函数之后的，那main之前Xcode为我们做了哪些事呢？

当我们用Xcode连接真机或者模拟器运行应用程序的的时候，都会有一个生成可执行文件的过程，称之为编译流程,如下图:

编译流程.jpg

我们这里只做简单介绍，由于内容过多，就不展开了，有兴趣请自行查阅资料，或购买书《程序员的自我修养：链接、装载与库》

1. 预编译：Xcode会将我们写的.m .h等文件拿到，处理预编译指令，比如：删除#define并展开宏定义，将#include包含的文件插入到该指令位置等
2. 编译：对预编译处理过的文件进行词法分析、语法分析、语义分析，并进行源代码优化，生成汇编代码
3. 汇编：通过汇编器将汇编代码转为机器可以执行的指令，并生成目标.o文件
4. 链接：将动态库（.so、.lib、.framework），静态库（.a、. framework）和所有目标文件进行链接，生成可执行文件

一、dyld的定义

dyld：全称the dynamic loader，动态加载器，是苹果操作系统的重要组成部分，在应用程序被编译打包成可执行文件后，交由dyld负责链接，加载程序

dyld源码

该定义来自官方文档

二、dyld的作用

加载应用程序的可执行文件，并检查可执行文件中的Mach加载命令，以查找应用程序所需的框架和动态库。然后，它将每个框架加载到内存中，并解析可执行文件中的动态符号，以指向动态库中的适当地址。

App启动流程：

App启动流程.jpg

三、dyld加载流程

3.1 定位入口函数_dyld_start

image.png

• 添加类GomuPerson
• 实现类方法load，并打下断点
• 运行项目拿到堆栈信息：
  1. 从左边堆栈栏中看堆栈信息
  2. 在lldb中用bt命令打印堆栈信息
• 定位到入口函数_dyld_start，并获取到_dyld_start位于dyld库
• 官网下载源码：dyld750.6

3.2 _dyld_start源码介绍

由于源码会根据架构不同，有不同的现实，这里以arm64为例

image.png

• 找到汇编入口：__dyld_start:
• 汇编看不懂就看后面的注释
• __dyld_start:会执行到红框处，调用dyldbootstrap命名空间里面的start方法

3.2.1 dyldbootstrap源码和其中的start源码介绍

由于代码量过大，请自行查询，这里只介绍主要的一些方法

namespace dyldbootstrap {
//: -- 定义别名Initializer
typedef void (*Initializer)(int argc, const char* argv[], const char* envp[], const char* apple[]);

//: -- 调用dyld的初始化方法
static void runDyldInitializers(int argc, const char* argv[], const char* envp[], const char* apple[])
{
    for (const Initializer* p = &inits_start; p < &inits_end; ++p) {
        (*p)(argc, argv, envp, apple);
    }
}
#endif // DYLD_INITIALIZER_SUPPORT


//: -- 给dyld的数据段关联指针
static void rebaseDyld(const dyld3::MachOLoaded* dyldMH)
{
    ......
}

//: -- dyld的引导方法
uintptr_t start(const dyld3::MachOLoaded* appsMachHeader, int argc, const char* argv[],
                const dyld3::MachOLoaded* dyldsMachHeader, uintptr_t* startGlue)
{
//: -- 发送一个kdebug追踪点表面dyld已经开始引导
    dyld3::kdebug_trace_dyld_marker(DBG_DYLD_TIMING_BOOTSTRAP_START, 0, 0, 0, 0);

//: -- 查询设定dyld，dyld滑动之后，必须重新设定
    rebaseDyld(dyldsMachHeader);

//: -- 将env指针设置为刚好超出agv数组的末尾
    const char** envp = &argv[argc+1];
    
//: -- 将envp指针设置为刚好超出agv数组的末尾
    const char** apple = envp;
    while(*apple != NULL) { ++apple; }
    ++apple;

//: -- 为堆栈设置随机值
    __guard_setup(apple);

#if DYLD_INITIALIZER_SUPPORT
//: -- 在dyld中运行所有C ++ initializers
    runDyldInitializers(argc, argv, envp, apple);
#endif
//: -- 调用dyld::_main
    uintptr_t appsSlide = appsMachHeader->getSlide();
    return dyld::_main((macho_header*)appsMachHeader, appsSlide, argc, argv, envp, apple, startGlue);
}


#if TARGET_OS_SIMULATOR
//: -- 模拟器会多调用一次start_sim
uintptr_t start_sim(int argc, const char* argv[], const char* envp[], const char* apple[],
                    const dyld3::MachOLoaded* mainExecutableMH, const dyld3::MachOLoaded* dyldSimMH, uintptr_t dyldSlide,
                    const dyld::SyscallHelpers* sc, uintptr_t* startGlue)
{
    ......
}
#endif
} // end of namespace

• 源码分析得出下一个流程dyld::_main调用

3.3 dyld::_main源码介绍

由于dyld::_main源量太大，但又极为重要，所以我们分步说明主要流程

3.3.1 配置环境变量

//: -- 给imageLoader设置平台id
if (gProcessInfo->version >= 16){...}

//: -- 检测并设置环境变量
checkEnvironmentVariables(envp);

//: -- 如果没有设置环境变量，则为DYLD_FALLBACK_FRAMEWORK_PATH赋默认值
defaultUninitializedFallbackPaths(envp);
....
//: -- 获取CPU架构
getHostInfo(mainExecutableMH, mainExecutableSlide);

3.3.2 共享缓存

//: -- 如果主可执行文件的区域与共享区域重叠，则禁用共享区域
//: -- iOS无法在没有共享区域的情况下运行
checkSharedRegionDisable((dyld3::MachOLoaded*)mainExecutableMH, mainExecutableSlide);
    if ( gLinkContext.sharedRegionMode != ImageLoader::kDontUseSharedRegion ) {
#if TARGET_OS_SIMULATOR
//: -- 判断共享缓存是否映射到了共享区域
    if ( sSharedCacheOverrideDir)
//: -- 共享缓存
            mapSharedCache();
#else
//: -- 共享缓存
    mapSharedCache();
#endif

3.3.3 主程序初始化

//: -- 主程序赋值，给主程序初始化ImageLoader
sMainExecutable = instantiateFromLoadedImage(mainExecutableMH, mainExecutableSlide, sExecPath);

• 给主程序变量sMainExecutable赋值了一个ImageLoaderMachO类型的对象

3.3.3.1 instantiateFromLoadedImage源码介绍

static ImageLoaderMachO* instantiateFromLoadedImage(const macho_header* mh, uintptr_t slide, const char* path)
{
    // try mach-o loader
    if ( isCompatibleMachO((const uint8_t*)mh, path) ) {
//: -- 实例化对象image接收实例主程序
        ImageLoader* image = ImageLoaderMachO::instantiateMainExecutable(mh, slide, path, gLinkContext);
//: -- 添加到sAllImages里面
        addImage(image);
        return (ImageLoaderMachO*)image;
    }
//: -- 抛出异常
    throw "main executable not a known format";
}

• 通过instantiateMainExecutable方法创建一个ImageLoader的实例化对象，然后添加到sAllImages中

3.3.3.2 instantiateMainExecutable源码介绍

ImageLoader* ImageLoaderMachO::instantiateMainExecutable(const macho_header* mh, uintptr_t slide, const char* path, const LinkContext& context)
{
    bool compressed;
    unsigned int segCount;
    unsigned int libCount;
    const linkedit_data_command* codeSigCmd;
    const encryption_info_command* encryptCmd;

//: -- 获取`Mach-O`类型文件的`Load Command`的相关信息，赋值给`compressed `等对象
    sniffLoadCommands(mh, path, false, &compressed, &segCount, &libCount, context, &codeSigCmd, &encryptCmd);
    // instantiate concrete class based on content of load commands
    if ( compressed ) 
//: -- 返回压缩过的Mach-O子类
        return ImageLoaderMachOCompressed::instantiateMainExecutable(mh, slide, path, segCount, libCount, context);
    else
#if SUPPORT_CLASSIC_MACHO
//: -- 返回普通的Mach-O子类
        return ImageLoaderMachOClassic::instantiateMainExecutable(mh, slide, path, segCount, libCount, context);
#else
        throw "missing LC_DYLD_INFO load command";
#endif
}

• 为主可执行文件创建映像，返回一个ImageLoader对象

3.3.4 插入动态库

//: -- 插入动态库
//: -- 加载所以DYLD_INSERT_LIBRARIES类型的库
if  ( sEnv.DYLD_INSERT_LIBRARIES != NULL ) {
    for (const char* const* lib = sEnv.DYLD_INSERT_LIBRARIES; *lib != NULL; ++lib) 
    loadInsertedDylib(*lib);
}

3.3.5 链接主程序

link(sMainExecutable, sEnv.DYLD_BIND_AT_LAUNCH, true, ImageLoader::RPathChain(NULL, NULL), -1);

3.3.6 链接动态库

//: -- 链接所有插入的动态库
//: -- 链接主可执行文件后执行此操作，这样插入dylib（例如libSystem），将不会在程序使用的dylib之前
if ( sInsertedDylibCount > 0 ) {
    for(unsigned int i=0; i < sInsertedDylibCount; ++i) {
        ImageLoader* image = sAllImages[i+1];
        link(image, sEnv.DYLD_BIND_AT_LAUNCH, true, ImageLoader::RPathChain(NULL, NULL), -1);
        image->setNeverUnloadRecursive();
    }
    if ( gLinkContext.allowInterposing ) {

//: -- 只有被表示 INSERTED 的库才能插入
//: -- 绑定所有插入的库后再注册插入信息，是为了链接
        for(unsigned int i=0; i < sInsertedDylibCount; ++i) {
            ImageLoader* image = sAllImages[i+1];

//: -- 注册插入的image
            image->registerInterposing(gLinkContext);
        }
    }
}

3.3.7 弱符号绑定

//: -- 通知插入的的Image已经被绑定
if ( sInsertedDylibCount > 0 ) {
    for(unsigned int i=0; i < sInsertedDylibCount; ++i) {
        ImageLoader* image = sAllImages[i+1];
        image->recursiveBind(gLinkContext, sEnv.DYLD_BIND_AT_LAUNCH, true);
    }
}

3.3.8 执行初始化方法

//: -- 执行所以初始化程序
initializeMainExecutable(); 

3.3.8.1 initializeMainExecutable源码介绍

void initializeMainExecutable()
{
//: -- 状态变量，记录已经进入这里
    gLinkContext.startedInitializingMainExecutable = true;

//: -- 运行所有的插入的dylib的initializers方法
    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]);
        }
    }
    
//: -- 运行主要可执行文件以及他附带的一切的初始化方法 
    sMainExecutable->runInitializers(gLinkContext, initializerTimes[0]);
//: -- 当此进程退出时，调用cxa_atexit（）处理程序所有image加载的的静态终止符
    if ( gLibSystemHelpers != NULL ) 
        (*gLibSystemHelpers->cxa_atexit)(&runAllStaticTerminators, NULL, NULL);

    // dump info if requested
    if ( sEnv.DYLD_PRINT_STATISTICS )
        ImageLoader::printStatistics((unsigned int)allImagesCount(), initializerTimes[0]);
    if ( sEnv.DYLD_PRINT_STATISTICS_DETAILS )
        ImageLoaderMachO::printStatisticsDetails((unsigned int)allImagesCount(), initializerTimes[0]);
}

• 进入initializeMainExecutable方法后，循环遍历，为每一个插入的dylib执行initializers方法

3.3.8.2 runInitializers源码介绍

void ImageLoader::runInitializers(const LinkContext& context, InitializerTimingList& timingInfo)
{
    uint64_t t1 = mach_absolute_time();
    mach_port_t thisThread = mach_thread_self();
    ImageLoader::UninitedUpwards up;
    up.count = 1;
    up.imagesAndPaths[0] = { this, this->getPath() };
    processInitializers(context, thisThread, timingInfo, up);
    context.notifyBatch(dyld_image_state_initialized, false);
    mach_port_deallocate(mach_task_self(), thisThread);
    uint64_t t2 = mach_absolute_time();
    fgTotalInitTime += (t2 - t1);
}

• 调用runInitializers后，主要调用processInitializers方法

3.3.8.3 processInitializers源码介绍

void ImageLoader::processInitializers(const LinkContext& context, mach_port_t thisThread,
                                     InitializerTimingList& timingInfo, ImageLoader::UninitedUpwards& images)
{
    uint32_t maxImageCount = context.imageCount()+2;
    ImageLoader::UninitedUpwards upsBuffer[maxImageCount];
    ImageLoader::UninitedUpwards& ups = upsBuffer[0];
    ups.count = 0;

//: -- 在所有images类表中，递归调用init，构建未初始化的向上依赖关系新列表
    for (uintptr_t i=0; i < images.count; ++i) {
        images.imagesAndPaths[i].first->recursiveInitialization(context, thisThread, images.imagesAndPaths[i].second, timingInfo, ups);
    }
//: -- 如果还有向上依赖的，init他们
    if ( ups.count > 0 )
        processInitializers(context, thisThread, timingInfo, ups);
}
- `processInitializers `函数中，主要是对镜像列表调用`recursiveInitialization `函数进行递归实例化

3.3.8.4 recursiveInitialization源码介绍

void ImageLoader::recursiveInitialization(const LinkContext& context, mach_port_t this_thread, const char* pathToInitialize,
                                          InitializerTimingList& timingInfo, UninitedUpwards& uninitUps)
{
...
//: -- 关键代码
//: -- 通知objc，我们将要初始化此镜像
      context.notifySingle(dyld_image_state_dependents_initialized, this, &timingInfo);
            
//: -- 初始化镜像
      bool hasInitializers = this->doInitialization(context);

//: -- 通知所有的关联库，我们已完成此镜像的初始化      
      context.notifySingle(dyld_image_state_initialized, this, NULL);
...
}

• 初始化镜像之前，我们需要调用notifySingle，通知objc我们即将初始化这个镜像，猜想会在objc中有回调方法，需要在初始化之前执行
• 初始化镜像，调用doInitialization
• 通知所有的关联库，我们已完成此镜像的初始化

3.3.8.5 notifySingle源码介绍

static void notifySingle(dyld_image_states state, const ImageLoader* image, ImageLoader::InitializerTimingList* timingInfo)
{
...
//: -- 关键代码
(*sNotifyObjCInit)(image->getRealPath(), image->machHeader());
...
}

• sNotifyObjCInit没有源码实现，只有一个赋值操作
  
  image.png
• registerObjCNotifiers会在_dyld_objc_notify_register中调用
  
  image.png
• 但是_dyld_objc_notify_register并没有在dyld库被调用，它在objc库中的_objc_init中被调用

3.3.8.6 _objc_init源码介绍

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调用
    _dyld_objc_notify_register(&map_images, load_images, unmap_image);

#if __OBJC2__
    didCallDyldNotifyRegister = true;
#endif
}

• 我们确实在_objc_init中找到了_dyld_objc_notify_register函数的调用
• _objc_init位于objc， objc源码 自行下载
• _objc_init函数中，对_dyld_objc_notify_register函数进行了赋值，那我们可以判断出sNotifyObjCInit的值就是_dyld_objc_notify_register函数传值的load_images，所以notifySingle是一个回调函数

3.3.8.7 load函数加载流程

• 流程比较简单，请自行查找
• 在objc源码中，我们从load_images -> call_load_methods -> call_class_loads -> (*load_method)(cls, @selector(load))
• 在_objc_init中，在类的加载过程中，的确调用了load方法
• 那么_objc_init又在什么时候调用的呢，进入刚刚预留的一个函数doInitialization中

3.3.8.8 doInitialization源码介绍

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

    // mach-o has -init and static initializers
//: -- 初始化Image
    doImageInit(context);
//: -- 初始化C++函数
    doModInitFunctions(context);
    
    CRSetCrashLogMessage2(NULL);
    
    return (fHasDashInit || fHasInitializers);
}

• 进入doInitialization源码后，找到了Image和C++函数的初始化方法
• 进入doImageInit,doModInitFunctions源码

3.3.8.9 doImageInit源码介绍（doModInitFunctions源码类似，这里就不过多赘述）

image.png

• 进入doImageInit后，是一个递归调用初始化image
• 这里依然没有找到_objc_init的调用，已经走到路的尽头
• 注意红框处，有一个加了注释的条件，libSystem initializer must run first，必须先加载系统库，柳暗花明又一村
• 那我们猜想，_objc_init的调用是否在libSystem库中呢
• 去苹果开源库中搜索发现，libSystem没有开源，那怎么办？跳到3.4 _objc_init调用流程查找

3.3.9 寻找主程序入口（main函数）

//: -- 寻找主程序入口
result = (uintptr_t)sMainExecutable->getEntryFromLC_MAIN();
if ( result != 0 ) {
//: -- 主程序使用 LC_MAIN, 我们需要在libdyld中使用helper来调用main（）
    if ( (gLibSystemHelpers != NULL) && (gLibSystemHelpers->version >= 9) )
        *startGlue = (uintptr_t)gLibSystemHelpers->startGlueToCallExit;
    else
        halt("libdyld.dylib support not present for LC_MAIN");
}
else {
//: -- 主可执行文件使用LC_UNIXTHREAD，dyld需要在为main（）设置的程序中让“启动”
    result = (uintptr_t)sMainExecutable->getEntryFromLC_UNIXTHREAD();
    *startGlue = 0;
//: -- 通知进入主函数
    notifyMonitoringDyldMain()
}

• 从Load Command读取LC_MAIN入口，如果没有，就读取LC_UNIXTHREAD，这样就来到了日常开发中熟悉的main函数了

• 回到汇编也可以看到注释call main()，如下图红框

  
  
  image.png
• 注意：main是写定的函数，写入内存，读取到dyld，如果修改了main函数的名称，会报错

3.4 _objc_init调用流程

libSystem没有开源，那怎么办？既然是探究的_objc_init，那我们索性就下个_objc_init的符号断点，一探究竟

image.png

• 经过符号断点发现，libSystem会调用libdispatch库中的libdispatch_init
• 下载libdispatch源码

3.4.1 libdispatch_init源码查看

libdispatch_init(void)
{
...省略无关代码
    _os_object_init();
...
}

• libdispatch_init中调用了_os_object_init()

3.4.2 _os_object_init源码查看

image.png

• _os_object_init中调用了_objc_init，形成了闭环

四、总结

dyld 流程总结：

_dyld_start -> dyldbootstrap::start -> dyld::_main -> dyld::initializeMainExecutable -> ImageLoader::runInitializers -> ImageLoader::processInitializers -> ImageLoader::recursiveInitialization -> doInitialization -> libSystem_initializer（libSystem.B.dylib） -> libdispatch_init（libdispatch.dylib） -> _os_object_init（libdispatch.dylib） -> _objc_init(libobjc.A.dylib)

dyld流程图：

dyld加载流程.jpg

五、拓展知识

静态库和动态库

库：是资源文件和代码编译的集合

静态库：在编译时，完整的拷贝至可执行文件中，被多次使用就有多次冗余拷贝

动态库：程序运行时由系统动态加载到内存，而不是复制，供程序调用。系统只加载一次，多个程序共用，节省内存。因此，编译内容更小，而且因为动态库是需要时才被引用，所以更快。

动态库静态库对比：

动态库静态库对比.png

• 系统的库基本上都是动态库
• 使用场景：如果你有很多文件，静态库的多个副本意味着可执行文件的大小增加，那就建议使用动态库，可以节省时间。如果执行时间的好处超过节省空间的需要，那么静态库就是最佳选择。