在上一篇iOS原理探索11--dyld是如何關(guān)聯(lián)objc的呜象，我們了解obj是怎么和dyld關(guān)聯(lián)的芳誓，主要的函數(shù)_dyld_objc_notify_register(&map_images, load_images, unmap_image);知道map_images和load_images的重要性药蜻，本文主要探索類(lèi)的相關(guān)信息肌括，通過(guò)探索map_images和load_images狱从，了解類(lèi)是如何加載到內(nèi)存的撤师。

map_images

• mapImages:管理文件中和動(dòng)態(tài)庫(kù)中的所有符號(hào)，即class佳励、protocol、selector蛆挫、category等赃承；
• 主要是把Mach-O的類(lèi)加載到內(nèi)存中；
• 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[])
{
    static bool firstTime = YES;
    header_info *hList[mhCount];
    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();
    }

    if (PrintImages) {
        _objc_inform("IMAGES: processing %u newly-mapped images...\n", mhCount);
    }


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

    // Count classes. Size various table based on the total.
    int totalClasses = 0;
    int unoptimizedTotalClasses = 0;
    {
        ....省略代碼...
    }

    if (firstTime) {
        sel_init(selrefCount);
        arr_init();

#if SUPPORT_GC_COMPAT

        for (uint32_t i = 0; i < hCount; i++) {
            auto hi = hList[i];
            auto mh = hi->mhdr();
            if (mh->filetype != MH_EXECUTE  &&  shouldRejectGCImage(mh)) {
                _objc_fatal_with_reason
                    (OBJC_EXIT_REASON_GC_NOT_SUPPORTED, 
                     OS_REASON_FLAG_CONSISTENT_FAILURE, 
                     "%s requires Objective-C garbage collection "
                     "which is no longer supported.", hi->fname());
            }
        }
#endif

#if TARGET_OS_OSX

        if (dyld_get_program_sdk_version() < DYLD_MACOSX_VERSION_10_13) {
            DisableInitializeForkSafety = true;
            if (PrintInitializing) {
                _objc_inform("INITIALIZE: disabling +initialize fork "
                             "safety enforcement because the app is "
                             "too old (SDK version " SDK_FORMAT ")",
                             FORMAT_SDK(dyld_get_program_sdk_version()));
            }
        }

        for (uint32_t i = 0; i < hCount; i++) {
            auto hi = hList[i];
            auto mh = hi->mhdr();
            if (mh->filetype != MH_EXECUTE) continue;
            unsigned long size;
            if (getsectiondata(hi->mhdr(), "__DATA", "__objc_fork_ok", &size)) {
                DisableInitializeForkSafety = true;
                if (PrintInitializing) {
                    _objc_inform("INITIALIZE: disabling +initialize fork "
                                 "safety enforcement because the app has "
                                 "a __DATA,__objc_fork_ok section");
                }
            }
            break;  // assume only one MH_EXECUTE image
        }
#endif

    }
//_read_images這個(gè)是重點(diǎn)研究對(duì)象
    if (hCount > 0) {
        _read_images(hList, hCount, totalClasses, unoptimizedTotalClasses);
    }

    firstTime = NO;
    
    // Call image load funcs after everything is set up.
    for (auto func : loadImageFuncs) {
        for (uint32_t i = 0; i < mhCount; i++) {
            func(mhdrs[i]);
        }
    }
}

• _read_images源代碼
  _read_images主要是主要是加載類(lèi)信息悴侵，即類(lèi)瞧剖、分類(lèi)、協(xié)議等可免，進(jìn)入_read_images源碼實(shí)現(xiàn)抓于，主要分為以下幾部分：
  • 1、條件控制進(jìn)行的一次加載
  • 2浇借、修復(fù)預(yù)編譯階段的@selector的混亂問(wèn)題
  • 3捉撮、錯(cuò)誤混亂的類(lèi)處理
  • 4、修復(fù)重映射一些沒(méi)有被鏡像文件加載進(jìn)來(lái)的類(lèi)
  • 5逮刨、修復(fù)一些消息
  • 6呕缭、當(dāng)類(lèi)里面有協(xié)議時(shí)：readProtocol 讀取協(xié)議
  • 7堵泽、修復(fù)沒(méi)有被加載的協(xié)議
  • 8、分類(lèi)處理
  • 9恢总、類(lèi)的加載處理
  • 10迎罗、沒(méi)有被處理的類(lèi)，優(yōu)化那些被侵犯的類(lèi)

按照上面的幾個(gè)部分逐個(gè)分析一下_read_images的作用

• 1片仿、條件控制進(jìn)行的一次加載
  在doneOnce判斷流程中纹安，最關(guān)鍵的步驟在于，使用為了方便類(lèi)的查找NXCreateMapTable創(chuàng)建哈希表gdb_objc_realized_classes砂豌，并且這個(gè)哈希表用于存儲(chǔ)不在共享緩存且已命名類(lèi)厢岂，無(wú)論類(lèi)是否實(shí)現(xiàn)，其容量是類(lèi)數(shù)量的4/3阳距。

if (!doneOnce) {
     
    //...省略部分代碼...
    
    // namedClasses
    // Preoptimized classes don't go in this table.
    // 4/3 is NXMapTable's load factor
    int namedClassesSize = 
        (isPreoptimized() ? unoptimizedTotalClasses : totalClasses) * 4 / 3;
    //創(chuàng)建表（哈希表key-value）塔粒，目的是查找快
    gdb_objc_realized_classes =
        NXCreateMapTable(NXStrValueMapPrototype, namedClassesSize);

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

• 2、修復(fù)預(yù)編譯階段的@selector的混亂問(wèn)題

// Fix up @selector references 修復(fù)@selector引用
//sel 不是簡(jiǎn)單的字符串筐摘，而是帶地址的字符串
static size_t UnfixedSelectors;
{
    mutex_locker_t lock(selLock);
    for (EACH_HEADER) {
        if (hi->hasPreoptimizedSelectors()) continue;

        bool isBundle = hi->isBundle();
        //通過(guò)_getObjc2SelectorRefs拿到Mach-O中的靜態(tài)段__objc_selrefs
        SEL *sels = _getObjc2SelectorRefs(hi, &count);
        UnfixedSelectors += count;
        for (i = 0; i < count; i++) { //列表遍歷
            const char *name = sel_cname(sels[i]);
            //注冊(cè)sel操作卒茬，即將sel添加到
            SEL sel = sel_registerNameNoLock(name, isBundle);
            if (sels[i] != sel) {//當(dāng)sel與sels[i]地址不一致時(shí)，需要調(diào)整為一致的
                sels[i] = sel;
            }
        }
    }
}

sel_registerNameNoLock的源碼展示咖熟，主要是使用auto it = namedSelectors.get().insert(name);將sel插入到表中圃酵。

SEL sel_registerNameNoLock(const char *name, bool copy) {
    return __sel_registerName(name, 0, copy);  // NO lock, maybe copy
}

??
static SEL __sel_registerName(const char *name, bool shouldLock, bool copy) 
{
    SEL result = 0;

    if (shouldLock) selLock.assertUnlocked();
    else selLock.assertLocked();

    if (!name) return (SEL)0;

    result = search_builtins(name);
    if (result) return result;
    
    conditional_mutex_locker_t lock(selLock, shouldLock);
    auto it = namedSelectors.get().insert(name);//sel插入表
    if (it.second) {
        // No match. Insert.
        *it.first = (const char *)sel_alloc(name, copy);
    }
    return (SEL)*it.first;
}

• 3、錯(cuò)誤混亂的類(lèi)處理

//3馍管、錯(cuò)誤混亂的類(lèi)處理
// Discover classes. Fix up unresolved future classes. Mark bundle classes.
bool hasDyldRoots = dyld_shared_cache_some_image_overridden();
//讀取類(lèi)：readClass
for (EACH_HEADER) {
    if (! mustReadClasses(hi, hasDyldRoots)) {
        // Image is sufficiently optimized that we need not call readClass()
        continue;
    }
    //從編譯后的類(lèi)列表中取出所有類(lèi)郭赐，即從Mach-O中獲取靜態(tài)段__objc_classlist，是一個(gè)classref_t類(lèi)型的指針
    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];//此時(shí)獲取的cls只是一個(gè)地址
        Class newCls = readClass(cls, headerIsBundle, headerIsPreoptimized); //讀取類(lèi)确沸，經(jīng)過(guò)這步后捌锭，cls獲取的值才是一個(gè)名字
        //經(jīng)過(guò)調(diào)試，并未執(zhí)行if里面的流程
        //初始化所有懶加載的類(lèi)需要的內(nèi)存空間罗捎，但是懶加載類(lèi)的數(shù)據(jù)現(xiàn)在是沒(méi)有加載到的舀锨，連類(lèi)都沒(méi)有初始化
        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.
            //將懶加載的類(lèi)添加到數(shù)組中
            resolvedFutureClasses = (Class *)
                realloc(resolvedFutureClasses, 
                        (resolvedFutureClassCount+1) * sizeof(Class));
            resolvedFutureClasses[resolvedFutureClassCount++] = newCls;
        }
    }
}
ts.log("IMAGE TIMES: discover classes");

總結(jié)：這一步操作結(jié)束cls類(lèi)的信息目前僅存儲(chǔ)了地址+名稱(chēng)。

• 4宛逗、修復(fù)重映射一些沒(méi)有被鏡像文件加載進(jìn)來(lái)的類(lèi)

//4、修復(fù)重映射一些沒(méi)有被鏡像文件加載進(jìn)來(lái)的類(lèi)
// Fix up remapped classes 修正重新映射的類(lèi)
// Class list and nonlazy class list remain unremapped.類(lèi)列表和非惰性類(lèi)列表保持未映射
// Class refs and super refs are remapped for message dispatching.類(lèi)引用和超級(jí)引用將重新映射以進(jìn)行消息分發(fā)
//經(jīng)過(guò)調(diào)試盾剩，并未執(zhí)行if里面的流程
//將未映射的Class 和 Super Class重映射雷激，被remap的類(lèi)都是懶加載的類(lèi)
if (!noClassesRemapped()) {
    for (EACH_HEADER) {
      //獲取Mach-O中的靜態(tài)段__objc_classrefs即類(lèi)的引用
        Class *classrefs = _getObjc2ClassRefs(hi, &count);//Mach-O的靜態(tài)段 __objc_classrefs
        for (i = 0; i < count; i++) {
            remapClassRef(&classrefs[i]);
        }
        // fixme why doesn't test future1 catch the absence of this?
        //獲取Mach-O中的靜態(tài)段__objc_classrefs即父類(lèi)的引用
        classrefs = _getObjc2SuperRefs(hi, &count);//Mach_O中的靜態(tài)段 __objc_superrefs
        for (i = 0; i < count; i++) {
        //remapClassRef的類(lèi)都是懶加載的類(lèi)，所以最初經(jīng)過(guò)調(diào)試時(shí)告私，這部分代碼是沒(méi)有執(zhí)行的
            remapClassRef(&classrefs[i]);
        }
    }
}

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

• 5屎暇、修復(fù)一些消息

#if SUPPORT_FIXUP
    // Fix up old objc_msgSend_fixup call sites
    for (EACH_HEADER) {
        // _getObjc2MessageRefs 獲取Mach-O的靜態(tài)段 __objc_msgrefs
        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());
        }
        //經(jīng)過(guò)調(diào)試，并未執(zhí)行for里面的流程
        //遍歷將函數(shù)指針進(jìn)行注冊(cè)驻粟，并fix為新的函數(shù)指針
        for (i = 0; i < count; i++) {
            fixupMessageRef(refs+i);
        }
    }

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

• 6根悼、當(dāng)類(lèi)里面有協(xié)議時(shí)：readProtocol 讀取協(xié)議

// Discover protocols. Fix up protocol refs. 發(fā)現(xiàn)協(xié)議凶异。修正協(xié)議參考
//遍歷所有協(xié)議列表，并且將協(xié)議列表加載到Protocol的哈希表中
for (EACH_HEADER) {
    extern objc_class OBJC_CLASS_$_Protocol;
    //cls = Protocol類(lèi)挤巡，所有協(xié)議和對(duì)象的結(jié)構(gòu)體都類(lèi)似剩彬，isa都對(duì)應(yīng)Protocol類(lèi)
    Class cls = (Class)&OBJC_CLASS_$_Protocol;
    ASSERT(cls);
    //獲取protocol哈希表 -- protocol_map
    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();
    //通過(guò)_getObjc2ProtocolList 獲取到Mach-O中的靜態(tài)段__objc_protolist協(xié)議列表，
    //即從編譯器中讀取并初始化protocol
    protocol_t * const *protolist = _getObjc2ProtocolList(hi, &count);
    for (i = 0; i < count; i++) {
        //通過(guò)添加protocol到protocol_map哈希表中
        readProtocol(protolist[i], cls, protocol_map, 
                     isPreoptimized, isBundle);
    }
}

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

• 7矿卑、修復(fù)沒(méi)有被加載的協(xié)議

// 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;
    //_getObjc2ProtocolRefs 獲取到Mach-O的靜態(tài)段 __objc_protorefs
    protocol_t **protolist = _getObjc2ProtocolRefs(hi, &count);
    for (i = 0; i < count; i++) {//遍歷
        //比較當(dāng)前協(xié)議和協(xié)議列表中的同一個(gè)內(nèi)存地址的協(xié)議是否相同喉恋，如果不同則替換
        remapProtocolRef(&protolist[i]);//經(jīng)過(guò)代碼調(diào)試，并未執(zhí)行
    }
}

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

• 8母廷、分類(lèi)處理

// Discover categories. Only do this after the initial category 發(fā)現(xiàn)分類(lèi)
// 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");

• 9轻黑、類(lèi)的加載處理

// Realize non-lazy classes (for +load methods and static instances) 初始化非懶加載類(lèi)，進(jìn)行rw琴昆、ro等操作：realizeClassWithoutSwift
    //懶加載類(lèi) -- 別人不動(dòng)我氓鄙，我就不動(dòng)
    //實(shí)現(xiàn)非懶加載的類(lèi)，對(duì)于load方法和靜態(tài)實(shí)例變量
    for (EACH_HEADER) {
        //通過(guò)_getObjc2NonlazyClassList獲取Mach-O的靜態(tài)段__objc_nlclslist非懶加載類(lèi)表
        classref_t const *classlist = 
            _getObjc2NonlazyClassList(hi, &count);
        for (i = 0; i < count; i++) {
            Class cls = remapClass(classlist[i]);
            
            const char *mangledName  = cls->mangledName();
             const char *LGPersonName = "LGPerson";
            
             if (strcmp(mangledName, LGPersonName) == 0) {
                 auto kc_ro = (const class_ro_t *)cls->data();
                 printf("_getObjc2NonlazyClassList: 這個(gè)是我要研究的 %s \n",LGPersonName);
             }
            
            if (!cls) continue;

            addClassTableEntry(cls);//插入表业舍，但是前面已經(jīng)插入過(guò)了抖拦，所以不會(huì)重新插入

            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
            }
            //實(shí)現(xiàn)當(dāng)前的類(lèi)，因?yàn)榍懊鎟eadClass讀取到內(nèi)存的僅僅只有地址+名稱(chēng)勤讽，類(lèi)的data數(shù)據(jù)并沒(méi)有加載出來(lái)
            //實(shí)現(xiàn)所有非懶加載的類(lèi)(實(shí)例化類(lèi)對(duì)象的一些信息蟋座，例如rw)
            realizeClassWithoutSwift(cls, nil);
        }
    }

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

• 10、沒(méi)有被處理的類(lèi)脚牍，優(yōu)化那些被侵犯的類(lèi)

// 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");
            }
            //實(shí)現(xiàn)類(lèi)
            realizeClassWithoutSwift(cls, nil);
            cls->setInstancesRequireRawIsaRecursively(false/*inherited*/);
        }
        free(resolvedFutureClasses);
    }

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

    if (DebugNonFragileIvars) {
        //實(shí)現(xiàn)所有類(lèi)
        realizeAllClasses();
    }

那么上面步驟中的重點(diǎn)來(lái)了：readClass讀取類(lèi)

readClass方法主要是讀取類(lèi)向臀，在沒(méi)有調(diào)用該方法前，cls只是一個(gè)地址诸狭，執(zhí)行該方法后券膀，cls是類(lèi)的名稱(chēng)，其源碼實(shí)現(xiàn)如下

Class readClass(Class cls, bool headerIsBundle, bool headerIsPreoptimized)
{
    const char *mangledName  = cls->mangledName();
    const char *LGPersonName = "LGPerson";

    // printf("誒唷: %s \n ",mangledName);

    if (strcmp(mangledName, LGPersonName) == 0) {
        auto kc_ro = (const class_ro_t *)cls->data();
        printf("readClass: 這個(gè)是我要研究的 %s \n",LGPersonName);
    }

    //當(dāng)前類(lèi)的父類(lèi)中若有丟失的weak-linked類(lèi)驯遇，則返回nil
    if (missingWeakSuperclass(cls)) {
        // No superclass (probably weak-linked). 
        // Disavow any knowledge of this subclass.
        if (PrintConnecting) {
            _objc_inform("CLASS: IGNORING class '%s' with "
                         "missing weak-linked superclass", 
                         cls->nameForLogging());
        }
        addRemappedClass(cls, nil);
        cls->superclass = nil;
        return nil;
    }
    
    cls->fixupBackwardDeployingStableSwift();
    //判斷是不是后期要處理的類(lèi)
    //正常情況下芹彬，不會(huì)走到popFutureNamedClass，因?yàn)檫@是專(zhuān)門(mén)針對(duì)未來(lái)待處理的類(lèi)的操作
    //通過(guò)斷點(diǎn)調(diào)試叉庐，不會(huì)走到if流程里面舒帮，因此也不會(huì)對(duì)ro、rw進(jìn)行操作
    Class replacing = nil;
    if (Class newCls = popFutureNamedClass(mangledName)) {
        // This name was previously allocated as a future class.
        // Copy objc_class to future class's struct.
        // Preserve future's rw data block.
        
        if (newCls->isAnySwift()) {
            _objc_fatal("Can't complete future class request for '%s' "
                        "because the real class is too big.", 
                        cls->nameForLogging());
        }
        
        class_rw_t *rw = newCls->data();
        const class_ro_t *old_ro = rw->ro();
        memcpy(newCls, cls, sizeof(objc_class));
        rw->set_ro((class_ro_t *)newCls->data());
        newCls->setData(rw);
        freeIfMutable((char *)old_ro->name);
        free((void *)old_ro);
        
        addRemappedClass(cls, newCls);
        
        replacing = cls;
        cls = newCls;
    }
    //判斷是否類(lèi)是否已經(jīng)加載到內(nèi)存
    if (headerIsPreoptimized  &&  !replacing) {
        // class list built in shared cache
        // fixme strict assert doesn't work because of duplicates
        // ASSERT(cls == getClass(name));
        ASSERT(getClassExceptSomeSwift(mangledName));
    } else {
        //加載共享緩存中的類(lèi)
        addNamedClass(cls, mangledName, replacing);
        //插入表陡叠，即相當(dāng)于從mach-O文件 讀取到 內(nèi)存 中
        addClassTableEntry(cls);
    }

    // for future reference: shared cache never contains MH_BUNDLEs
    if (headerIsBundle) {
        cls->data()->flags |= RO_FROM_BUNDLE;
        cls->ISA()->data()->flags |= RO_FROM_BUNDLE;
    }
    
    return cls;
}

關(guān)鍵代碼是addNamedClass和addClassTableEntry玩郊，源碼實(shí)現(xiàn)如下

• addNamedClass源代碼

/***********************************************************************
* addNamedClass 加載共享緩存中的類(lèi) 插入表
* Adds name => cls to the named non-meta class map. 將name=> cls添加到命名的非元類(lèi)映射
* Warns about duplicate class names and keeps the old mapping.
* Locking: runtimeLock must be held by the caller
**********************************************************************/
static void addNamedClass(Class cls, const char *name, Class replacing = nil)
{
    runtimeLock.assertLocked();
    Class old;
    if ((old = getClassExceptSomeSwift(name))  &&  old != replacing) {
        inform_duplicate(name, old, cls);

        // getMaybeUnrealizedNonMetaClass uses name lookups.
        // Classes not found by name lookup must be in the
        // secondary meta->nonmeta table.
        addNonMetaClass(cls);
    } else {
        //添加到gdb_objc_realized_classes哈希表
        NXMapInsert(gdb_objc_realized_classes, name, cls);
    }
    ASSERT(!(cls->data()->flags & RO_META));

    // wrong: constructed classes are already realized when they get here
    // ASSERT(!cls->isRealized());
}

readClass源碼分析
第一步：首先通過(guò)const char *mangledName = cls->mangledName();獲取類(lèi)的名字，已經(jīng)初始化的從data()->ro()->name中獲取枉阵，反之從((const class_ro_t *)data())->name中獲取译红。
第二步：當(dāng)前類(lèi)的父類(lèi)中若有丟失的weak-linked類(lèi)，則返回nil
第三步：判斷是不是后期要處理的類(lèi)兴溜，正常情況下侦厚，不會(huì)走到popFutureNamedClass耻陕，因?yàn)檫@是專(zhuān)門(mén)針對(duì)未來(lái)待處理的類(lèi)的操作，通過(guò)斷點(diǎn)調(diào)試刨沦，不會(huì)走到if流程里面诗宣，因此也不會(huì)對(duì)ro、rw進(jìn)行操作已卷。
第四步：判斷是否類(lèi)是否已經(jīng)加載到內(nèi)存梧田，沒(méi)有的話加載共享緩存中的類(lèi)，插入表中侧蘸。

• addClassTableEntry源代碼

/***********************************************************************
* addClassTableEntry 將一個(gè)類(lèi)添加到所有類(lèi)的表中
* Add a class to the table of all classes. If addMeta is true,
* automatically adds the metaclass of the class as well.
* Locking: runtimeLock must be held by the caller.
**********************************************************************/
static void
addClassTableEntry(Class cls, bool addMeta = true)
{
    runtimeLock.assertLocked();

    // This class is allowed to be a known class via the shared cache or via
    // data segments, but it is not allowed to be in the dynamic table already.
    auto &set = objc::allocatedClasses.get();//開(kāi)辟的類(lèi)的表裁眯，在objc_init中的runtime_init就創(chuàng)建了表

    ASSERT(set.find(cls) == set.end());

    if (!isKnownClass(cls))
        set.insert(cls);
    if (addMeta)
        //添加到allocatedClasses哈希表
        addClassTableEntry(cls->ISA(), false);
}

總結(jié)：readClass的主要作用就是將Mach-O中的類(lèi)讀取到內(nèi)存，即插入表中讳癌，但是目前的類(lèi)僅有兩個(gè)信息：地址以及名稱(chēng)穿稳，而mach-O的其中的data數(shù)據(jù)還未讀取出來(lái)。

• realizeClassWithoutSwift：實(shí)現(xiàn)所有非懶加載的類(lèi)(實(shí)例化類(lèi)對(duì)象的一些信息晌坤，例如rw)

• realizeClassWithoutSwift源碼

realizeClassWithoutSwift(Class cls, Class previously)
{
    runtimeLock.assertLocked();

    class_rw_t *rw;
    Class supercls;
    Class metacls;
    
    const char *mangledName  = cls->mangledName();
    const char *LGPersonName = "LGPerson";

    if (strcmp(mangledName, LGPersonName) == 0) {
        auto kc_ro = (const class_ro_t *)cls->data();
        auto kc_isMeta = kc_ro->flags & RO_META;
        if (!kc_isMeta) {
            printf("%s: 這個(gè)是我要研究的 %s \n",__func__,LGPersonName);
        }
    }

    if (!cls) return nil;
    if (cls->isRealized()) return cls;
    ASSERT(cls == remapClass(cls));

    // fixme verify class is not in an un-dlopened part of the shared cache?

    auto ro = (const class_ro_t *)cls->data();
    auto isMeta = ro->flags & RO_META;
    if (ro->flags & RO_FUTURE) {
        // This was a future class. rw data is already allocated.
        rw = cls->data();
        ro = cls->data()->ro();
        ASSERT(!isMeta);
        cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
    } else {
        // Normal class. Allocate writeable class data.
        //此時(shí)將數(shù)據(jù)讀取進(jìn)來(lái)了逢艘，也賦值完畢了
        rw = objc::zalloc<class_rw_t>();//申請(qǐng)開(kāi)辟zalloc--rw
        rw->set_ro(ro);//rw中的ro設(shè)置為臨時(shí)變量ro
        rw->flags = RW_REALIZED|RW_REALIZING|isMeta;
        cls->setData(rw);//將cls的data賦值為rw形式
    }

#if FAST_CACHE_META
    if (isMeta) cls->cache.setBit(FAST_CACHE_META);
#endif

    // Choose an index for this class.
    // Sets cls->instancesRequireRawIsa if indexes no more indexes are available
    cls->chooseClassArrayIndex();

    if (PrintConnecting) {
        _objc_inform("CLASS: realizing class '%s'%s %p %p #%u %s%s",
                     cls->nameForLogging(), isMeta ? " (meta)" : "", 
                     (void*)cls, ro, cls->classArrayIndex(),
                     cls->isSwiftStable() ? "(swift)" : "",
                     cls->isSwiftLegacy() ? "(pre-stable swift)" : "");
    }

    // Realize superclass and metaclass, if they aren't already.
    // This needs to be done after RW_REALIZED is set above, for root classes.
    // This needs to be done after class index is chosen, for root metaclasses.
    // This assumes that none of those classes have Swift contents,
    //   or that Swift's initializers have already been called.
    //   fixme that assumption will be wrong if we add support
    //   for ObjC subclasses of Swift classes.
    //第二步：遞歸調(diào)用realizeClassWithoutSwift，來(lái)完善繼承鏈骤菠，并且處理當(dāng)前的父類(lèi)它改，元類(lèi)
    //遞歸實(shí)現(xiàn)設(shè)置當(dāng)前類(lèi)、父類(lèi)商乎、元類(lèi)的rw央拖，主要的目的是確定繼承鏈
    //當(dāng)isa找到根源類(lèi)之后，根源類(lèi)的isa是指向自己的鹉戚，不會(huì)返回nil
    //從而導(dǎo)致死循環(huán)——remapClass中對(duì)類(lèi)在表中進(jìn)行查找的操作鲜戒，如果表中已有該類(lèi)，則返回一個(gè)空值抹凳；
    //如果沒(méi)有則返回當(dāng)前類(lèi)遏餐，這樣保證了類(lèi)只加載一次并結(jié)束遞歸
    supercls = realizeClassWithoutSwift(remapClass(cls->superclass), nil);
    metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil);

#if SUPPORT_NONPOINTER_ISA
    if (isMeta) {
        // Metaclasses do not need any features from non pointer ISA
        // This allows for a faspath for classes in objc_retain/objc_release.
        cls->setInstancesRequireRawIsa();
    } else {
        // Disable non-pointer isa for some classes and/or platforms.
        // Set instancesRequireRawIsa.
        bool instancesRequireRawIsa = cls->instancesRequireRawIsa();
        bool rawIsaIsInherited = false;
        static bool hackedDispatch = false;

        if (DisableNonpointerIsa) {
            // Non-pointer isa disabled by environment or app SDK version
            instancesRequireRawIsa = true;
        }
        else if (!hackedDispatch  &&  0 == strcmp(ro->name, "OS_object"))
        {
            // hack for libdispatch et al - isa also acts as vtable pointer
            hackedDispatch = true;
            instancesRequireRawIsa = true;
        }
        else if (supercls  &&  supercls->superclass  &&
                 supercls->instancesRequireRawIsa())
        {
            // This is also propagated by addSubclass()
            // but nonpointer isa setup needs it earlier.
            // Special case: instancesRequireRawIsa does not propagate
            // from root class to root metaclass
            instancesRequireRawIsa = true;
            rawIsaIsInherited = true;
        }

        if (instancesRequireRawIsa) {
            cls->setInstancesRequireRawIsaRecursively(rawIsaIsInherited);
        }
    }
// SUPPORT_NONPOINTER_ISA
#endif

    // Update superclass and metaclass in case of remapping
    // 將父類(lèi)和元類(lèi)給我們的類(lèi) 分別是isa和父類(lèi)的對(duì)應(yīng)值
    cls->superclass = supercls;
    cls->initClassIsa(metacls);

    // Reconcile instance variable offsets / layout.
    // This may reallocate class_ro_t, updating our ro variable.
    if (supercls  &&  !isMeta) reconcileInstanceVariables(cls, supercls, ro);

    // Set fastInstanceSize if it wasn't set already.
    cls->setInstanceSize(ro->instanceSize);

    // Copy some flags from ro to rw
    if (ro->flags & RO_HAS_CXX_STRUCTORS) {
        cls->setHasCxxDtor();
        if (! (ro->flags & RO_HAS_CXX_DTOR_ONLY)) {
            cls->setHasCxxCtor();
        }
    }
    
    // Propagate the associated objects forbidden flag from ro or from
    // the superclass.
    if ((ro->flags & RO_FORBIDS_ASSOCIATED_OBJECTS) ||
        (supercls && supercls->forbidsAssociatedObjects()))
    {
        rw->flags |= RW_FORBIDS_ASSOCIATED_OBJECTS;
    }

    // Connect this class to its superclass's subclass lists
    //雙向鏈表指向關(guān)系 父類(lèi)中可以找到子類(lèi) 子類(lèi)中也可以找到父類(lèi)
    //通過(guò)addSubclass把當(dāng)前類(lèi)放到父類(lèi)的子類(lèi)列表中去
    if (supercls) {
        addSubclass(supercls, cls);
    } else {
        addRootClass(cls);
    }

    // Attach categories
    //方法：將屬性列表、方法列表赢底、協(xié)議列表等貼到rwe中
    methodizeClass(cls, previously);

    return cls;
}

• realizeClassWithoutSwift步驟分析

realizeClassWithoutSwift從源代碼中可以得出失都，主要是實(shí)現(xiàn)類(lèi)，如果沒(méi)有實(shí)現(xiàn)就將data中的數(shù)據(jù)加載到內(nèi)存中幸冻。
第一步：將data中的數(shù)據(jù)讀取到rw和ro;
第二步：雙向鏈表指向關(guān)系嗅剖，父類(lèi)中可以找到子類(lèi) 子類(lèi)中也可以找到父類(lèi)嘁扼；
第三步：方法：將屬性列表、方法列表黔攒、協(xié)議列表等貼到rwe中

• 【第一步】data數(shù)據(jù)的讀取趁啸，rw初始化强缘，并且將ro(ro表示 readOnly，即只讀不傅，其在編譯時(shí)就已經(jīng)確定了內(nèi)存旅掂，包含類(lèi)名稱(chēng)、方法访娶、協(xié)議和實(shí)例變量的信息商虐，由于是只讀的，所以屬于Clean Memory崖疤，而Clean Memory是指加載后不會(huì)發(fā)生更改的內(nèi)存)數(shù)據(jù)拷貝一份到rw(rw 表示 readWrite秘车，即可讀可寫(xiě)，由于其動(dòng)態(tài)性劫哼，可能會(huì)往類(lèi)中添加屬性叮趴、方法、添加協(xié)議)的ro中权烧。

   auto ro = (const class_ro_t *)cls->data();
    auto isMeta = ro->flags & RO_META;
    if (ro->flags & RO_FUTURE) {
        // This was a future class. rw data is already allocated.
        rw = cls->data();
        ro = cls->data()->ro();
        ASSERT(!isMeta);
        cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
    } else {
        // Normal class. Allocate writeable class data.
        //此時(shí)將數(shù)據(jù)讀取進(jìn)來(lái)了眯亦，也賦值完畢了
        rw = objc::zalloc<class_rw_t>();//申請(qǐng)開(kāi)辟zalloc--rw
        rw->set_ro(ro);//rw中的ro設(shè)置為臨時(shí)變量ro
        rw->flags = RW_REALIZED|RW_REALIZING|isMeta;
        cls->setData(rw);//將cls的data賦值為rw形式
    }

• 【第二步】完善繼承鏈，遞歸實(shí)現(xiàn)realizeClassWithoutSwift來(lái)完善繼承鏈般码，并將父類(lèi)和元類(lèi)給當(dāng)前類(lèi)妻率，分別是isa和父類(lèi)的對(duì)應(yīng)值，通過(guò)addSubclass 和 addRootClass設(shè)置父子的雙向鏈表指向關(guān)系板祝，即父類(lèi)中可以找到子類(lèi)宫静，子類(lèi)中可以找到父類(lèi)。

 // Realize superclass and metaclass, if they aren't already.
    // This needs to be done after RW_REALIZED is set above, for root classes.
    // This needs to be done after class index is chosen, for root metaclasses.
    // This assumes that none of those classes have Swift contents,
    //   or that Swift's initializers have already been called.
    //   fixme that assumption will be wrong if we add support
    //   for ObjC subclasses of Swift classes. --
    //遞歸調(diào)用realizeClassWithoutSwift完善繼承鏈,并處理當(dāng)前類(lèi)的父類(lèi)扔字、元類(lèi)
    //遞歸實(shí)現(xiàn) 設(shè)置當(dāng)前類(lèi)囊嘉、父類(lèi)、元類(lèi)的 rw革为，主要目的是確定繼承鏈 （類(lèi)繼承鏈扭粱、元類(lèi)繼承鏈）
    //實(shí)現(xiàn)元類(lèi)、父類(lèi)
    //當(dāng)isa找到根元類(lèi)之后震檩，根元類(lèi)的isa是指向自己的琢蛤，不會(huì)返回nil從而導(dǎo)致死循環(huán)——remapClass中對(duì)類(lèi)在表中進(jìn)行查找的操作，如果表中已有該類(lèi)抛虏，則返回一個(gè)空值博其；如果沒(méi)有則返回當(dāng)前類(lèi)，這樣保證了類(lèi)只加載一次并結(jié)束遞歸
    supercls = realizeClassWithoutSwift(remapClass(cls->superclass), nil);
    metacls = realizeClassWithoutSwift(remapClass(cls->ISA()), nil);
    
...

// Update superclass and metaclass in case of remapping -- class 是 雙向鏈表結(jié)構(gòu) 即父子關(guān)系都確認(rèn)了
// 將父類(lèi)和元類(lèi)給我們的類(lèi) 分別是isa和父類(lèi)的對(duì)應(yīng)值
cls->superclass = supercls;
cls->initClassIsa(metacls);

...

// Connect this class to its superclass's subclass lists
//雙向鏈表指向關(guān)系 父類(lèi)中可以找到子類(lèi) 子類(lèi)中也可以找到父類(lèi)
//通過(guò)addSubclass把當(dāng)前類(lèi)放到父類(lèi)的子類(lèi)列表中去
if (supercls) {
    addSubclass(supercls, cls);
} else {
    addRootClass(cls);
}

-【第三步】methodizeClass方法將屬性列表迂猴、方法列表慕淡、協(xié)議列表等貼到rwe中

/***********************************************************************
* methodizeClass
* Fixes up cls's method list, protocol list, and property list.
* Attaches any outstanding categories.
* Locking: runtimeLock must be held by the caller
**********************************************************************/
static void methodizeClass(Class cls, Class previously)
{
    runtimeLock.assertLocked();

    bool isMeta = cls->isMetaClass();
    auto rw = cls->data();//初始化一個(gè)rw
    auto ro = rw->ro();
    auto rwe = rw->ext();
    
    const char *mangledName  = cls->mangledName();
    const char *LGPersonName = "LGPerson";

    if (strcmp(mangledName, LGPersonName) == 0) {
        bool kc_isMeta = cls->isMetaClass();
        auto kc_rw = cls->data();
        auto kc_ro = kc_rw->ro();
        if (!kc_isMeta) {
            printf("%s: 這個(gè)是我要研究的 %s \n",__func__,LGPersonName);
        }
    }

    // Methodizing for the first time
    if (PrintConnecting) {
        _objc_inform("CLASS: methodizing class '%s' %s", 
                     cls->nameForLogging(), isMeta ? "(meta)" : "");
    }

    // Install methods and properties that the class implements itself.
    //將屬性列表、方法列表沸毁、協(xié)議列表等貼到rw中
    // 將ro中的方法列表加入到rw中
    method_list_t *list = ro->baseMethods();
    if (list) {
        //進(jìn)行方法排序
        prepareMethodLists(cls, &list, 1, YES, isBundleClass(cls));
        if (rwe) rwe->methods.attachLists(&list, 1);
    }
     //加入屬性
    property_list_t *proplist = ro->baseProperties;
    if (rwe && proplist) {
        rwe->properties.attachLists(&proplist, 1);
    }
    //加入列表
    protocol_list_t *protolist = ro->baseProtocols;
    if (rwe && protolist) {
        rwe->protocols.attachLists(&protolist, 1);
    }

    // Root classes get bonus method implementations if they don't have 
    // them already. These apply before category replacements.
    if (cls->isRootMetaclass()) {
        // root metaclass
        addMethod(cls, @selector(initialize), (IMP)&objc_noop_imp, "", NO);
    }

    // Attach categories.
    //加入分類(lèi)
    if (previously) {
        if (isMeta) {
        
            objc::unattachedCategories.attachToClass(cls, previously,
                                                     ATTACH_METACLASS);
        } else {
            // When a class relocates, categories with class methods
            // may be registered on the class itself rather than on
            // the metaclass. Tell attachToClass to look for those.
            objc::unattachedCategories.attachToClass(cls, previously,
                                                     ATTACH_CLASS_AND_METACLASS);
        }
    }
    objc::unattachedCategories.attachToClass(cls, cls,
                                             isMeta ? ATTACH_METACLASS : ATTACH_CLASS);

#if DEBUG
    // Debug: sanity-check all SELs; log method list contents
    for (const auto& meth : rw->methods()) {
        if (PrintConnecting) {
            _objc_inform("METHOD %c[%s %s]", isMeta ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(meth.name));
        }
        ASSERT(sel_registerName(sel_getName(meth.name)) == meth.name); 
    }
#endif
}