IOS程序在main函数前所做的事情

qis-Mac-mini:Debug-iphoneos qi$ cd QiDemo.app/
qis-Mac-mini:QiDemo.app qi$ ls
Base.lproj			QiDemo
Info.plist			_CodeSignature
PkgInfo				embedded.mobileprovision
qis-Mac-mini:QiDemo.app qi$ otool -L QiDemo 
QiDemo:
	/System/Library/Frameworks/Foundation.framework/Foundation (compatibility version 300.0.0, current version 1452.23.0)
	/usr/lib/libobjc.A.dylib (compatibility version 1.0.0, current version 228.0.0)
	/usr/lib/libc++.1.dylib (compatibility version 1.0.0, current version 400.9.1)
	/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1252.50.4)
	/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation (compatibility version 150.0.0, current version 1452.23.0)
	/System/Library/Frameworks/UIKit.framework/UIKit (compatibility version 1.0.0, current version 3698.52.10)

//
// 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
//
uintptr_t
_main(const macho_header* mainExecutableMH, uintptr_t mainExecutableSlide, 
		int argc, const char* argv[], const char* envp[], const char* apple[], 
		uintptr_t* startGlue)
{
    ....
}

//objc-os.mm
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();
    lock_init();
    exception_init();
        
    // Register for unmap first, in case some +load unmaps something
    _dyld_register_func_for_remove_image(&unmap_image);
    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);
}

 const char *
load_images(enum dyld_image_states state, uint32_t infoCount,
            const struct dyld_image_info infoList[])
{
        bool found;

    // Return without taking locks if there are no +load methods here.
        found = false;
        //这里会找所有的class以及category的列表里面是否有+load方法
        for (uint32_t i = 0; i < infoCount; i++) {
            if (hasLoadMethods((const headerType *)infoList[i].imageLoadAddress)) {
                found = true;
                break;
            }
        }
        if (!found) return nil;
        
        
        recursive_mutex_locker_t lock(loadMethodLock);

        // Discover load methods
        // 搜集所有的+load方法
        {
            rwlock_writer_t lock2(runtimeLock);
            found = load_images_nolock(state, infoCount, infoList);
        }
        //调用+load方法
        if (found) {
            call_load_methods();
        }
        ...
    }
    
    bool 
load_images_nolock(enum dyld_image_states state,uint32_t infoCount,
                   const struct dyld_image_info infoList[])
    {
        bool found = NO;
        uint32_t i;
    
        i = infoCount;
        while (i--) {
            const headerType *mhdr = (headerType*)infoList[i].imageLoadAddress;
            if (!hasLoadMethods(mhdr)) continue;
            // 搜集镜像中的load方法
            prepare_load_methods(mhdr);
            found = YES;
        }
    
        return found;
    }
    
  
  
  void prepare_load_methods(const headerType *mhdr)
    {
        size_t count, i;
    
        runtimeLock.assertWriting();
    
        //1. 先搜集class中的+load方法
        classref_t *classlist = 
            _getObjc2NonlazyClassList(mhdr, &count);
        for (i = 0; i < count; i++) {
            schedule_class_load(remapClass(classlist[i]));
        }
    
        category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
        //2. 再搜集category中的+load方法
        for (i = 0; i < count; i++) {
            category_t *cat = categorylist[i];
            Class cls = remapClass(cat->cls);
            if (!cls) continue;  // category for ignored weak-linked class
            realizeClass(cls);
            assert(cls->ISA()->isRealized());
            add_category_to_loadable_list(cat);
        }
    }
    
    //递归实现，可以看到这里是先找父类中的+load方法，并放入到一个列表里面，所以在最终的class的load方法列表里面，父类的+load方法是先于子类的+load方法的
    //大家可以看下add_class_to_loadable_list的实现，里面的分配内存策略使用了指数增长策略
    static void schedule_class_load(Class cls)
    {
        if (!cls) return;
        assert(cls->isRealized());  // _read_images should realize
    
        if (cls->data()->flags & RW_LOADED) return;
    
        // Ensure superclass-first ordering
        schedule_class_load(cls->superclass);
    
        add_class_to_loadable_list(cls);
        cls->setInfo(RW_LOADED); 
    }

 void call_load_methods(void)
{
    static bool loading = NO;
    bool more_categories;

    loadMethodLock.assertLocked();

    // Re-entrant calls do nothing; the outermost call will finish the job.
    if (loading) return;
    loading = YES;

    void *pool = objc_autoreleasePoolPush();

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

    objc_autoreleasePoolPop(pool);

    loading = NO;
}

 const char *
map_images_nolock(enum dyld_image_states state, uint32_t infoCount,
                  const struct dyld_image_info infoList[])
    {
        static bool firstTime = YES;
        static bool wantsGC = NO;
        uint32_t i;
        header_info *hi;
        header_info *hList[infoCount];
        uint32_t hCount;
        size_t selrefCount = 0;
    
        // Perform first-time initialization if necessary.
        // This function is called before ordinary library initializers. 
        // fixme defer initialization until an objc-using image is found?
        if (firstTime) {
            preopt_init();
        }
    
        // Find all images with Objective-C metadata.
        hCount = 0;
        i = infoCount;
        //收集infoList中的所有header信息并存储在一个单链表
        while (i--) {
            const headerType *mhdr = (headerType *)infoList[i].imageLoadAddress;
    
            hi = addHeader(mhdr);
            if (!hi) {
                // no objc data in this entry
                continue;
            }
    
            if (mhdr->filetype == MH_EXECUTE) {
                // Size some data structures based on main executable's size
                size_t count;
                _getObjc2SelectorRefs(hi, &count);
                selrefCount += count;
                _getObjc2MessageRefs(hi, &count);
                selrefCount += count;
            }
    
            hList[hCount++] = hi;
            
        }
    
        if (firstTime) {
            //注册一些我们常用的函数，比如load,alloc,dealloc等等
            //并使用selrefCount的值 去创建一个capacity为这个值的全局Map
            sel_init(wantsGC, selrefCount);
            //初始化AutoreleasePool，和一个SideTable，SideTable是干啥的也没弄清楚，暂时不管，这里不重要
            arr_init();
        }
        //重点是这个，这个会去读取hList里面的所有的image
        //中的classes，categories，protocols并存储在内存中
        //使我们之后使用runtime方法提供了前提，比如方法替换，消息转发等等
        _read_images(hList, hCount);
    
        firstTime = NO;
    
        return NULL;
    }

dyld_register_image_state_change_handler(
dyld_image_state_bound, 1, &map_images);
dyld_register_image_state_change_handler(
dyld_image_state_dependents_initialized, 0, &load_images);