从 dyld 到 runtime

1
2
3
4
5
6
7
8
9

dyld中c++部分:
    
    // In dyld we have to do this manually.
    start(){
        // others work...
        return _main();//而_main()返回的是主程序main()的地址
    }
dyld汇编中部分：
    __dyld_start: 会jumps 到start()返回的地址

1
2
3
4
5
6

// 
// Entry point for dyld. The kernel loads dyld and jumps to __dyld_start which
// sets up some registers and call this function.
//
// Returns address of main() in target program which __dyld_start jumps to
//

1
2
3
4
5
6
7
8
9

1,// instantiate ImageLoader for main executable
// load shared cache
// Now that shared cache is loaded, setup an versioned dylib overrides
2,// load any inserted libraries
3,// link main executable
4,// 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
5,// run all initializers
6,// find entry point for main executable
7,// Returns address of main() in target program

1
2
3
4
5
6
7
8
9
10
11
12

//
// ImageLoader is an abstract base class. To support loading a particular executable
// file format, you make a concrete subclass of ImageLoader.
//
// 每个.o文件都会生成一个ImageLoader子类实例
// For each executable file (dynamic shared object) in use, an ImageLoader is instantiated.
//
// The ImageLoader base class does the work of linking together images, but it knows nothing
// about any particular file format.
//
//
class ImageLoader {...}

1
2

// instantiate ImageLoader for main executable
sMainExecutable = instantiateFromLoadedImage(mainExecutableMH, mainExecutableSlide, sExecPath);

1
2
3
4
5
6
7
8
9
10

// The kernel maps in main executable before dyld gets control. 
// We need to make an ImageLoader* for the already mapped in main executable.
static ImageLoader* instantiateFromLoadedImage(...){
    if ( isCompatibleMachO((const uint8_t*)mh, path) ) { //检查.o是否合法
       //instantiateMainExecutable()：得到主程序的image。省略不贴code了(影响美观，??)
        ImageLoader* image = ImageLoaderMachO::instantiateMainExecutable(mh, slide, path, gLinkContext);
        addImage(image);
        return image;
    }
}

1
2
3
4
5
6
7
8

static void addImage(ImageLoader* image){
    //add to master list
    // update mapped ranges
    // other work…
    if ( sEnv.DYLD_PRINT_LIBRARIES || ...) {
        dyld::log("dyld: loaded: %sn", image->getPath());
   }
}

1
2
3
4
5

// load any inserted libraries
if( sEnv.DYLD_INSERT_LIBRARIES != NULL) {
    for (const char* const* lib = sEnv.DYLD_INSERT_LIBRARIES; *lib != NULL; ++lib)
        loadInsertedDylib(*lib);
}

1
2
3
4
5
6
7
8

void initializeMainExecutable(){
    // run initialzers for any inserted dylibs
    // run initializers for main executable and everything it brings up
    // register cxa_atexit() handler to run static terminators in all loaded images when this process exits
    // dump info if requested
    if( sEnv.DYLD_PRINT_STATISTICS ){
        ImageLoaderMachO::printStatistics((unsigned int)sAllImages.size(), initializerTimes[0]);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

static void libSystem_initializer(...){
    // others init...
    libdispatch_init();
}
void libdispatch_init(void){
    // others init...
    _os_object_init();
}
void _os_object_init(void){
    _objc_init();
    // others init work...
}
/***********************************************************************
* _objc_init
* Bootstrap initialization. Registers our image notifier with dyld.
* Old ABI: called by dyld as a library initializer
* New ABI: called by libSystem BEFORE library initialization time
**********************************************************************/
void _objc_init(void){
    // other init work…
    
    // Old objc-runtime.mm(??的主要用这种来介绍)
    dyld_register_image_state_change_handler(dyld_image_state_bound,1/*batch*/, &map_2_images);
    dyld_register_image_state_change_handler(dyld_image_state_dependents_initialized,0/*not batch*/, &load_images);
    
    // 在新的 objc-runtime.mm中是这样的，反正都差不多就不计较用法了。
    // _dyld_objc_notify_register(&map_images, load_images, unmap_image);
}
// 关于 dyld_register_image_state_change_handler的介绍,其中第三个参数是callback!!
// Register a handler to be called when any image changes to the requested state.
extern void dyld_register_image_state_change_handler(enum dyld_image_states state, bool batch, dyld_image_state_change_handler handler);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

const char*load_images(enum dyld_image_states state, uint32_t infoCount,const structdyld_image_info infoList[]){
    // other work ...
    // Call +load methods (without runtimeLock - re-entrant)
    call_load_methods();
}
/***********************************************************************
* call_load_methods
* Call all pending class and category +load methods.
* Class +load methods are called superclass-first. 
* Category +load methods are not called until after the parent class's +load.
…………
**********************************************************************/
void call_load_methods(void){
    // other work...
    do{
        // 1. Repeatedly call class +loads until there aren't any more
        while (loadable_classes_used > 0) {
           call_class_loads();
        }
        // 2. Call category +loads ONCE
        more_categories = call_category_loads();
        // 3. Run more +loads if there are classes OR more untried categories
    }while (loadable_classes_used > 0  ||  more_categories);
}