iOSObjectiveC:+loadvs+initialize

void prepare_load_methods(header_info *hi) { size_t count, i; rwlock_assert_writing(&runtimeLock); classref_t *classlist &＃61; _getObjc2NonlazyClassList(hi, &count); for (i &＃61; 0; i <count; i&＃43;&＃43;) { schedule_class_load(remapClass(classlist[i])); } category_t **categorylist &＃61; _getObjc2NonlazyCategoryList(hi, &count); for (i &＃61; 0; i <count; i&＃43;&＃43;) { category_t *cat &＃61; categorylist[i]; Class cls &＃61; remapClass(cat->cls); if (!cls) continue; // category for ignored weak-linked class realizeClass(cls); 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); }

void call_load_methods(void) { static BOOL loading &＃61; NO; BOOL more_categories; recursive_mutex_assert_locked(&loadMethodLock); // Re-entrant calls do nothing; the outermost call will finish the job. if (loading) return; loading &＃61; YES; void *pool &＃61; objc_autoreleasePoolPush(); do { // 1. Repeatedly call class &＃43;loads until there aren&＃39;t any more while (loadable_classes_used > 0) { call_class_loads(); } // 2. Call category &＃43;loads ONCE more_categories &＃61; call_category_loads(); // 3. Run more &＃43;loads if there are classes OR more untried categories } while (loadable_classes_used > 0 || more_categories); objc_autoreleasePoolPop(pool); loading &＃61; NO; }

static void call_class_loads(void) { int i; // Detach current loadable list. struct loadable_class *classes &＃61; loadable_classes; int used &＃61; loadable_classes_used; loadable_classes &＃61; nil; loadable_classes_allocated &＃61; 0; loadable_classes_used &＃61; 0; // Call all &＃43;loads for the detached list. for (i &＃61; 0; i <used; i&＃43;&＃43;) { Class cls &＃61; classes[i].cls; load_method_t load_method &＃61; (load_method_t)classes[i].method; if (!cls) continue; if (PrintLoading) { _objc_inform("LOAD: &＃43;[%s load]\n", cls->nameForLogging()); } (*load_method)(cls, SEL_load); } // Destroy the detached list. if (classes) _free_internal(classes); }

loadable_classes &＃61; nil; loadable_classes_allocated &＃61; 0; loadable_classes_used &＃61; 0;

IMP lookUpImpOrForward(Class cls, SEL sel, id inst, bool initialize, bool cache, bool resolver) { ... rwlock_unlock_write(&runtimeLock); } if (initialize && !cls->isInitialized()) { _class_initialize (_class_getNonMetaClass(cls, inst)); // If sel &＃61;&＃61; initialize, _class_initialize will send &＃43;initialize and // then the messenger will send &＃43;initialize again after this // procedure finishes. Of course, if this is not being called // from the messenger then it won&＃39;t happen. 2778172 } // The lock is held to make method-lookup &＃43; cache-fill atomic // with respect to method addition. Otherwise, a category could ... }

void _class_initialize(Class cls) { ... Class supercls; BOOL reallyInitialize &＃61; NO; // Make sure super is done initializing BEFORE beginning to initialize cls. // See note about deadlock above. supercls &＃61; cls->superclass; if (supercls && !supercls->isInitialized()) { _class_initialize(supercls); } // Try to atomically set CLS_INITIALIZING. monitor_enter(&classInitLock); if (!cls->isInitialized() && !cls->isInitializing()) { cls->setInitializing(); reallyInitialize &＃61; YES; } monitor_exit(&classInitLock); if (reallyInitialize) { // We successfully set the CLS_INITIALIZING bit. Initialize the class. // Record that we&＃39;re initializing this class so we can message it. _setThisThreadIsInitializingClass(cls); // Send the &＃43;initialize message. // Note that &＃43;initialize is sent to the superclass (again) if // this class doesn&＃39;t implement &＃43;initialize. 2157218 if (PrintInitializing) { _objc_inform("INITIALIZE: calling &＃43;[%s initialize]", cls->nameForLogging()); } ((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize); if (PrintInitializing) { _objc_inform("INITIALIZE: finished &＃43;[%s initialize]", ... }

&＃43; (void)initialize { if (self &＃61;&＃61; [ClassName self]) { // ... do the initialization ... } }