应用程序加载（二） -- dyld&objc关联以及类的加载初探

应用程序加载（一） -- dyld流程分析
应用程序加载（二） -- dyld&objc关联以及类的加载初探
应用程序加载（三）-- 类的加载
应用程序加载（四）-- 分类的加载
应用程序加载（五）-- 类扩展和关联对象

---

前一篇文章通过一个小例子了解到应用程序加载的逻辑。这篇文章紧接着去研究类的加载。

切入点 - _objc_init

在上篇文章中对dyld的分析，最后回到objc源码中是通过_dyld_objc_notify_register这个函数，该函数是被_objc_init函数中调用的。

从dyld到objc的简要流程图：

_objc_init分析

看看_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();
    runtime_init();
    exception_init();
    cache_init();
    _imp_implementationWithBlock_init();
    
    _dyld_objc_notify_register(&map_images, load_images, unmap_image);

#if __OBJC2__
    didCallDyldNotifyRegister = true;
#endif
}

• 前三行代码：定义一个静态变量作为开关，目的是下面的操作只进行一次
• 然后调用7个xxx_init()函数
  • environ_init：环境变量相关内容
  • tls_init：线程相关内容
  • static_init：c++静态构造函数相关内容
  • runtime_init：运行时相关内容
  • exception_init：异常相关初始化处理
  • cache_init：缓存相关初始化处理
  • _imp_implementationWithBlock_init：系统层级的一些额外处理
• 调用_dyld_objc_notify_register函数，这个函数是在dyld中实现的，并且提供三个回调函数：
  • map_images：映射镜像
  • load_images：加载镜像
  • unmap_image：不需要映射的镜像

此时结合上篇的内容，应用启动后，从dyld开始，到objc，然后又回到dyld中。因为程序启动的入口是main函数，而main函数是在dyld中调用的。完整的流程图如下：

类加载map_images

从dyld到objc再到dyld。整个启动过程已经了解。但是还是没有看到类加载的位置。但是我们遗漏了objc给dyld中“预留”的几个回调函数。看看map_images回调函数的的实现：

void
map_images(unsigned count, const char * const paths[],
           const struct mach_header * const mhdrs[])
{
    mutex_locker_t lock(runtimeLock);
    return map_images_nolock(count, paths, mhdrs);
}

• 核心代码map_images_nolock调用，接下来看看它的实现

void 
map_images_nolock(unsigned mhCount, const char * const mhPaths[],
                  const struct mach_header * const mhdrs[])
{
    //省略部分代码

    // Find all images with Objective-C metadata.
    hCount = 0;

    //省略hCount计算代码

    if (hCount > 0) {
        _read_images(hList, hCount, totalClasses, unoptimizedTotalClasses);
    }
    
    //省略部分代码
}

• 此处核心代码是_read_images函数调用，进入的条件是变量hCount。但是没必要细究这些，直接看它的实现，代码很长，可以直接跳过，下面有对代码的解释

void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses)
{
    header_info *hi;
    uint32_t hIndex;
    size_t count;
    size_t i;
    Class *resolvedFutureClasses = nil;
    size_t resolvedFutureClassCount = 0;
    static bool doneOnce;
    bool launchTime = NO;
    TimeLogger ts(PrintImageTimes);

    runtimeLock.assertLocked();

#define EACH_HEADER \
    hIndex = 0;         \
    hIndex < hCount && (hi = hList[hIndex]); \
    hIndex++

    if (!doneOnce) {
        doneOnce = YES;
        launchTime = YES;

#if SUPPORT_NONPOINTER_ISA
        // Disable non-pointer isa under some conditions.

# if SUPPORT_INDEXED_ISA
        // Disable nonpointer isa if any image contains old Swift code
        for (EACH_HEADER) {
            if (hi->info()->containsSwift()  &&
                hi->info()->swiftUnstableVersion() < objc_image_info::SwiftVersion3)
            {
                DisableNonpointerIsa = true;
                if (PrintRawIsa) {
                    _objc_inform("RAW ISA: disabling non-pointer isa because "
                                 "the app or a framework contains Swift code "
                                 "older than Swift 3.0");
                }
                break;
            }
        }
# endif

# if TARGET_OS_OSX
        // Disable non-pointer isa if the app is too old
        // (linked before OS X 10.11)
        if (dyld_get_program_sdk_version() < DYLD_MACOSX_VERSION_10_11) {
            DisableNonpointerIsa = true;
            if (PrintRawIsa) {
                _objc_inform("RAW ISA: disabling non-pointer isa because "
                             "the app is too old (SDK version " SDK_FORMAT ")",
                             FORMAT_SDK(dyld_get_program_sdk_version()));
            }
        }

        // Disable non-pointer isa if the app has a __DATA,__objc_rawisa section
        // New apps that load old extensions may need this.
        for (EACH_HEADER) {
            if (hi->mhdr()->filetype != MH_EXECUTE) continue;
            unsigned long size;
            if (getsectiondata(hi->mhdr(), "__DATA", "__objc_rawisa", &size)) {
                DisableNonpointerIsa = true;
                if (PrintRawIsa) {
                    _objc_inform("RAW ISA: disabling non-pointer isa because "
                                 "the app has a __DATA,__objc_rawisa section");
                }
            }
            break;  // assume only one MH_EXECUTE image
        }
# endif

#endif

        if (DisableTaggedPointers) {
            disableTaggedPointers();
        }
        
        initializeTaggedPointerObfuscator();

        if (PrintConnecting) {
            _objc_inform("CLASS: found %d classes during launch", totalClasses);
        }

        // namedClasses
        // Preoptimized classes don't go in this table.
        // 4/3 is NXMapTable's load factor
        int namedClassesSize = 
            (isPreoptimized() ? unoptimizedTotalClasses : totalClasses) * 4 / 3;
        gdb_objc_realized_classes =
            NXCreateMapTable(NXStrValueMapPrototype, namedClassesSize);

        ts.log("IMAGE TIMES: first time tasks");
    }

    // Fix up @selector references
    static size_t UnfixedSelectors;
    {
        mutex_locker_t lock(selLock);
        for (EACH_HEADER) {
            if (hi->hasPreoptimizedSelectors()) continue;

            bool isBundle = hi->isBundle();
            SEL *sels = _getObjc2SelectorRefs(hi, &count);
            UnfixedSelectors += count;
            for (i = 0; i < count; i++) {
                const char *name = sel_cname(sels[i]);
                SEL sel = sel_registerNameNoLock(name, isBundle);
                if (sels[i] != sel) {
                    sels[i] = sel;
                }
            }
        }
    }

    ts.log("IMAGE TIMES: fix up selector references");

    // Discover classes. Fix up unresolved future classes. Mark bundle classes.
    bool hasDyldRoots = dyld_shared_cache_some_image_overridden();

    for (EACH_HEADER) {
        if (! mustReadClasses(hi, hasDyldRoots)) {
            // Image is sufficiently optimized that we need not call readClass()
            continue;
        }

        classref_t const *classlist = _getObjc2ClassList(hi, &count);

        bool headerIsBundle = hi->isBundle();
        bool headerIsPreoptimized = hi->hasPreoptimizedClasses();

        for (i = 0; i < count; i++) {
            Class cls = (Class)classlist[i];
            Class newCls = readClass(cls, headerIsBundle, headerIsPreoptimized);

            if (newCls != cls  &&  newCls) {
                // Class was moved but not deleted. Currently this occurs 
                // only when the new class resolved a future class.
                // Non-lazily realize the class below.
                resolvedFutureClasses = (Class *)
                    realloc(resolvedFutureClasses, 
                            (resolvedFutureClassCount+1) * sizeof(Class));
                resolvedFutureClasses[resolvedFutureClassCount++] = newCls;
            }
        }
    }

    ts.log("IMAGE TIMES: discover classes");

    // Fix up remapped classes
    // Class list and nonlazy class list remain unremapped.
    // Class refs and super refs are remapped for message dispatching.
    
    if (!noClassesRemapped()) {
        for (EACH_HEADER) {
            Class *classrefs = _getObjc2ClassRefs(hi, &count);
            for (i = 0; i < count; i++) {
                remapClassRef(&classrefs[i]);
            }
            // fixme why doesn't test future1 catch the absence of this?
            classrefs = _getObjc2SuperRefs(hi, &count);
            for (i = 0; i < count; i++) {
                remapClassRef(&classrefs[i]);
            }
        }
    }

    ts.log("IMAGE TIMES: remap classes");

#if SUPPORT_FIXUP
    // Fix up old objc_msgSend_fixup call sites
    for (EACH_HEADER) {
        message_ref_t *refs = _getObjc2MessageRefs(hi, &count);
        if (count == 0) continue;

        if (PrintVtables) {
            _objc_inform("VTABLES: repairing %zu unsupported vtable dispatch "
                         "call sites in %s", count, hi->fname());
        }
        for (i = 0; i < count; i++) {
            fixupMessageRef(refs+i);
        }
    }

    ts.log("IMAGE TIMES: fix up objc_msgSend_fixup");
#endif

    bool cacheSupportsProtocolRoots = sharedCacheSupportsProtocolRoots();

    // Discover protocols. Fix up protocol refs.
    for (EACH_HEADER) {
        extern objc_class OBJC_CLASS_$_Protocol;
        Class cls = (Class)&OBJC_CLASS_$_Protocol;
        ASSERT(cls);
        NXMapTable *protocol_map = protocols();
        bool isPreoptimized = hi->hasPreoptimizedProtocols();

        // Skip reading protocols if this is an image from the shared cache
        // and we support roots
        // Note, after launch we do need to walk the protocol as the protocol
        // in the shared cache is marked with isCanonical() and that may not
        // be true if some non-shared cache binary was chosen as the canonical
        // definition
        if (launchTime && isPreoptimized && cacheSupportsProtocolRoots) {
            if (PrintProtocols) {
                _objc_inform("PROTOCOLS: Skipping reading protocols in image: %s",
                             hi->fname());
            }
            continue;
        }

        bool isBundle = hi->isBundle();

        protocol_t * const *protolist = _getObjc2ProtocolList(hi, &count);
        for (i = 0; i < count; i++) {
            readProtocol(protolist[i], cls, protocol_map, 
                         isPreoptimized, isBundle);
        }
    }

    ts.log("IMAGE TIMES: discover protocols");

    // Fix up @protocol references
    // Preoptimized images may have the right 
    // answer already but we don't know for sure.
    for (EACH_HEADER) {
        // At launch time, we know preoptimized image refs are pointing at the
        // shared cache definition of a protocol.  We can skip the check on
        // launch, but have to visit @protocol refs for shared cache images
        // loaded later.
        if (launchTime && cacheSupportsProtocolRoots && hi->isPreoptimized())
            continue;
        protocol_t **protolist = _getObjc2ProtocolRefs(hi, &count);
        for (i = 0; i < count; i++) {
            remapProtocolRef(&protolist[i]);
        }
    }

    ts.log("IMAGE TIMES: fix up @protocol references");

    // Discover categories. Only do this after the initial category
    // attachment has been done. For categories present at startup,
    // discovery is deferred until the first load_images call after
    // the call to _dyld_objc_notify_register completes. rdar://problem/53119145
    if (didInitialAttachCategories) {
        for (EACH_HEADER) {
            load_categories_nolock(hi);
        }
    }

    ts.log("IMAGE TIMES: discover categories");

    // Category discovery MUST BE Late to avoid potential races
    // when other threads call the new category code before
    // this thread finishes its fixups.

    // +load handled by prepare_load_methods()

    // Realize non-lazy classes (for +load methods and static instances)
    for (EACH_HEADER) {
        classref_t const *classlist = 
            _getObjc2NonlazyClassList(hi, &count);
        for (i = 0; i < count; i++) {
            Class cls = remapClass(classlist[i]);
            if (!cls) continue;

            addClassTableEntry(cls);

            if (cls->isSwiftStable()) {
                if (cls->swiftMetadataInitializer()) {
                    _objc_fatal("Swift class %s with a metadata initializer "
                                "is not allowed to be non-lazy",
                                cls->nameForLogging());
                }
                // fixme also disallow relocatable classes
                // We can't disallow all Swift classes because of
                // classes like Swift.__EmptyArrayStorage
            }
            realizeClassWithoutSwift(cls, nil);
        }
    }

    ts.log("IMAGE TIMES: realize non-lazy classes");

    // Realize newly-resolved future classes, in case CF manipulates them
    if (resolvedFutureClasses) {
        for (i = 0; i < resolvedFutureClassCount; i++) {
            Class cls = resolvedFutureClasses[i];
            if (cls->isSwiftStable()) {
                _objc_fatal("Swift class is not allowed to be future");
            }
            realizeClassWithoutSwift(cls, nil);
            cls->setInstancesRequireRawIsaRecursively(false/*inherited*/);
        }
        free(resolvedFutureClasses);
    }

    ts.log("IMAGE TIMES: realize future classes");

    if (DebugNonFragileIvars) {
        realizeAllClasses();
    }


    // Print preoptimization statistics
    if (PrintPreopt) {
        static unsigned int PreoptTotalMethodLists;
        static unsigned int PreoptOptimizedMethodLists;
        static unsigned int PreoptTotalClasses;
        static unsigned int PreoptOptimizedClasses;

        for (EACH_HEADER) {
            if (hi->hasPreoptimizedSelectors()) {
                _objc_inform("PREOPTIMIZATION: honoring preoptimized selectors "
                             "in %s", hi->fname());
            }
            else if (hi->info()->optimizedByDyld()) {
                _objc_inform("PREOPTIMIZATION: IGNORING preoptimized selectors "
                             "in %s", hi->fname());
            }

            classref_t const *classlist = _getObjc2ClassList(hi, &count);
            for (i = 0; i < count; i++) {
                Class cls = remapClass(classlist[i]);
                if (!cls) continue;

                PreoptTotalClasses++;
                if (hi->hasPreoptimizedClasses()) {
                    PreoptOptimizedClasses++;
                }
                
                const method_list_t *mlist;
                if ((mlist = ((class_ro_t *)cls->data())->baseMethods())) {
                    PreoptTotalMethodLists++;
                    if (mlist->isFixedUp()) {
                        PreoptOptimizedMethodLists++;
                    }
                }
                if ((mlist=((class_ro_t *)cls->ISA()->data())->baseMethods())) {
                    PreoptTotalMethodLists++;
                    if (mlist->isFixedUp()) {
                        PreoptOptimizedMethodLists++;
                    }
                }
            }
        }

        _objc_inform("PREOPTIMIZATION: %zu selector references not "
                     "pre-optimized", UnfixedSelectors);
        _objc_inform("PREOPTIMIZATION: %u/%u (%.3g%%) method lists pre-sorted",
                     PreoptOptimizedMethodLists, PreoptTotalMethodLists, 
                     PreoptTotalMethodLists
                     ? 100.0*PreoptOptimizedMethodLists/PreoptTotalMethodLists 
                     : 0.0);
        _objc_inform("PREOPTIMIZATION: %u/%u (%.3g%%) classes pre-registered",
                     PreoptOptimizedClasses, PreoptTotalClasses, 
                     PreoptTotalClasses 
                     ? 100.0*PreoptOptimizedClasses/PreoptTotalClasses
                     : 0.0);
        _objc_inform("PREOPTIMIZATION: %zu protocol references not "
                     "pre-optimized", UnfixedProtocolReferences);
    }

#undef EACH_HEADER
}

通过代码中的注释，可以了解到：

• 条件控制进⾏⼀次的加载
• 修复预编译阶段的 @selector 的混乱问题
• 错误混乱的类处理
• 修复重映射⼀些没有被镜像⽂件加载进来的类
• 修复⼀些消息!
• 当我们类⾥⾯有协议的时候 : readProtocol
• 修复没有被加载的协议
• 分类处理
• 类的加载处理
• 没有被处理的类，优化那些被侵犯的类

在其中，发现了readClass函数的调用，通过函数名，其实就可以了解，此处就是加载类的地方，如图

此文先了解到这，下篇文章再仔细了解一下类的加载逻辑。

扩展 - 环境变量

在_objc_init中调用的environ_init函数的实现：

void environ_init(void) 
{
    //省略代码
    ...

    bool PrintHelp = false;
    bool PrintOptions = false;

    //省略代码
    ...

    // Print OBJC_HELP and OBJC_PRINT_OPTIONS output.
    if (PrintHelp  ||  PrintOptions) {
        //省略代码
        ...

        for (size_t i = 0; i < sizeof(Settings)/sizeof(Settings[0]); i++) {
            const option_t *opt = &Settings[i];            
            if (PrintHelp) _objc_inform("%s: %s", opt->env, opt->help);
            if (PrintOptions && *opt->var) _objc_inform("%s is set", opt->env);
        }
    }
}

通过产看最后for循环中的源码，可以打印所有的环境变量。但是被两个bool类型的变量控制。

• PrintHelp：环境变量和帮助说明。
• PrintOptions：当前环境变量的状态。
  objc源码是可调式的，我们可以修改PrintHelp=true，就可以打印看到所有的环境变量。

bool PrintHelp = false; 修改成=》 bool PrintHelp = true;

运行打印如下：

objc[47614]: Objective-C runtime debugging. Set variable=YES to enable.
objc[47614]: OBJC_HELP: describe available environment variables
objc[47614]: OBJC_HELP is set
objc[47614]: OBJC_PRINT_OPTIONS: list which options are set
objc[47614]: OBJC_PRINT_OPTIONS is set
objc[47614]: OBJC_PRINT_IMAGES: log image and library names as they are loaded
objc[47614]: OBJC_PRINT_IMAGE_TIMES: measure duration of image loading steps
objc[47614]: OBJC_PRINT_LOAD_METHODS: log calls to class and category +load methods
objc[47614]: OBJC_PRINT_INITIALIZE_METHODS: log calls to class +initialize methods
objc[47614]: OBJC_PRINT_RESOLVED_METHODS: log methods created by +resolveClassMethod: and +resolveInstanceMethod:
objc[47614]: OBJC_PRINT_CLASS_SETUP: log progress of class and category setup
objc[47614]: OBJC_PRINT_PROTOCOL_SETUP: log progress of protocol setup
objc[47614]: OBJC_PRINT_IVAR_SETUP: log processing of non-fragile ivars
objc[47614]: OBJC_PRINT_VTABLE_SETUP: log processing of class vtables
objc[47614]: OBJC_PRINT_VTABLE_IMAGES: print vtable images showing overridden methods
objc[47614]: OBJC_PRINT_CACHE_SETUP: log processing of method caches
objc[47614]: OBJC_PRINT_FUTURE_CLASSES: log use of future classes for toll-free bridging
objc[47614]: OBJC_PRINT_PREOPTIMIZATION: log preoptimization courtesy of dyld shared cache
objc[47614]: OBJC_PRINT_CXX_CTORS: log calls to C++ ctors and dtors for instance variables
objc[47614]: OBJC_PRINT_EXCEPTIONS: log exception handling
objc[47614]: OBJC_PRINT_EXCEPTION_THROW: log backtrace of every objc_exception_throw()
objc[47614]: OBJC_PRINT_ALT_HANDLERS: log processing of exception alt handlers
objc[47614]: OBJC_PRINT_REPLACED_METHODS: log methods replaced by category implementations
objc[47614]: OBJC_PRINT_DEPRECATION_WARNINGS: warn about calls to deprecated runtime functions
objc[47614]: OBJC_PRINT_POOL_HIGHWATER: log high-water marks for autorelease pools
objc[47614]: OBJC_PRINT_CUSTOM_CORE: log classes with custom core methods
objc[47614]: OBJC_PRINT_CUSTOM_RR: log classes with custom retain/release methods
objc[47614]: OBJC_PRINT_CUSTOM_AWZ: log classes with custom allocWithZone methods
objc[47614]: OBJC_PRINT_RAW_ISA: log classes that require raw pointer isa fields
objc[47614]: OBJC_DEBUG_UNLOAD: warn about poorly-behaving bundles when unloaded
objc[47614]: OBJC_DEBUG_FRAGILE_SUPERCLASSES: warn about subclasses that may have been broken by subsequent changes to superclasses
objc[47614]: OBJC_DEBUG_NIL_SYNC: warn about @synchronized(nil), which does no synchronization
objc[47614]: OBJC_DEBUG_NONFRAGILE_IVARS: capriciously rearrange non-fragile ivars
objc[47614]: OBJC_DEBUG_ALT_HANDLERS: record more info about bad alt handler use
objc[47614]: OBJC_DEBUG_MISSING_POOLS: warn about autorelease with no pool in place, which may be a leak
objc[47614]: OBJC_DEBUG_POOL_ALLOCATION: halt when autorelease pools are popped out of order, and allow heap debuggers to track autorelease pools
objc[47614]: OBJC_DEBUG_DUPLICATE_CLASSES: halt when multiple classes with the same name are present
objc[47614]: OBJC_DEBUG_DONT_CRASH: halt the process by exiting instead of crashing
objc[47614]: OBJC_DISABLE_VTABLES: disable vtable dispatch
objc[47614]: OBJC_DISABLE_PREOPTIMIZATION: disable preoptimization courtesy of dyld shared cache
objc[47614]: OBJC_DISABLE_TAGGED_POINTERS: disable tagged pointer optimization of NSNumber et al.
objc[47614]: OBJC_DISABLE_TAG_OBFUSCATION: disable obfuscation of tagged pointers
objc[47614]: OBJC_DISABLE_NONPOINTER_ISA: disable non-pointer isa fields
objc[47614]: OBJC_DISABLE_INITIALIZE_FORK_SAFETY: disable safety checks for +initialize after fork

OBJC_PRINT_LOAD_METHODS环境变量

OBJC_PRINT_LOAD_METHODS环境变量可以帮助我们打印所有的load方法的调用，添加环境变量的方式如图：

该工程是一个“空工程”，创建后仅仅在AppDelegate和ViewController中添加了+load方法。

运行后能看到工程中调用load方法的类。

使用场景：load方法中如果有耗时的操作，就会影响应用的启动速度，所以通过这种方式，可以很方便的查找。