前言

我们都知道，每个项目都会有一个入口 main() 函数，是不是应用程序加载时第一个调用的就是 main 函数呢？

创建新工程，在 ViewController 中重写 +load 方法

@interface ViewController ()

@end

@implementation ViewController

+ (void)load {
    NSLog(@"来了：%s", __func__);
}

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
}

@end

在 main 函数中添加 C++ 方法，在 main 函数中打印一行字

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        
        NSLog(@"来了：%s", __func__);
        
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

__attribute__((constructor)) void kcFunc(){
    printf("来了 : %s \n",__func__);
}

运行项目，看它们的调用顺序，结果如下

可以看到，其顺序是 load -> C++方法 -> main，为什么会是这样一个顺序呢？main 函数是入口函数，为什么不是最先执行，main 函数之前是不是还有其他的操作？带着这些疑问，我们开始今天的分析

编译过程

我们知道，App 启动之前是需要先编译的，编译的流程图如下

静态库&动态库

静态库

在链接阶段，会将可汇编生成的目标程序与引用的库一起链接打包到可执行文件当中。此时的静态库就不会在改变了，因为它是编译时被直接拷贝一份，复制到目标程序里的

缺点：由于静态库被多次使用就有多分拷贝，所以会导致目标程序的体积增大，对内存、性能、速度消耗很大

优点：编译完成后直接就可以使用

动态库

程序编译时并不会链接到目标程序中，目标程序只会存储指向动态库的引用，在程序运行时才被载入

缺点：动态载入会带来一部分性能损失，使用动态库也会使得程序依赖于外部环境

优点：共享内存，节约资源（同一份库可以被多个程序使用）；减少打包之后 app 的大小（不需要拷贝至目标程序中，所以不会影响目标程序的体积）；通过更新动态库，达到更新程序（由于运行时才载入的特性，可以随时对库进行替换，而不需要重新编译代码）

dyld 的加载流程

dyld（the dynamic link editor）动态链接器，是苹果操作系统的重要组成部分，在 app 被编译打包成可执行文件格式的 Mach-O 文件后，交由 dyld 负责连接，加载程序，流程图如下

我们在 load 方法前打个断点，通过 bt 查看调用堆栈，观察 dyld 的入口

我们也可以从 Xcode 左边的堆栈信息来找到入口函数

通过运行程序的堆栈可以看到，入口是从 dyld 中的 _dyld_start 开始的，这里我们需要到苹果官方下载 dyld 的源码才能看到具体的流程--dyld 源码下载

_dyld_start

打开下载好的 dyld-750.6 源码，在源码中搜索 _dyld_start 真机使用的是 arm64 架构，我们看到是汇编实现的，通过注释可以看到会调用 dyldbootstrap::start(app_mh, argc, argv, dyld_mh, &startGlue)

在 dyld 源码中搜索 dyldbootstrap 找到命名作用空间，是一个 C++ 方法，在文件中查找 start 方法，源码如下

uintptr_t start(const dyld3::MachOLoaded* appsMachHeader, int argc, const char* argv[],
                const dyld3::MachOLoaded* dyldsMachHeader, uintptr_t* startGlue)
{

    // Emit kdebug tracepoint to indicate dyld bootstrap has started <rdar://46878536>
    dyld3::kdebug_trace_dyld_marker(DBG_DYLD_TIMING_BOOTSTRAP_START, 0, 0, 0, 0);

    // if kernel had to slide dyld, we need to fix up load sensitive locations
    // we have to do this before using any global variables
    rebaseDyld(dyldsMachHeader);

    // kernel sets up env pointer to be just past end of agv array
    const char** envp = &argv[argc+1];
    
    // kernel sets up apple pointer to be just past end of envp array
    const char** apple = envp;
    while(*apple != NULL) { ++apple; }
    ++apple;

    // set up random value for stack canary
    __guard_setup(apple);

#if DYLD_INITIALIZER_SUPPORT
    // run all C++ initializers inside dyld
    runDyldInitializers(argc, argv, envp, apple);
#endif

    // now that we are done bootstrapping dyld, call dyld's main
    uintptr_t appsSlide = appsMachHeader->getSlide();
    return dyld::_main((macho_header*)appsMachHeader, appsSlide, argc, argv, envp, apple, startGlue);
}

主要做了：

1. 使用全局变量前，对 dyld 进行 rebase 操作，以修复为 real pointer 来运行
1. 设置参数和环境变量
1. 调用 dyld 的 main 方法

macho_header 是 Mach-O 的头部，而 dyld 加载的文件就是 Mach-O 类型的，Mach-O 由四部分组成：Mach-O头部、Load Command、section、Other Data，可以通过 MachOView 查看可执行文件信息

dyld::_main

 uintptr_t
_main(const macho_header* mainExecutableMH, uintptr_t mainExecutableSlide,
        int argc, const char* argv[], const char* envp[], const char* apple[],
        uintptr_t* startGlue)
{
    // 设置运行环境，可执行文件准备工作
    checkEnvironmentVariables(envp);
    defaultUninitializedFallbackPaths(envp);
    
    ......
    
    // load shared cache   加载共享缓存
    mapSharedCache();
    
    ......

    reloadAllImages:
    
    ......
    
    // instantiate ImageLoader for main executable 加载可执行文件并生成一个ImageLoader实例对象
    sMainExecutable = instantiateFromLoadedImage(mainExecutableMH, mainExecutableSlide, sExecPath);
    
    ......

    // load any inserted libraries   加载插入的动态库
    if  ( sEnv.DYLD_INSERT_LIBRARIES != NULL ) {
        for (const char* const* lib = sEnv.DYLD_INSERT_LIBRARIES; *lib != NULL; ++lib)
            loadInsertedDylib(*lib);
    }
    
    ......
    
    //link main executable 链接主程序
    link(sMainExecutable, sEnv.DYLD_BIND_AT_LAUNCH, true, ImageLoader::RPathChain(NULL, NULL), -1);
    
    ......
    
    // link any inserted libraries
    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 ) {
            // only INSERTED libraries can interpose
            // register interposing info after all inserted libraries are bound so chaining works
            for(unsigned int i=0; i < sInsertedDylibCount; ++i) {
                ImageLoader* image = sAllImages[i+1];
                image->registerInterposing(gLinkContext);
            }
        }
    }
    
    ......
    
    // <rdar://problem/12186933> do weak binding only after all inserted images linked
    sMainExecutable->weakBind(gLinkContext);
    sMainExecutable->recursiveMakeDataReadOnly(gLinkContext);
    
    ......
    
    // run all initializers 执行初始化方法
    initializeMainExecutable();
    
    ......
    
    // notify any montoring proccesses that this process is about to enter main()
    notifyMonitoringDyldMain();
    
    ......
    
    return result;
}

源码很长，这里做了精简，主要做了以下事情：

1. 设置运行环境，为可执行文件的加载做准备工作
1. 映射共享缓存到当前进程的逻辑内存空间
1. 实例化主程序
1. 加载插入的动态库
1. 链接主程序
1. 链接插入的动态库
1. 执行弱符号绑定（weakBind）
1. 执行初始化方法
1. 查找程序入口并返回main( )

这里主要讲解第三步和第八步

主程序的初始化

 sMainExecutable = instantiateFromLoadedImage(mainExecutableMH, mainExecutableSlide, sExecPath);

dyld 将可执行文件以及插入的 lib 加载进内存，生成对应的 image。sMainExecutable 对应着可执行文件，通过 instantiateFromLoadedImage 方法初始化并返回一个 ImageLoader 的实例对象

static ImageLoaderMachO* instantiateFromLoadedImage(const macho_header* mh, uintptr_t slide, const char* path)
{
   // try mach-o loader
   if ( isCompatibleMachO((const uint8_t*)mh, path) ) {
       ImageLoader* image = ImageLoaderMachO::instantiateMainExecutable(mh, slide, path, gLinkContext);
       addImage(image);
       return (ImageLoaderMachO*)image;
   }
   
   throw "main executable not a known format";
}

isCompatibleMachO 是检查 Mach-O 的 subtype 是否是当前 cpu 可以支持；内核会映射到主可执行文件中，我们需要为映射到主可执行文件的文件，创建ImageLoader ，通过 instantiateMainExecutable 实例化

// create image for main executable
ImageLoader* ImageLoaderMachO::instantiateMainExecutable(const macho_header* mh, uintptr_t slide, const char* path, const LinkContext& context)
{
   //dyld::log("ImageLoader=%ld, ImageLoaderMachO=%ld, ImageLoaderMachOClassic=%ld, ImageLoaderMachOCompressed=%ld\n",
   //  sizeof(ImageLoader), sizeof(ImageLoaderMachO), sizeof(ImageLoaderMachOClassic), sizeof(ImageLoaderMachOCompressed));
   bool compressed;
   unsigned int segCount;
   unsigned int libCount;
   const linkedit_data_command* codeSigCmd;
   const encryption_info_command* encryptCmd;
   sniffLoadCommands(mh, path, false, &compressed, &segCount, &libCount, context, &codeSigCmd, &encryptCmd);
   // instantiate concrete class based on content of load commands
   if ( compressed ) 
       return ImageLoaderMachOCompressed::instantiateMainExecutable(mh, slide, path, segCount, libCount, context);
   else
#if SUPPORT_CLASSIC_MACHO
       return ImageLoaderMachOClassic::instantiateMainExecutable(mh, slide, path, segCount, libCount, context);
#else
       throw "missing LC_DYLD_INFO load command";
#endif
}

实例化可执行文件，这个期间会解析 LoadCommand，这个之后会发送 dyld_image_state_mapped 通知；在此方法中，读取 image，然后 addImage() 到镜像列表。

执行初始化方法

 void initializeMainExecutable()
{
    // record that we've reached this step
    gLinkContext.startedInitializingMainExecutable = true;

    // 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]);
        }
    }
    
    // run initializers for main executable and everything it brings up 
    sMainExecutable->runInitializers(gLinkContext, initializerTimes[0]);
    
    // register cxa_atexit() handler to run static terminators in all loaded images when this process exits
    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]);
}

主要是调用所有 image 的 Initalizer 方法进行初始化

1. 为所有插入的动态库执行初始化操作
1. 主程序可执行文件执行初始化操作
1. 进程终止时注册 cxa_atexit() 回调

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);
}

核心是会调用 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;
    // 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) {
        // 对镜像表中的所有镜像执行 recursiveInitialization ，创建一个未初始化的向上依赖新表
        images.imagesAndPaths[i].first->recursiveInitialization(context, thisThread, images.imagesAndPaths[i].second, timingInfo, ups);
    }
    // If any upward dependencies remain, init them.
    if ( ups.count > 0 )
        processInitializers(context, thisThread, timingInfo, ups);
}

在这里，对镜像表中的所有镜像执行 recursiveInitialization ，创建一个未初始化的向上依赖新表。如果依赖中未初始化完毕，则继续执行 processInitializers，直到全部初始化完毕。

void ImageLoader::recursiveInitialization(const LinkContext& context, mach_port_t this_thread, const char* pathToInitialize,
                                          InitializerTimingList& timingInfo, UninitedUpwards& uninitUps)
{
    recursive_lock lock_info(this_thread);
    recursiveSpinLock(lock_info);// 递归加锁

    if ( fState < dyld_image_state_dependents_initialized-1 ) {
        uint8_t oldState = fState;
        // break cycles
        fState = dyld_image_state_dependents_initialized-1;
        try {
            // initialize lower level libraries first
            for(unsigned int i=0; i < libraryCount(); ++i) {
                ImageLoader* dependentImage = libImage(i);
                if ( dependentImage != NULL ) {
                    // don't try to initialize stuff "above" me yet
                    if ( libIsUpward(i) ) {
                        uninitUps.imagesAndPaths[uninitUps.count] = { dependentImage, libPath(i) };
                        uninitUps.count++;
                    }
                    else if ( dependentImage->fDepth >= fDepth ) {
                        dependentImage->recursiveInitialization(context, this_thread, libPath(i), timingInfo, uninitUps);
                    }
                }
            }
            
            // record termination order
            if ( this->needsTermination() )
                context.terminationRecorder(this);

            // ⭐️ 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);
            
            // ⭐️ initialize this image
            bool hasInitializers = this->doInitialization(context);

            // ⭐️ let anyone know we finished initializing this image
            fState = dyld_image_state_initialized;
            oldState = fState;
            context.notifySingle(dyld_image_state_initialized, this, NULL);
            
            if ( hasInitializers ) {
                uint64_t t2 = mach_absolute_time();
                timingInfo.addTime(this->getShortName(), t2-t1);
            }
        }
        catch (const char* msg) {
            // this image is not initialized
            fState = oldState;
            recursiveSpinUnLock();
            throw;
        }
    }
    
    recursiveSpinUnLock();// 递归解锁
}

在这里，有三行代码比较关键，就是调用了两个函数方法

context.notifySingle(dyld_image_state_dependents_initialized, this, &timingInfo);
bool hasInitializers = this->doInitialization(context);
context.notifySingle(dyld_image_state_initialized, this, NULL);

context.notifySingle(dyld_image_state_dependents_initialized, this, &timingInfo)

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)(image->getRealPath(), image->machHeader()); 获取镜像文件的真实地址。全局搜索 sNotifyObjCInit 只找到了它的赋值操作，如下

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 是通过调用 registerObjCNotifiers 方法传递的参数，再次全局搜索调用 registerObjCNotifiers 方法的地方，继而我们找到 _dyld_objc_notify_register 函数

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);
}

_dyld_objc_notify_register 函数需要到 libobjc 源码中查找，打开 objc-781 源码找到其是在 _objc_init 函数中调用的

/***********************************************************************
* _objc_init
* Bootstrap initialization. Registers our image notifier with dyld.
* Called by libSystem BEFORE library initialization time
**********************************************************************/

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);

#if __OBJC2__
    didCallDyldNotifyRegister = true;
#endif
}

runtime 初始化后，在 _objc_init 中注册了几个通知，由 dyld 接手，包括初始化相应依赖库里的类结构，调用依赖库里所有的load方法等。那么 _objc_init 函数是什么时候调用的呢？前面我们说了有三行重要的代码，现在来分析下 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);
}

我们看到，上面的两行代码才是重点，继而我们继续到它们的源码实现

doImageInit

主要是for循环加载方法的调用，另外通过注释我们看到，libSystem 的初始化必须最先执行。

doModInitFunctions

源码很长，就不做粘贴了，主要是加载了所有 Cxx 文件，在调用 C++ 方法打个断点可以验证

直到这里还是没有找到 _objc_init 方法的调用，怎么办呢？既然直接找不到，那我们就反推，在 _objc_init 加一个符号断点，运行程序，查看 _objc_init 的堆栈信息

libSystem_initializer 的源码是在 libsystem 中，下载地址 libsystem 源码下载，源码如下

libSystem_initializer(int argc,
             const char* argv[],
             const char* envp[],
             const char* apple[],
             const struct ProgramVars* vars)
{
   ......
   
   // No ASan interceptors are invoked before this point. ASan is normally initialized via the malloc interceptor:
   // _dyld_initializer() -> tlv_load_notification -> wrap_malloc -> ASanInitInternal

   _dyld_initializer();
   _libSystem_ktrace_init_func(DYLD);

   libdispatch_init();
   _libSystem_ktrace_init_func(LIBDISPATCH);
   
   ......
}

参照前面 _objc_init 打印的堆栈信息，可以知道，之后会调用 libdispatch_init()，而 libdispatch_init() 是在 libdispatch 库中的，libdispatch 源码下载，源码实现如下：

DISPATCH_EXPORT DISPATCH_NOTHROW
void
libdispatch_init(void)
{
   ......
   _dispatch_hw_config_init();
   _dispatch_time_init();
   _dispatch_vtable_init();
   _os_object_init();
   _voucher_init();
   _dispatch_introspection_init();
}

下一步会调用 _os_object_init()，_os_object_init 的源码实现

void
_os_object_init(void)
{
    _objc_init();
    Block_callbacks_RR callbacks = {
        sizeof(Block_callbacks_RR),
        (void (*)(const void *))&objc_retain,
        (void (*)(const void *))&objc_release,
        (void (*)(const void *))&_os_objc_destructInstance
    };
    _Block_use_RR2(&callbacks);
#if DISPATCH_COCOA_COMPAT
    const char *v = getenv("OBJC_DEBUG_MISSING_POOLS");
    if (v) _os_object_debug_missing_pools = _dispatch_parse_bool(v);
    v = getenv("DISPATCH_DEBUG_MISSING_POOLS");
    if (v) _os_object_debug_missing_pools = _dispatch_parse_bool(v);
    v = getenv("LIBDISPATCH_DEBUG_MISSING_POOLS");
    if (v) _os_object_debug_missing_pools = _dispatch_parse_bool(v);
#endif
}

可以看到，其源码最终调用了 _objc_init() 函数。

综上分析，通过 _objc_init runtime 向 dyld 注册通知回调，当 image 加载到内存后，dyld 会通知 runtime 进行处理。runtime 接手后调用 map_images 做解析和处理，接下来 load_images 中调用 call_load_methods 方法，遍历所有加载进来的 Class，按继承层级依次调用 Class 的 +load 方法和其 Category 的 +load 方法。至此，可执行文件和动态库中所有的符号（Class，Protocol，Selector，IMP，…）都已经按格式成功加载到内存中，被 runtime 所管理。

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

iOS应用程序加载流程