启动之前(编译阶段)
编译阶段主要是把代码编译成可执行文件。主要流程如下:
加载源文件
:载入.h、.m、.cpp等文件预编译
:替换宏,删除注释,展开头文件,产生.i文件编译
:将.i文件转换为汇编语言,产生.s文件汇编
:将汇编文件转换为机器码
文件,产生.o
文件链接
:对.o
文件中引用其他库的地方进行引用,生成最后的可执行文件 以下是编译的流程
编译阶段静态库
和动态库
的处理
静态库
在编译阶段会直接拷贝一份到目标程序中,所以,程序运行后,程序对静态库文件没有依赖性。但是会造成目标程序的体积增大和运行速度减慢等问题
动态库
在编译阶段目标程序只会存储指向动态库的引用,在程序运行时才被载入。
- 优点:减少目标程序的大小。一份文件可以多处使用,而且不需要复制到目标程序中。
- 缺点:动态载入消耗部分性能。程序对动态库文件有很强的依赖性。
探索启动之前
在探索程序启动时执行的方法之前。我们去找程序的调用的入口。首先在main
函数中增加断点,如下图所示,可以看出在执行main
之前调用了dyld
中的start
方法。
- 在
main
方法执行之前调用的方法加上断点进行查看。先查看方法调用的顺序。如下所示:load方法->C++方法->main方法
load
方法的断点(C++方法一样)。- 所以我们可以到
dyld
源码中查看是否是程序的入口。并且在启动时做了什么事情。
启动过程
在load函数中打上断点,可以看到XCode左边的堆栈中的方法列表。其中 _dyld_start
是程序的入口。而且调用的方法大多数是dyld源码中的方法,下载dyld源码查看内部实现。
在源码中查看到dyld
主要做了如下事情
- App运行环境的配置。
- 环境变量配置
- 共享缓存设置
- 主程序的初始化
- 对需要使用的库进行插入和绑定
- 插入动态库
- 链接主程序
- 链接动态库
- 弱符号绑定
- 初始化方法
- 寻找程序入口(main方法),并且返回
启动时dyld
具体代码实现
- 在
dyld
源码中搜索_dyld_start
,可以看到汇编方法如下所示。_dyld_start
的入口同时会调用一个C++方法dyldbootstrap::start
- 源码中搜索
dyldbootstrap
,再在这个文件中查找start方法,其核心是返回值的调用了dyld的main函数,其中macho_header是Mach-O的头部,而dyld加载的文件就是Mach-O类型的,即Mach-O类型是可执行文件类型,由四部分组成:Mach-O头部、Load Command、section、Other Data,可以通过MachOView查看可执行文件信息。
App运行环境的配置
- 环境变量配置 根据环境变量设置相应的值以及获取当前运行架构
uintptr_t
_main(const macho_header* mainExecutableMH, uintptr_t mainExecutableSlide,
int argc, const char* argv[], const char* envp[], const char* apple[],
uintptr_t* startGlue)
{
...
...
// 创建主程序cdHash的空间
uint8_t mainExecutableCDHashBuffer[20];
// 从环境中获取可执行主要文件CDHash
const uint8_t* mainExecutableCDHash = nullptr;
if ( const char* mainExeCdHashStr = _simple_getenv(apple, "executable_cdhash") ) {
unsigned bufferLenUsed;
if ( hexStringToBytes(mainExeCdHashStr, mainExecutableCDHashBuffer, sizeof(mainExecutableCDHashBuffer), bufferLenUsed) )
mainExecutableCDHash = mainExecutableCDHashBuffer;
}
...
...
// 获取当前运行环境架构的信息
getHostInfo(mainExecutableMH, mainExecutableSlide);
{
//【第一步--------环境变量配置】
checkEnvironmentVariables(envp);
defaultUninitializedFallbackPaths(envp);
}
...
...
}
- 共享缓存设置
检查是否开启了共享缓存,以及共享缓存是否映射到共享区域,例如
UIKit
、CoreFoundation
等
...
...
////【第二步--------共享缓存】
// 检查共享缓存是否开启 在iOS中必须开启
checkSharedRegionDisable((dyld3::MachOLoaded*)mainExecutableMH, mainExecutableSlide);
if ( gLinkContext.sharedRegionMode != ImageLoader::kDontUseSharedRegion ) {
#if TARGET_OS_SIMULATOR
if ( sSharedCacheOverrideDir)
//检查共享缓存是否映射到共享区
mapSharedCache(mainExecutableSlide);
#else
//检查共享缓存是否映射到共享区
mapSharedCache(mainExecutableSlide);
#endif
...
...
// 如果还没有关闭模式 请检查环境和共享缓存的类型
// If we haven't got a closure mode yet, then check the environment and cache type
if ( sClosureMode == ClosureMode::Unset ) {...}
...
...
主程序的初始化
调用instantiateFromLoadedImage函数实例化了一个ImageLoader
对象
...
...
// instantiate ImageLoader for main executable
//【第三步--------主程序的初始化】
// 加载可执行文件,并且生产一个LoadedImage实例对象
sMainExecutable = instantiateFromLoadedImage(mainExecutableMH, mainExecutableSlide, sExecPath);
gLinkContext.mainExecutable = sMainExecutable;
gLinkContext.mainExecutableCodeSigned = hasCodeSignatureLoadCommand(mainExecutableMH);
...
...
对需要使用的库进行插入和绑定
- 插入动态库
遍历
DYLD_INSERT_LIBRARIES
环境变量,调用loadInsertedDylib
加载
...
...
// load any inserted libraries
//【第四步--------插入动态库】
// 加载所有DYLD_INSERT_LIBRARIES指定的库
if ( sEnv.DYLD_INSERT_LIBRARIES != NULL ) {
for (const char* const* lib = sEnv.DYLD_INSERT_LIBRARIES; *lib != NULL; ++lib)
loadInsertedDylib(*lib);
}
// 记录插入库的数量以便进行统一搜索
// record count of inserted libraries so that a flat search will look at
// 插入库,然后main和其他
// inserted libraries, then main, then others.
sInsertedDylibCount = sAllImages.size()-1;
...
...
- 链接主程序
...
...
//【第五步--------link主程序】
link(sMainExecutable, sEnv.DYLD_BIND_AT_LAUNCH, true, ImageLoader::RPathChain(NULL, NULL), -1);
sMainExecutable->setNeverUnloadRecursive();
if ( sMainExecutable->forceFlat() ) {
gLinkContext.bindFlat = true;
gLinkContext.prebindUsage = ImageLoader::kUseNoPrebinding;
}
...
...
- 链接动态库
...
...
//【第六步--------link动态库】
// link any inserted libraries
// 链接插入的动态库
// do this after linking main executable so that any dylibs pulled in by inserted
// dylibs (e.g. libSystem) will not be in front of dylibs the program uses
// 在链接主程序后执行链接动态库,保证所有的dylibs在使用前(如:libSystem)都被插入
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);
}
}
}
...
...
- 弱符号绑定
...
...
// 绑定并且通知主要可执行文件,现在插入已经被注册
// Bind and notify for the main executable now that interposing has been registered
uint64_t bindMainExecutableStartTime = mach_absolute_time();
sMainExecutable->recursiveBindWithAccounting(gLinkContext, sEnv.DYLD_BIND_AT_LAUNCH, true);
uint64_t bindMainExecutableEndTime = mach_absolute_time();
ImageLoaderMachO::fgTotalBindTime += bindMainExecutableEndTime - bindMainExecutableStartTime;
gLinkContext.notifyBatch(dyld_image_state_bound, false);
// 绑定并通知已插入镜像已经被注册
// Bind and notify for the inserted images now interposing has been registered
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, nullptr);
}
}
// 弱符号绑定
// <rdar://problem/12186933> do weak binding only after all inserted images linked
sMainExecutable->weakBind(gLinkContext);
...
...
初始化方法
// run all initializers
//【第八步--------执行初始化程序】
initializeMainExecutable();
寻找程序入口(main方法),并且返回
从Load Command读取LC_MAIN入口,如果没有,就读取LC_UNIXTHREAD,这样就来到了日常开发中熟悉的main函数了
...
...
{
//【第九步--------寻找主程序入口】
// find entry point for main executable
// 寻找入口并且执行
result = (uintptr_t)sMainExecutable->getEntryFromLC_MAIN();
if ( result != 0 ) {
// main executable uses LC_MAIN, we need to use helper in libdyld to call into main()
// 主要可执行文件使用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 {
// main executable uses LC_UNIXTHREAD, dyld needs to let "start" in program set up for main()
// 主要可执行文件使用LC_UNIXTHREAD
result = (uintptr_t)sMainExecutable->getEntryFromLC_UNIXTHREAD();
*startGlue = 0;
}
}
...
...
启动时中的细节
初始化方法initializeMainExecutable
- 点进该方法,主要是执行所有插入的dylibs的初始化
void initializeMainExecutable()
{
// record that we've reached this step
gLinkContext.startedInitializingMainExecutable = true;
// run initialzers for any inserted dylibs
// 执行所有插入的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]);
//当程序退出时注册cxa_atexit处理程序
// 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]);
}
- 查看dylib的初始化方法runInitializers,全局搜索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);
}
- 在这里,对镜像表中的所有镜像执行recursiveInitialization ,创建一个未初始化的向上依赖新表。如果依赖中未初始化完毕,则继续执行processInitializers,直到全部初始化完毕。
// <rdar://problem/14412057> upward dylib initializers can be run too soon
// To handle dangling dylibs which are upward linked but not downward, all upward linked dylibs
// have their initialization postponed until after the recursion through downward dylibs
// has completed.
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) {
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);
}
- ImageLoader::recursiveInitialization方法
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) {...}
// record termination order
if ( this->needsTermination() )
context.terminationRecorder(this);
//让objc知道将要初始化这个镜像
// 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);
//初始化镜像 会执行_objc_init方法
// initialize this image
bool hasInitializers = this->doInitialization(context);
//让anyone知道将要初始化这个镜像
// 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 ) {...}
}
catch (const char* msg) {...}
}
recursiveSpinUnLock();
}
- 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();
(*sNotifyObjCInit)(image->getRealPath(), image->machHeader());
}
......
}
- 获取镜像文件的真实地址 【*sNotifyObjCInit)(image->getRealPath(), image->machHeader() 】,而 sNotifyObjCInit 是 通过 registerObjCNotifiers 中传递的参数(_dyld_objc_notify_init)进行赋值的。
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;
......
}
- 继而找到,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 函数是供
objc runtime
使用的,当objc镜像被映射,取消映射,和初始化时 被调用的注册处理器。我们可以在objc源码
中的_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(); // C++
runtime_init(); // runtime 初始化
exception_init(); // 异常初始化
cache_init(); // 缓存初始化
_imp_implementationWithBlock_init(); //
_dyld_objc_notify_register(&map_images, load_images, unmap_image);
#if __OBJC2__
didCallDyldNotifyRegister = true;
#endif
}
- 其中
load_images
是一个调用所有类的+load
的方法。
总结
APP是由内核引导启动的,kernel内核做好所有准备工作后会得到线程入口及main
入口,但是线程不会马上进入main入口,因为还要加载动态链接器(dyld)
,dyld会将入口点保存下来,等dyld加载完所有动态链接库等工作之后,再开始执行main函数。
- 系统kernel做好启动程序的初始准备后,交给dyld负责。
- dyld接手后,系统先读取 App 的可执行文件(Mach-O文件),从里面获取dyld的路径,然后加载dyld,dyld去初始化运行环境,开启缓存策略。
- 配合 ImageLoader 将二进制文件按格式加载到内存,加载程序相关依赖库(其中也包含我们的可执行文件),并对这些库进行链接,
- 最后调用每个依赖库的初始化方法,在这一步,runtime被初始化。当所有依赖库初始化后,轮到最后一位(程序可执行文件)进行初始化,在这时runtime会对项目中所有类进行类结构初始化,然后调用所有的load方法。
- 最后dyld返回main()函数地址,main()函数被调用。
这个过程远比写出来的要复杂,这里只提到了 runtime 这个分支,还有像 GCD、XPC 等重头的系统库初始化分支没有提及(当然,有缓存机制在,它们也不会玩命初始化),总结起来就是 main 函数执行之前,系统做了茫茫多的加载和初始化工作,最终引入那个熟悉的main函数。
借鉴: