load

• 源码

//objc-os.mm
void objc_init(void)
{
    _dyld_objc_notify_register(&map_images, load_images, unmap_image);
}

load_images ->objc-runtime-new.mm(load_images)

//objc-runtime-new.mm
void load_images(const char *path __unused, const struct mach_header *mh)
{
    // Discover load methods
    {
        mutex_locker_t lock2(runtimeLock);
        prepare_load_methods((const headerType *)mh);
    }

    // Call +load methods (without runtimeLock - re-entrant)
    call_load_methods();
}

    call_load_methods() ->objc-loadmethod.mm(call_load_methods);

• prepare_load_methods

void prepare_load_methods(const headerType *mhdr)
{
 classref_t const *classlist = 
       _getObjc2NonlazyClassList(mhdr, &count);
   for (i = 0; i < count; i++) {
       schedule_class_load(remapClass(classlist[i]));  //递归把类以及父类添加进去
   }

 
 category_t * const *categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
   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
       if (cls->isSwiftStable()) {
           _objc_fatal("Swift class extensions and categories on Swift "
                       "classes are not allowed to have +load methods");
       }
       realizeClassWithoutSwift(cls, nil);
       ASSERT(cls->ISA()->isRealized());
       add_category_to_loadable_list(cat);   //按照编译顺序添加分类
   }

}

//添加类之前，先递归把父类添加进去
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); 
}

• call_load_methods

//objc-loadmethod.mm

static int loadable_classes_used = 0;

void call_load_methods(void)
{
    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);
}

static void call_class_loads(void)
{
    int i;
    
    // Detach current loadable list.
    struct loadable_class *classes = loadable_classes;
    int used = loadable_classes_used;
    loadable_classes = nil;
    loadable_classes_allocated = 0;
    loadable_classes_used = 0;
    
    // Call all +loads for the detached list.
    for (i = 0; i < used; i++) {
        Class cls = classes[i].cls;
        load_method_t load_method = (load_method_t)classes[i].method;
        if (!cls) continue; 

        if (PrintLoading) {
            _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
        }
        (*load_method)(cls, @selector(load));
    }
    
    // Destroy the detached list.
    if (classes) free(classes);
}

static bool call_category_loads(void)
{
    int i, shift;
    bool new_categories_added = NO;
    
    // Detach current loadable list.
    struct loadable_category *cats = loadable_categories;
    int used = loadable_categories_used;
    int allocated = loadable_categories_allocated;
    loadable_categories = nil;
    loadable_categories_allocated = 0;
    loadable_categories_used = 0;

    // Call all +loads for the detached list.
    for (i = 0; i < used; i++) {
        Category cat = cats[i].cat;
        load_method_t load_method = (load_method_t)cats[i].method;
        Class cls;
        if (!cat) continue;

        cls = _category_getClass(cat);
        if (cls  &&  cls->isLoadable()) {
            if (PrintLoading) {
                _objc_inform("LOAD: +[%s(%s) load]\n", 
                             cls->nameForLogging(), 
                             _category_getName(cat));
            }
            (*load_method)(cls, @selector(load));
            cats[i].cat = nil;
        }
    }

    // Compact detached list (order-preserving)
    shift = 0;
    for (i = 0; i < used; i++) {
        if (cats[i].cat) {
            cats[i-shift] = cats[i];
        } else {
            shift++;
        }
    }
    used -= shift;

    // Copy any new +load candidates from the new list to the detached list.
    new_categories_added = (loadable_categories_used > 0);
    for (i = 0; i < loadable_categories_used; i++) {
        if (used == allocated) {
            allocated = allocated*2 + 16;
            cats = (struct loadable_category *)
                realloc(cats, allocated *
                                  sizeof(struct loadable_category));
        }
        cats[used++] = loadable_categories[i];
    }

    // Destroy the new list.
    if (loadable_categories) free(loadable_categories);

    // Reattach the (now augmented) detached list. 
    // But if there's nothing left to load, destroy the list.
    if (used) {
        loadable_categories = cats;
        loadable_categories_used = used;
        loadable_categories_allocated = allocated;
    } else {
        if (cats) free(cats);
        loadable_categories = nil;
        loadable_categories_used = 0;
        loadable_categories_allocated = 0;
    }

    if (PrintLoading) {
        if (loadable_categories_used != 0) {
            _objc_inform("LOAD: %d categories still waiting for +load\n",
                         loadable_categories_used);
        }
    }

    return new_categories_added;
}

• 调用时间
  runtime加载class,category的时候调用，只调用一次
• 调用方式
  找到函数(load)地址，直接调用
• 调用顺序
  1.先调用class 的load
  a>不存在继承关系的类，先编译的先调用
  b>存在继承关系的类，子类先编译，先调用父类的load(通过递归查找父类，然后返回)，再调用子类的load;
  父类先编译，则按照顺序调用load

2.后调用category的load
按照编译顺序调用

initialize

类对象第一次接收到消息时调用，也就是说使用消息机制objc_msgSend()发消息

• 源码

/*
 * id objc_msgSend(id self, SEL _cmd, ...);
 * IMP objc_msgLookup(id self, SEL _cmd, ...);
 * 
 * objc_msgLookup ABI:
 * IMP returned in r12
 * Forwarding returned in Z flag
 * r9 reserved for our use but not used
 */
入口函数
IMP lookUpImpOrForward(id inst, SEL sel, Class cls, int behavior)
{
    cls = initializeAndLeaveLocked(cls, inst, runtimeLock);
}

static Class initializeAndLeaveLocked(Class cls, id obj, mutex_t& lock)
{
    return initializeAndMaybeRelock(cls, obj, lock, true);
}

static Class initializeAndMaybeRelock(Class cls, id inst,
                                      mutex_t& lock, bool leaveLocked)
{
   initializeNonMetaClass(nonmeta);
}


void initializeNonMetaClass(Class cls)
{

    //进行递归找父类的initialize
    supercls = cls->superclass;
    if (supercls  &&  !supercls->isInitialized()) {
        initializeNonMetaClass(supercls);
    }
    callInitialize(cls);
}

//发消息
void callInitialize(Class cls)
{
    ((void(*)(Class, SEL))objc_msgSend)(cls, @selector(initialize));
    asm("");
}


//

• 调用时间
  类对象第一次接收到消息时调用，每一个类只会调用一次；
  若存在继承关系，子类没有实现+initialize，则父类的+initialize会被调用多次。
• 调用方式
  通过消息机制objc_msgSend(id,sel,...)调用
• 调用顺序
  先调用父类的initialize(递归)，再调用子类的initialize。若存在category,调用最后编译的category的initialize