1
struct category_t {
2
    const char *name;  // 名字
3
    classref_t cls;  // 要附加的目标类
4
    struct method_list_t *instanceMethods;
5
    struct method_list_t *classMethods;  //添加的类方法列表，被附加到元类上
6
    struct protocol_list_t *protocols;//协议列表
7
    struct property_list_t *instanceProperties; // 实例属性元数据
8
    struct property_list_t *_classProperties;   // 类属性元数据，新版 runtime 使用
9
};

1
struct method_list_t : entsize_list_tt<method_t, method_list_t, 0xffff0003> {
2
    // 成员变量和方法
3
};
4

5
template <typename Element, typename List, uint32_t FlagMask>
6
struct entsize_list_tt {
7
    uint32_t entsizeAndFlags;
8
    uint32_t count;
9
    Element first;
10
};

1
struct method_t {
2
    SEL name;
3
    const char *types;   //  方法类型编码
4
    IMP imp;
5
};

1
1. 从 obj 的 isa 找到类对象 MyClass
2
2. 先查方法缓存 cache
3
3. cache 没有，就查方法列表 method_list_t
4
4. 在方法列表里查找 method_t
5
5. 找到 method_t.name == @selector(printName)
6
6. 拿到 method_t.imp
7
7. 调用 imp(obj, @selector(printName))
8
8. 可能把 selector -> imp 缓存起来

1
struct locstamped_category_list_t {
2
    uint32_t count;
3
    locstamped_category_t list[0];
4
};
5
struct locstamped_category_t {
6
    category_t *cat;   // category本身
7
    struct header_info *hi;  // category来自的mach-o镜像信息
8
};
9
typedef locstamped_category_list_t category_list;

1
category_list / locstamped_category_list_t
2
    └── locstamped_category_t
3
            ├── category_t *cat
4
            │       ├── method_list_t *instanceMethods
5
            │       │       └── entsize_list_tt<method_t, method_list_t, ...>
6
            │       │               └── method_t[]
7
            │       │                       ├── SEL name
8
            │       │                       ├── const char *types
9
            │       │                       └── IMP imp
10
            │       │
11
            │       ├── method_list_t *classMethods
12
            │       │       └── entsize_list_tt<method_t, method_list_t, ...>
13
            │       │               └── method_t[]
14
            │       │
15
            │       ├── protocol_list_t *protocols
16
            │       ├── property_list_t *instanceProperties
17
            │       └── property_list_t *_classProperties
18
            │
19
            └── header_info *hi

1
static method_t *getMethodNoSuper_nolock(Class cls, SEL sel) {
2
    for (auto mlists = cls->data()->methods.beginLists(),
3
              end    = cls->data()->methods.endLists();
4
         mlists != end; ++mlists) {
5
        method_t *m = search_method_list(*mlists, sel);
6
        if (m) return m;        // 找到就返回,不再继续
7
    }
8
    return nil;
9
}
10

11
static method_t *search_method_list(const method_list_t *mlist, SEL sel) {
12
    for (auto& meth : *mlist) {
13
        if (meth.name == sel) return &meth;
14
    }
15
    return nil;
16
}

1
// 从当前 Mach-O 镜像 hi 中获取 Category 列表。
2
// catlist 指向当前镜像中的 category_t 指针数组。
3
// count 表示当前镜像中 Category 的数量。
4
category_t **catlist = _getObjc2CategoryList(hi, &count);
5

6
// 判断当前镜像是否包含 Category 的 class property 元数据。
7
// 新版 runtime 中会用这个标志决定是否读取 cat->_classProperties。
8
bool hasClassProperties = hi->info()->hasCategoryClassProperties();
9

10

11
// 遍历当前镜像中的所有 Category。
12
for (i = 0; i < count; i++) {
13

14
    // 取出一个 Category。
15
    category_t *cat = catlist[i];
16

17
    // 根据 Category 中记录的目标类引用，找到 runtime 中真正的 Class。
18
    // remapClass 用于处理类重映射、weak-linked class 等情况。
19
    Class cls = remapClass(cat->cls);
20

21
    // 如果目标类不存在，说明这个 Category 无法附加。
22
    // 常见情况：目标类是 weak-linked，但当前系统中不存在。
23
    if (!cls) {
24
        catlist[i] = NULL;
25
        continue;
26
    }
27

28

29
    // ============================================================
30
    // 一、处理 Category 的“实例侧内容”
31
    //
32
    // 包括：
33
    // 1. 实例方法 instanceMethods
34
    // 2. 协议 protocols
35
    // 3. 实例属性元数据 instanceProperties
36
    //
37
    // 这些内容会附加到普通类对象 cls 上。
38
    // ============================================================
39

40
    bool classExists = NO;
41

42
    if (cat->instanceMethods ||
43
        cat->protocols ||
44
        cat->instanceProperties)
45
    {
46
    // 先把 Category 登记到目标类 cls 对应的待附加列表中。
47
        //
48
        // 注意：
49
        // addUnattachedCategoryForClass 并不是真正合并方法列表。
50
        // 它只是建立：
51
        //
52
        // cls -> category
53
        //
54
        // 的关联关系。
55
        addUnattachedCategoryForClass(cat, cls, hi);
56

57
        // 如果目标类已经 realized，
58
        // 说明它已经完成 runtime 初始化，可以立刻合并 Category 内容。
59
        if (cls->isRealized()) {
60

61
            // 真正把 Category 的实例方法、属性、协议等附加到 cls 上。
62
            remethodizeClass(cls);
63

64
            classExists = YES;
65
        }
66
    }
67

68

69
    // ============================================================
70
    // 二、处理 Category 的“类侧内容”
71
    //
72
    // 包括：
73
    // 1. 类方法 classMethods
74
    // 2. 协议 protocols
75
    // 3. 类属性元数据 _classProperties
76
    //
77
    // 这些内容会附加到目标类的元类 cls->ISA() 上。
78
    // ============================================================
79

80
    if (cat->classMethods ||
81
        cat->protocols ||
82
        (hasClassProperties && cat->_classProperties))
83
    {
84
        // 类方法本质上是元类的实例方法，
85
        // 所以 Category 的类方法要登记到 cls->ISA() 上，
86
        // 也就是目标类的元类。
87
        addUnattachedCategoryForClass(cat, cls->ISA(), hi);
88

89
        // 如果元类已经 realized，
90
        // 就立刻把 Category 的类方法、类属性元数据、协议等附加进去。
91
        if (cls->ISA()->isRealized()) {
92
            remethodizeClass(cls->ISA());
93
        }
94
    }
95
}

1
// 将一个 Category 暂存到“目标类 cls 的待附加 Category 列表”中。
2
// 注意：这个函数并不会真正把 Category 的方法、属性、协议合并到类上。
3
// 真正合并发生在后面的 remethodizeClass(cls) 中。
4
static void addUnattachedCategoryForClass(category_t *cat,
5
                                          Class cls,
6
                                          header_info *catHeader)
7
{
8
    // 当前必须已经持有 runtimeLock。
9
    // 因为这里要修改 runtime 的全局 Category 映射表。
10
    runtimeLock.assertLocked();
11

12
    // 获取全局的“未附加 Category 映射表”。
13
    //
14
    // 这个表可以理解为：
15
    //
16
    //     Class -> category_list
17
    //
18
    // 也就是：
19
    //
20
    //     某个类 -> 这个类当前等待附加的 Category 列表
21
    //
22
    NXMapTable *cats = unattachedCategories();
23

24
    category_list *list;
25

26
    // 根据目标类 cls，从映射表中取出它已有的待附加 Category 列表。
27
    list = (category_list *)NXMapGet(cats, cls);
28

29
    if (!list) {
30
        // 如果这个类还没有待附加 Category 列表，
31
        // 就创建一个新的 category_list。
32
        //
33
        // sizeof(*list)：
34
        //     category_list 结构体头部大小，里面包含 count。
35
        //
36
        // sizeof(list->list[0])：
37
        //     一个 locstamped_category_t 的大小。
38
        //
39
        // 因为 list 里使用了 list[0] 这种零长度数组技巧，
40
        // 所以创建第一个元素时，需要额外申请一个元素的空间。
41
        list = (category_list *)calloc(
42
            sizeof(*list) + sizeof(list->list[0]),
43
            1
44
        );
45
    } else {
46
        // 如果这个类已经有待附加 Category 列表，
47
        // 就扩容，多申请一个 locstamped_category_t 的空间。
48
        //
49
        // 原来能存 list->count 个 Category，
50
        // 现在要存 list->count + 1 个。
51
        list = (category_list *)realloc(
52
            list,
53
            sizeof(*list) + sizeof(list->list[0]) * (list->count + 1)
54
        );
55
    }
56

57
    // 把当前 Category 和它所在的 Mach-O 镜像信息一起存入列表。
58
    //
59
    // locstamped_category_t 包含：
60
    //     cat       : Category 本体
61
    //     catHeader : Category 来自哪个 Mach-O 镜像
62
    //
63
    // list->count++：
64
    //     先把元素写入当前位置，再把 count 加 1。
65
    list->list[list->count++] = (locstamped_category_t){ cat, catHeader };
66

67
    // 把更新后的 list 重新插入全局映射表。
68
    //
69
    // 如果之前 cats 中已经有 cls 对应的旧 list，
70
    // 这里会用扩容后的新 list 覆盖旧记录。
71
    NXMapInsert(cats, cls, list);
72
}

1
static void remethodizeClass(Class cls)
2
{
3
    category_list *cats;
4
    bool isMeta;
5

6
    // 当前必须已经持有 runtimeLock。
7
    // 因为这里会读取并修改 runtime 中类的全局结构。
8
    runtimeLock.assertLocked();
9

10
    // 判断当前传入的 cls 是普通类，还是元类。
11
    //
12
    // 如果是普通类：
13
    //     处理 Category 的实例方法、实例属性、协议等。
14
    //
15
    // 如果是元类：
16
    //     处理 Category 的类方法、类属性、协议等。
17
    isMeta = cls->isMetaClass();
18

19
    // 从全局 unattachedCategories 表中取出 cls 对应的待附加 Category 列表。
20
    //
21
    // false 表示当前不是在 realizing class 的流程中调用。
22
    //
23
    // 返回的 cats 可以理解为：
24
    //
25
    //     cls -> [CategoryA, CategoryB, CategoryC]
26
    //
27
    // 这些 Category 之前是通过 addUnattachedCategoryForClass(cat, cls, hi)
28
    // 暂存进去的。
29
    cats = unattachedCategoriesForClass(cls, false /* not realizing */);
30

31
    if (cats) {
32
        // 真正把 cats 中的 Category 附加到 cls 上。
33
        //
34
        // attachCategories 会处理：
35
        //     1. 方法列表 methods
36
        //     2. 属性列表 properties
37
        //     3. 协议列表 protocols
38
        //
39
        // 如果 cls 是普通类：
40
        //     Category 的实例方法会被附加到 cls。
41
        //
42
        // 如果 cls 是元类：
43
        //     Category 的类方法会被附加到 cls。
44
        //
45
        // true 表示附加完成后需要刷新方法缓存。
46
        attachCategories(cls, cats, true /* flush caches */);
47

48
        // cats 是从 unattachedCategoriesForClass 取出的临时列表。
49
        // attach 完成后释放。
50
        free(cats);
51
    }
52
}

1
static void attachCategories(Class cls,
2
                             category_list *cats,
3
                             bool flush_caches)
4
{
5
    if (!cats) return;
6

7
    if (PrintReplacedMethods) {
8
        printReplacements(cls, cats);
9
    }
10

11
    // 判断当前 cls 是普通类还是元类。
12
    // 普通类：处理 Category 的实例方法、实例属性、协议。
13
    // 元类：处理 Category 的类方法、类属性、协议。
14
    bool isMeta = cls->isMetaClass();
15

16
    // 创建三个临时数组，用来收集所有 Category 中的方法列表、属性列表、协议列表。
17
    method_list_t **mlists = (method_list_t **)
18
        malloc(cats->count * sizeof(*mlists));
19

20
    property_list_t **proplists = (property_list_t **)
21
        malloc(cats->count * sizeof(*proplists));
22

23
    protocol_list_t **protolists = (protocol_list_t **)
24
        malloc(cats->count * sizeof(*protolists));
25

26
    // 记录实际收集到的方法列表、属性列表、协议列表数量。
27
    int mcount = 0;
28
    int propcount = 0;
29
    int protocount = 0;
30

31
    // 从后往前遍历 Category。
32
    // 这样可以保证“最新加载的 Category”排在前面。
33
    int i = cats->count;
34

35
    // 标记这些 Category 是否来自 bundle。
36
    bool fromBundle = NO;
37

38
    while (i--) {
39
        // 取出当前 Category 以及它所在的 Mach-O 镜像信息。
40
        auto& entry = cats->list[i];
41

42
        // 取出当前 Category 的方法列表。
43
        //
44
        // 如果 cls 是普通类：
45
        //     methodsForMeta(false) 取 instanceMethods。
46
        //
47
        // 如果 cls 是元类：
48
        //     methodsForMeta(true) 取 classMethods。
49
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
50

51
        if (mlist) {
52
            // 将当前 Category 的方法列表保存到临时方法列表数组中。
53
            mlists[mcount++] = mlist;
54

55
            // 记录是否有来自 bundle 的 Category。
56
            fromBundle |= entry.hi->isBundle();
57
        }
58

59
        // 取出当前 Category 的属性列表。
60
        //
61
        // 如果 cls 是普通类：
62
        //     通常取 instanceProperties。
63
        //
64
        // 如果 cls 是元类：
65
        //     可能取 classProperties；
66
        //     如果当前镜像不支持 classProperties，则可能返回 nil。
67
        property_list_t *proplist =
68
            entry.cat->propertiesForMeta(isMeta, entry.hi);
69

70
        if (proplist) {
71
            proplists[propcount++] = proplist;
72
        }
73

74
        // 取出当前 Category 声明遵守的协议列表。
75
        protocol_list_t *protolist = entry.cat->protocols;
76

77
        if (protolist) {
78
            protolists[protocount++] = protolist;
79
        }
80
    }
81

82
    // 取出当前类的运行时可变数据 class_rw_t。
83
    auto rw = cls->data();
84

85
    // 对即将附加的方法列表做准备工作。
86
    //
87
    // 例如：
88
    //     排序
89
    //     修正方法列表
90
    //     检查特殊方法
91
    //     标记是否来自 bundle
92
    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
93

94
    // 将 Category 的方法列表附加到 class_rw_t 的 methods 中。
95
    //
96
    // 注意：
97
    //     attachLists 会把新列表放到旧列表前面。
98
    //     所以 Category 的同名方法会优先于原类方法被查找到。
99
    rw->methods.attachLists(mlists, mcount);
100

101
    // 临时数组已经被 attachLists 使用完，可以释放。
102
    free(mlists);
103

104
    // 如果需要刷新缓存，并且确实附加了方法列表，就清理方法缓存。
105
    //
106
    // 因为 Category 可能添加或“覆盖”同名方法，
107
    // 如果不清缓存，objc_msgSend 可能继续命中旧 IMP。
108
    if (flush_caches && mcount > 0) {
109
        flushCaches(cls);
110
    }
111

112
    // 将 Category 的属性列表附加到 class_rw_t 的 properties 中。
113
    rw->properties.attachLists(proplists, propcount);
114

115
    // 释放属性临时数组。
116
    free(proplists);
117

118
    // 将 Category 的协议列表附加到 class_rw_t 的 protocols 中。
119
    rw->protocols.attachLists(protolists, protocount);
120

121
    // 释放协议临时数组。
122
    free(protolists);
123
}

1
1. 编译器把 Category 编译成 category_t
2
2. category_t 被放进 Mach-O 的 __objc_catlist
3
3. runtime 在 _read_images 中读取 __objc_catlist
4
4. 得到 category_t **catlist
5
5. 遍历每个 category_t
6
6. 找到它的目标类 cls
7
7. 调用 addUnattachedCategoryForClass(cat, cls, hi)
8
8. 把 category_t 和 header_info 包装成 locstamped_category_t
9
9. 放入 cls 对应的 category_list
10
10. 如果 cls 已经 realized，调用 remethodizeClass(cls)
11
11. remethodizeClass 取出 category_list
12
12. attachCategories 遍历 category_list
13
13. 从每个 locstamped_category_t 里取出 category_t
14
14. 从 category_t 里取出 method_list_t
15
15. 把 method_list_t attach 到 class_rw_t.methods（新版通常落到 rwe->methods）

1
static void attachCategories(Class cls,
2
                             const locstamped_category_t *cats_list,
3
                             uint32_t cats_count,
4
                             int flags)
5
{
6
    constexpr uint32_t ATTACH_BUFSIZ = 64;
7
    method_list_t   *mlists[ATTACH_BUFSIZ];      // 栈上,固定 64 个,避免 malloc
8
    property_list_t *proplists[ATTACH_BUFSIZ];
9
    protocol_list_t *protolists[ATTACH_BUFSIZ];
10

11
    uint32_t mcount = 0, propcount = 0, protocount = 0;
12
    bool fromBundle = NO;
13
    bool isMeta = (flags & ATTACH_METACLASS);
14

15
    // 关键:按需分配 rwe(只有真要附加内容时才创建)
16
    auto rwe = cls->data()->extAllocIfNeeded();
17

18
    for (uint32_t i = 0; i < cats_count; i++) {
19
        auto& entry = cats_list[i];
20

21
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
22
        if (mlist) {
23
            // 栈缓冲区满了就先 flush 一次
24
            if (mcount == ATTACH_BUFSIZ) {
25
                prepareMethodLists(cls, mlists, mcount, NO, fromBundle, __func__);
26
                rwe->methods.attachLists(mlists, mcount);
27
                mcount = 0;
28
            }
29
            // 倒序填充:让最终顺序一次 attachLists 就是对的
30
            mlists[ATTACH_BUFSIZ - ++mcount] = mlist;
31
            fromBundle |= entry.hi->isBundle();
32
        }
33
        // properties / protocols 同理...
34
    }
35

36
    // 处理剩余的(不满 64 个)
37
    if (mcount > 0) {
38
        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount,
39
                           mcount, NO, fromBundle, __func__);
40
        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
41
        if (flags & ATTACH_EXISTING) flushCaches(cls);
42
    }
43
    // 同样处理 properties / protocols...
44
}

1
typedef struct objc_class *Class;
2

3
@interface NSObject <NSObject> {
4
    Class isa  OBJC_ISA_AVAILABILITY;
5
}

1
struct objc_class {
2
    Class isa  OBJC_ISA_AVAILABILITY;
3

4
#if !__OBJC2__
5
    Class super_class                                        OBJC2_UNAVAILABLE;
6
    const char *name                                         OBJC2_UNAVAILABLE;
7
    long version                                             OBJC2_UNAVAILABLE;
8
    long info                                                OBJC2_UNAVAILABLE;
9
    long instance_size                                       OBJC2_UNAVAILABLE;
10
    struct objc_ivar_list *ivars  //一级指针                           OBJC2_UNAVAILABLE;
11
    struct objc_method_list **methodLists    //二级指针                OBJC2_UNAVAILABLE;
12
    struct objc_cache *cache                                 OBJC2_UNAVAILABLE;
13
    struct objc_protocol_list *protocols                     OBJC2_UNAVAILABLE;
14
#endif
15

16
} OBJC2_UNAVAILABLE;

1
methodLists ──→ [ *list1, *list2, *list3, ... ]
2
                    ↓       ↓       ↓
3
                  原始方法  Category Category
4
                  列表      A的方法   B的方法

1
@interface NSObject (Sark)
2
+ (void)foo;
3
@end
4

5
@implementation NSObject (Sark)
6
- (void)foo {
7
    NSLog(@"IMP: %@, self: %@", NSStringFromSelector(_cmd), self);
8
}
9
@end
10

11
int main(int argc, char * argv[]) {
12
    [NSObject foo];
13
    [[NSObject new] foo];
14
    return 0;
15
}

1
_objc_init
2
  -> map_images
3
  -> _read_images
4
  -> 读取 __objc_catlist
5
  -> addUnattachedCategoryForClass
6
  -> remethodizeClass
7
  -> attachCategories
8
  -> attachLists 前置插入
9
  -> 必要时 flushCaches