RunTime解析--Category(分类)实现

// 分类
struct category_t {
    // 分类名
    const char *name;
    // 原始类
    classref_t cls;
    // 对象方法列表
    struct method_list_t *instanceMethods;
    // 类方法列表
    struct method_list_t *classMethods;
    // 协议列表
    struct protocol_list_t *protocols;
    // 实例属性
    struct property_list_t *instanceProperties;
    // Fields below this point are not always present on disk.
    // 类属性(这个结构体以_开头命名？？？)
    struct property_list_t *_classProperties;
    // methodsForMeta 返回类方法列表或者对象方法列表
    method_list_t *methodsForMeta(bool isMeta) {
        if (isMeta) return classMethods;
        else return instanceMethods;
    }
    // 属性列表返回方法
    property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};

@interface PrimaryObject : NSObject

- (void)test;

@end


@interface PrimaryObject (Demo)

@end

@implementation PrimaryObject

- (void)test {
    NSLog(@"PrimaryObject---test");
}

@end



@implementation PrimaryObject (Demo)

- (void)test {
    NSLog(@"PrimaryObject-Demo---test");
}

@end

void _objc_init(void)
{
    static bool initialized = false;
    if (initialized) return;
    initialized = true;
    
    // fixme defer initialization until an objc-using image is found?
//	读取runtime的环境变量，如果需要则打印出来
    environ_init();
	
    tls_init();
	//运行c++ 构造函数
    static_init();
	//lock 初始化 暂时是空的函数
    lock_init();
	//初始化系统异常操作
    exception_init();
	/*
	 仅供objc运行时使用，注册在映射、取消映射和初始化objc映像调用的处理程序。dyld将使用包含objc-image-info回调给`mapped`.
	 这些dylibs将自动引用计数，因此objc将不再需要调用dlopen()防止未加载。
	 在调用_dyld_objc_notify_register()期间，dyld将调用 `mapped` 在已经加载好 images，稍后dlopen()。
	 在调动init的时候也会调用`mapped`,在dyld调用的时候，也会调用init函数
	 
	 在调用任何images +load方法时候
	 */
    _dyld_objc_notify_register(&map_images, load_images, unmap_image);
}

// 仅供objc运行时使用
// Note: only for use by objc runtime
// 当objc镜像在映射、取消映射、和初始化时注册的事件会被调
// Register handlers to be called when objc images are mapped, unmapped, and initialized.
// Dyld会回调给将mapped函数一组包含objc-image-info段
// Dyld will call back the "mapped" function with an array of images that contain an objc-image-info section.
// 这些dylibs 将自动引用计数，因此objc将不再需要调用dlopen()防止未加载
// Those images that are dylibs will have the ref-counts automatically bumped, so objc will no longer need to
// call dlopen() on them to keep them from being unloaded.  During the call to _dyld_objc_notify_register(),
// 在调用_dyld_objc_notify_register()期间 dyld将调用 `mapped` 在已经加载好 images，稍后dlopen()。
// dyld will call the "mapped" function with already loaded objc images.  During any later dlopen() call,
// 在调动init的时候也会调用`mapped`,在dyld调用的时候，也会调用init函数
// dyld will also call the "mapped" function.  Dyld will call the "init" function when dyld would be called
// 在调用任何images +load方法时候
// initializers in that image.  This is when objc calls any +load methods in that image.
void _dyld_objc_notify_register(_dyld_objc_notify_mapped    mapped,
                                _dyld_objc_notify_init      init,
                                _dyld_objc_notify_unmapped  unmapped);

// dyld将image加到内存中后调用
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);
}

void 
map_images_nolock(unsigned mhCount, const char * const mhPaths[],
                  const struct mach_header * const mhdrs[])
{   
    // 当头文件个数大于0调用_read_images方法
    if (hCount > 0) {
        _read_images(hList, hCount, totalClasses, unoptimizedTotalClasses);
    }

}

// 
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;
    TimeLogger ts(PrintImageTimes);

    runtimeLock.assertLocked();

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

    if (!doneOnce) {
        doneOnce = YES;

        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);
        
        allocatedClasses = NXCreateHashTable(NXPtrPrototype, 0, nil);
        
        ts.log("IMAGE TIMES: first time tasks");
    }


    // Discover classes. Fix up unresolved future classes. Mark bundle classes.

    for (EACH_HEADER) {
        classref_t *classlist = _getObjc2ClassList(hi, &count);
        
        if (! mustReadClasses(hi)) {
            // Image is sufficiently optimized that we need not call readClass()
            continue;
        }

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

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

    // Fix up @selector references
    static size_t UnfixedSelectors;
    {
        mutex_locker_t lock(selLock);
        for (EACH_HEADER) {
            if (hi->isPreoptimized()) 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]);
                sels[i] = sel_registerNameNoLock(name, isBundle);
            }
        }
    }

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

#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

    // 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->isPreoptimized();
        bool isBundle = hi->isBundle();

        protocol_t **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) {
        protocol_t **protolist = _getObjc2ProtocolRefs(hi, &count);
        for (i = 0; i < count; i++) {
            remapProtocolRef(&protolist[i]);
        }
    }

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

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

            // hack for class __ARCLite__, which didn't get this above
#if TARGET_OS_SIMULATOR
            if (cls->cache._buckets == (void*)&_objc_empty_cache  &&  
                (cls->cache._mask  ||  cls->cache._occupied)) 
            {
                cls->cache._mask = 0;
                cls->cache._occupied = 0;
            }
            if (cls->ISA()->cache._buckets == (void*)&_objc_empty_cache  &&  
                (cls->ISA()->cache._mask  ||  cls->ISA()->cache._occupied)) 
            {
                cls->ISA()->cache._mask = 0;
                cls->ISA()->cache._occupied = 0;
            }
#endif
            
            addClassTableEntry(cls);
            realizeClass(cls);
        }
    }

    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++) {
            realizeClass(resolvedFutureClasses[i]);
            resolvedFutureClasses[i]->setInstancesRequireRawIsa(false/*inherited*/);
        }
        free(resolvedFutureClasses);
    }    

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

    // Discover categories.
    // #define EACH_HEADER hIndex = 0; hIndex < hCount && (hi = hList[hIndex]); hIndex++
    for (EACH_HEADER) {
        //GETSECT(_getObjc2CategoryList,        category_t *,    "__objc_catlist");
        // 从__objc_catlist获取方法列表
        category_t **catlist = 
            _getObjc2CategoryList(hi, &count);
        // 是否有分类添加的属性
        bool hasClassProperties = hi->info()->hasCategoryClassProperties();
        // 遍历所有分类
        for (i = 0; i < count; i++) {
            // 取出每一个分类
            category_t *cat = catlist[i];
            //
            Class cls = remapClass(cat->cls);

            if (!cls) {
                // Category's target class is missing (probably weak-linked).
                // Disavow any knowledge of this category.
                catlist[i] = nil;
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class", 
                                 cat->name, cat);
                }
                continue;
            }

            // Process this category. 
            // First, register the category with its target class. 
            // Then, rebuild the class's method lists (etc) if 
            // the class is realized.

            bool classExists = NO;
            // 如果这个类的instanceMethods、protocols、instanceProperties有值
            if (cat->instanceMethods ||  cat->protocols  
                ||  cat->instanceProperties) 
            {
                //
                addUnattachedCategoryForClass(cat, cls, hi);

                if (cls->isRealized()) {
                    remethodizeClass(cls);
                    classExists = YES;
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category -%s(%s) %s", 
                                 cls->nameForLogging(), cat->name, 
                                 classExists ? "on existing class" : "");
                }
            }

            if (cat->classMethods  ||  cat->protocols  
                ||  (hasClassProperties && cat->_classProperties)) 
            {
                addUnattachedCategoryForClass(cat, cls->ISA(), hi);
                if (cls->ISA()->isRealized()) {
                    remethodizeClass(cls->ISA());
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category +%s(%s)", 
                                 cls->nameForLogging(), cat->name);
                }
            }
        }
    }

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

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

    // +load handled by prepare_load_methods()

    if (DebugNonFragileIvars) {
        realizeAllClasses();
    }

#undef EACH_HEADER
}

for (EACH_HEADER) {
        classref_t *classlist = _getObjc2ClassList(hi, &count);
}

for (EACH_HEADER) {
            Class *classrefs = _getObjc2ClassRefs(hi, &count);
}
 
for (EACH_HEADER) {
    SEL *sels = _getObjc2SelectorRefs(hi, &count);
}

for (EACH_HEADER) {
        message_ref_t *refs = _getObjc2MessageRefs(hi, &count);
}
for (EACH_HEADER) {
        protocol_t **protolist = _getObjc2ProtocolList(hi, &count);
}

for (EACH_HEADER) {
        protocol_t **protolist = _getObjc2ProtocolRefs(hi, &count);
}
for (EACH_HEADER) {
        classref_t *classlist = 
            _getObjc2NonlazyClassList(hi, &count);
}
for (EACH_HEADER) {
        category_t **catlist = 
            _getObjc2CategoryList(hi, &count);
}

//      function name                 content type     section name
GETSECT(_getObjc2SelectorRefs,        SEL,             "__objc_selrefs"); 
GETSECT(_getObjc2MessageRefs,         message_ref_t,   "__objc_msgrefs"); 
GETSECT(_getObjc2ClassRefs,           Class,           "__objc_classrefs");
GETSECT(_getObjc2SuperRefs,           Class,           "__objc_superrefs");
GETSECT(_getObjc2ClassList,           classref_t,      "__objc_classlist");
GETSECT(_getObjc2NonlazyClassList,    classref_t,      "__objc_nlclslist");
GETSECT(_getObjc2CategoryList,        category_t *,    "__objc_catlist");
GETSECT(_getObjc2NonlazyCategoryList, category_t *,    "__objc_nlcatlist");
GETSECT(_getObjc2ProtocolList,        protocol_t *,    "__objc_protolist");
GETSECT(_getObjc2ProtocolRefs,        protocol_t *,    "__objc_protorefs");
GETSECT(getLibobjcInitializers,       UnsignedInitializer, "__objc_init_func");

    // 遍历所有分类
    for (i = 0; i < count; i++) {
        // 取出每一个分类
        category_t *cat = catlist[i];
        // 调用remapClass(cat->cls)，并返回一个objc_class *对象cls。这一步的目的在于找到到category对应的类对象cls
        Class cls = remapClass(cat->cls);

        if (!cls) {
            // Category's target class is missing (probably weak-linked).
            // Disavow any knowledge of this category.
            catlist[i] = nil;
            if (PrintConnecting) {
                _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                             "missing weak-linked target class", 
                             cat->name, cat);
            }
            continue;
        }

        bool classExists = NO;
        // 如果这个类的instanceMethods、protocols、instanceProperties有值
        // 如果Category中有实例方法，协议，实例属性，会改写target class的结构
        if (cat->instanceMethods ||  cat->protocols  
            ||  cat->instanceProperties) 
        {
            //
            addUnattachedCategoryForClass(cat, cls, hi);
            //修改class的method list结构
            if (cls->isRealized()) {
                remethodizeClass(cls);
                classExists = YES;
            }
            if (PrintConnecting) {
                _objc_inform("CLASS: found category -%s(%s) %s", 
                             cls->nameForLogging(), cat->name, 
                             classExists ? "on existing class" : "");
            }
        }

        // 如果category中有类方法，协议，或类属性(目前OC版本不支持类属性), 会改写target class的元类结构
        if (cat->classMethods  ||  cat->protocols  
            ||  (hasClassProperties && cat->_classProperties)) 
        {
            addUnattachedCategoryForClass(cat, cls->ISA(), hi);

            // 修改class的method list结构
            if (cls->ISA()->isRealized()) {
                remethodizeClass(cls->ISA());
            }
            if (PrintConnecting) {
                _objc_inform("CLASS: found category +%s(%s)", 
                             cls->nameForLogging(), cat->name);
            }
        }
    }
}

// 把类和category做一个关联映射
//  category_t *cat 分类
//  Class cls 原始类
//  header_info *catHeader 分类头信息
static void addUnattachedCategoryForClass(category_t *cat, Class cls, 
                                          header_info *catHeader)
{
    runtimeLock.assertLocked();

    // DO NOT use cat->cls! cls may be cat->cls->isa instead
    // 初始化一个分类表(这里是一个table)
    NXMapTable *cats = unattachedCategories();
    // 分类list
    category_list *list;
    // 获取原始类cls元有的分类表
    list = (category_list *)NXMapGet(cats, cls);
    // 如果之前没有 那么新建
    if (!list) {
        list = (category_list *)
            calloc(sizeof(*list) + sizeof(list->list[0]), 1);
    } else {
        // 如果之前已经有了 那么扩容list->count + 1
        list = (category_list *)
            realloc(list, sizeof(*list) + sizeof(list->list[0]) * (list->count + 1));
    }
    // 将这个分类的信息放到与原始类相关的表中
    list->list[list->count++] = (locstamped_category_t){cat, catHeader};

    NXMapInsert(cats, cls, list);
}

static void remethodizeClass(Class cls)
{
    category_list *cats;
    bool isMeta;

    runtimeLock.assertLocked();

    isMeta = cls->isMetaClass();

    // 取出还未被附加到class上的category list
    if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
        if (PrintConnecting) {
            _objc_inform("CLASS: attaching categories to class '%s' %s", 
                         cls->nameForLogging(), isMeta ? "(meta)" : "");
        }
        // 将category附加到class上
        attachCategories(cls, cats, true /*flush caches*/);        
        free(cats);
    }
}

// 链接 分类中的 方法列表 属性和协议 到类中
// Class cls  原始类
// category_list *cats 分类列表
// bool flush_caches 是否需要刷新缓存
static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if (!cats) return;

    if (PrintReplacedMethods) printReplacements(cls, cats);

    bool isMeta = cls->isMetaClass();

    // fixme rearrange to remove these intermediate allocations
    // 首先分配method_list_t *， property_list_t *， protocol_list_t *的数组空间，数组大小等于category的个数
    //方法数组 二维数组 每个分类的方法是数组中的一个元素 每个分类可能有多个方法
    method_list_t **mlists = (method_list_t **)
        malloc(cats->count * sizeof(*mlists));
	//属性数组
    property_list_t **proplists = (property_list_t **)
        malloc(cats->count * sizeof(*proplists));
	//协议数组
    protocol_list_t **protolists = (protocol_list_t **)
        malloc(cats->count * sizeof(*protolists));

    // Count backwards through cats to get newest categories first
    int mcount = 0;
    int propcount = 0;
    int protocount = 0;
    // i表示分类的个数
    int i = cats->count;
    bool fromBundle = NO;
    //依次读取每一个category，将其methods，property，protocol添加到mlists，proplist，protolist中存储
    while (i--) {
		//取出某个分类
        auto& entry = cats->list[i];
        //取出分类 的 对象方法或者类方法
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        // 将方法列表加入都mlists中(注意mlist本身也是个数组) 因此mlists是一个二维数组
        if (mlist) {
            mlists[mcount++] = mlist; //mlists 接受所有分类方法
            fromBundle |= entry.hi->isBundle();
        }
        //proplist 所有分类属性
        property_list_t *proplist = 
            entry.cat->propertiesForMeta(isMeta, entry.hi);

        if (proplist) {
            proplists[propcount++] = proplist;
        }

        //proplist 所有协议方法
        protocol_list_t *protolist = entry.cat->protocols;
        if (protolist) {
            protolists[protocount++] = protolist;
        }
    }

    // 取出class的data()数据，其实是class_rw_t * 指针，其对应结构体实例存储了class的基本信息
    auto rw = cls->data();

    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
	//将category中的method 添加到class中
    rw->methods.attachLists(mlists, mcount);
	//释放数组
    free(mlists);

	// 如果需要，同时刷新class的method list cache
    if (flush_caches  &&  mcount > 0) flushCaches(cls);

    // 将category的property添加到class中
    rw->properties.attachLists(proplists, propcount);
    //释放数组
    free(proplists);


    // 将category的protocol添加到class中
    rw->protocols.attachLists(protolists, protocount);
    //释放数组
    free(protolists);
}

struct class_rw_t {
    method_array_t methods;//方法列表
    property_array_t properties;//属性列表
    protocol_array_t protocols;//协议列表

 // 要添加的list 要添加的个数
    void attachLists(List* const * addedLists, uint32_t addedCount) {
        if (addedCount == 0) return;
        
        if (hasArray()) {
            // 就list的个数
            uint32_t oldCount = array()->count;
			// 添加后list的个数
            uint32_t newCount = oldCount + addedCount;
			//分配内存 内存不够用了，需要扩容
            setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
			//赋值count
            array()->count = newCount;

			// array()->lists：原来的方法列表向后移动 oldCount * sizeof(array()->lists[0]个长度
            memmove(array()->lists + addedCount/*数组末尾*/, array()->lists/*数组*/,
                    oldCount * sizeof(array()->lists[0])/*移动的大小*/);

			//空出来的 内存使用addedLists拷贝过去 大小是:addedCount * sizeof(array()->lists[0])
            memcpy(array()->lists, addedLists, 
                   addedCount * sizeof(array()->lists[0]));
        }
        // 如果list为空 且要添加的个数为1 那么直接设置
        else if (!list  &&  addedCount == 1) {
            // 0 lists -> 1 list
            list = addedLists[0];
        } 
        else {
            // 如果要添加的个数大于1个
            List* oldList = list;
            // 就数据个数
            uint32_t oldCount = oldList ? 1 : 0;
            // 更新后的数组元素个数
            uint32_t newCount = oldCount + addedCount;
            // 分配内存空间 这时候空间所有数据为空
            setArray((array_t *)malloc(array_t::byteSize(newCount)));
            // 更新数据个数
            array()->count = newCount;
            // 如果有旧的
            if (oldList)
                // 将旧的数据放在了数组的addedCount的位置
                // 前面addedCount个位置是为了给addedLists保留
                array()->lists[addedCount] = oldList;

            // 将addedLists拷贝到数组的0-addedCount的位置
            memcpy(array()->lists, addedLists, 
                   addedCount * sizeof(array()->lists[0]));
        }
    }
    
// memmove ：内存移动。
/*  __dst : 移动内存的目的地
*   __src : 被移动的内存首地址
*   __len : 被移动的内存长度
*   将__src的内存移动__len块内存到__dst中
*/
void    *memmove(void *__dst, const void *__src, size_t __len);

// memcpy ：内存拷贝。
/*  __dst : 拷贝内存的拷贝目的地
*   __src : 被拷贝的内存首地址
*   __n : 被移动的内存长度
*   将__src的内存移动__n块内存到__dst中
*/
void    *memcpy(void *__dst, const void *__src, size_t __n);

id objc_getAssociatedObject(id object, const void *key) {
    return _object_get_associative_reference(object, (void *)key);
}


void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) {
    _object_set_associative_reference(object, (void *)key, value, policy);
}


void objc_removeAssociatedObjects(id object) 
{
    if (object && object->hasAssociatedObjects()) {
        _object_remove_assocations(object);
    }
}

typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
    /**< Specifies a weak reference to the associated object. */
    OBJC_ASSOCIATION_ASSIGN = 0,           
    /**< Specifies a strong reference to the associated object. 
    *   The association is not made atomically. */
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, 
    /**< Specifies that the associated object is copied. 
    *   The association is not made atomically. */
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,
    /**< Specifies a strong reference to the associated object.
    *   The association is made atomically. */
    OBJC_ASSOCIATION_RETAIN = 01401,    
    /**< Specifies that the associated object is copied.
    *   The association is made atomically. */   
    OBJC_ASSOCIATION_COPY = 01403          
};

// 设置关联对象的值
// object 目标对象
// 关联对象的key
// 关联对象的值
// 关联策略
void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    // retain the new value (if any) outside the lock.
    ObjcAssociation old_association(0, nil);
	//获取new_value的值
    // acquireValue根据policy== OBJC_ASSOCIATION_SETTER_COPY 或者OBJC_ASSOCIATION_SETTER_RETAIN
    // 判断是要进行retain操作还是copy操作
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        AssociationsManager manager;
		//生成一个全局的 HashMap
        AssociationsHashMap &associations(manager.associations());
        disguised_ptr_t disguised_object = DISGUISE(object);
		//newValue存在 需要更新
        if (new_value) {
            // 遍历 hashMap是否有该obj
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            // 遍历
            if (i != associations.end()) {
				//这个对象有关联对象 注意这里取出的并不是某个对象 而是一个哈希表
                ObjectAssociationMap *refs = i->second;
                // 根据key找到对应的关联对象
                ObjectAssociationMap::iterator j = refs->find(key);
                // 遍历根据key的查找结果
                if (j != refs->end()) {
                    // 如果找到了 更新值
                    old_association = j->second;
                    j->second = ObjcAssociation(policy, new_value);
                } else {
                    // 如果找到最后仍然没有找到 那么新增插入
                    (*refs)[key] = ObjcAssociation(policy, new_value);
                }
            } else {
				//如果这个对象之前就没有关联对象 那么新建
                ObjectAssociationMap *refs = new ObjectAssociationMap;
                associations[disguised_object] = refs;
                (*refs)[key] = ObjcAssociation(policy, new_value);
                object->setHasAssociatedObjects();
            }
        } else {
            // 如果传入的关联对象值为nil，则断开关联
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i !=  associations.end()) {
                ObjectAssociationMap *refs = i->second;
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    refs->erase(j);
                }
            }
        }
    }
    // 释放旧值
    if (old_association.hasValue()) ReleaseValue()(old_association);
}

// 获取一个已关联的对象
id _object_get_associative_reference(id object, void *key) {
    id value = nil;
    uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
    {
        // 可以把manager理解为一个单例 实际上是一个静态变量
        AssociationsManager manager;
		//初始化 _map = AssociationsHashMap
        AssociationsHashMap &associations(manager.associations());
        // 取反object 地址 作为accociative key
        disguised_ptr_t disguised_object = DISGUISE(object);
        // 在关联对象海西表中 找到与disguised_object关联的所有对象
        AssociationsHashMap::iterator i = associations.find(disguised_object);

        // 遍历这个哈希表
        if (i != associations.end()) {
            // 取出当前的这个关联对象
            ObjectAssociationMap *refs = i->second;
            // 根据key查找对应的关联对象 有可能存在多个
            ObjectAssociationMap::iterator j = refs->find(key);
            // 遍历查找结果
            if (j != refs->end()) {
                // 取出关联实体
                ObjcAssociation &entry = j->second;
                value = entry.value();
                policy = entry.policy();
                if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) {
                    objc_retain(value);
                }
            }
        }
    }
    // 如果policy = OBJC_ASSOCIATION_GETTER_AUTORELEASE
    if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
        objc_autorelease(value);
    }
    return value;
}

void *objc_destructInstance(id obj) 
{
    if (obj) {
        Class isa = obj->getIsa();

        if (isa->hasCxxDtor()) {
            object_cxxDestruct(obj);
        }

        if (isa->instancesHaveAssociatedObjects()) {
            _object_remove_assocations(obj);
        }

        objc_clear_deallocating(obj);
    }

    return obj;
}

// 对象释放时移除所有的关联属性
void _object_remove_assocations(id object) {
    vector< ObjcAssociation,ObjcAllocator<ObjcAssociation> > elements;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());

        if (associations.size() == 0) return;

        disguised_ptr_t disguised_object = DISGUISE(object);
        // 根据对象地址取出所有的关联对象
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            // 拷贝所有的关联关系
            ObjectAssociationMap *refs = i->second;
            for (ObjectAssociationMap::iterator j = refs->begin(), end = refs->end(); j != end; ++j) {
                // 记录所有的关联对象到elements
                elements.push_back(j->second);
            }
            // 删除refs 删除这个对象的所有关联对象
            delete refs;
            // 清除关联关系
            associations.erase(i);
        }
    }
    // elements数组中的所有元素执行ReleaseValue操作
    for_each(elements.begin(), elements.end(), ReleaseValue());
}

void
load_images(const char *path __unused, const struct mach_header *mh)
{
    // Return without taking locks if there are no +load methods here.
    if (!hasLoadMethods((const headerType *)mh)) return;

    recursive_mutex_locker_t lock(loadMethodLock);

    // Discover load methods
    {
        mutex_locker_t lock2(runtimeLock);
        //加载 class+load 和category+load方法
        prepare_load_methods((const headerType *)mh);
    }

    // Call +load methods (without runtimeLock - re-entrant)
    //执行 class+load 和category+load方法
    call_load_methods();
}

// 执行+load方法
void call_load_methods(void)
{
    do {
        //执行class+load直到完成
        while (loadable_classes_used > 0) {
            call_class_loads();
        }
        // 执行Category +load 一次
        more_categories = call_category_loads();

        // 3. Run more +loads if there are classes OR more untried categories
    } while (loadable_classes_used > 0  ||  more_categories);
}