跟着 NSDictionary 的底层设计学习优化技巧（2）

1

NSMutableDictionary *mutableDic = [NSMutableDictionary dictionary];

1
2
3

(lldb) b +[NSMutableDictionary dictionary]
Breakpoint 11: no locations (pending).
WARNING:  Unable to resolve breakpoint to any actual locations.

1
2
3

(lldb) bmessage +[NSMutableDictionary dictionary]
Setting a breakpoint at \+[NSDictionary dictionary] with condition (void*)object_getClass((id)$x0) == 0x00000001fbbbae68
Breakpoint 19: where = CoreFoundation`+[NSDictionary dictionary], address = 0x00000001a2404ec0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

CoreFoundation`+[NSDictionary dictionary]:
    0x1a2404ec0 <+0>:  stp    x29, x30, [sp, #-0x10]!
    0x1a2404ec4 <+4>:  mov    x29, sp

    # objc_alloc
    0x1a2404ec8 <+8>:  bl     0x1a2585f14               ; symbol stub for: -[NSMutableArray replaceObject:].cold.1

    # initWithObjects:forKeys:count:
    0x1a2404ecc <+12>: adrp   x8, 308195
    0x1a2404ed0 <+16>: add    x1, x8, #0xd8             ; =0xd8
    0x1a2404ed4 <+20>: mov    x2, #0x0
    0x1a2404ed8 <+24>: mov    x3, #0x0
    0x1a2404edc <+28>: mov    x4, #0x0
    # 发送消息
    0x1a2404ee0 <+32>: bl     0x1a2153e28
    0x1a2404ee4 <+36>: ldp    x29, x30, [sp], #0x10

    # objc_autorelease
    0x1a2404ee8 <+40>: b      0x1a2585f44               ; symbol stub for: -[NSMutableArray replaceObjectsAtIndexes:withObjects:].cold.1

1
2
3
4

CoreFoundation`-[NSMutableArray replaceObject:].cold.1:
    0x1a2585f14 <+0>: adrp   x16, 82705
    0x1a2585f18 <+4>: add    x16, x16, #0x28           ; =0x28
->  0x1a2585f1c <+8>: br     x16

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112

CoreFoundation`-[__NSPlaceholderDictionary initWithObjects:forKeys:count:]:
    0x1a24097b8 <+0>:   stp    x29, x30, [sp, #-0x10]!
    0x1a24097bc <+4>:   mov    x29, sp

    # keys 非 NULL，则跳转到 +16
    0x1a24097c0 <+8>:   cbnz   x3, 0x1a24097c8           ; <+16>

    # keys 是 NULL，count 大于 0，抛出异常
    0x1a24097c4 <+12>:  cbnz   x4, 0x1a24098a8           ; <+240>

    # 校验 count 数量是否过大，如果过大抛出异常
    0x1a24097c8 <+16>:  lsr    x8, x4, #61
    0x1a24097cc <+20>:  cbnz   x8, 0x1a24098b0           ; <+248>

    # count 等于 0，调整到 +52 处理
    0x1a24097d0 <+24>:  cbz    x4, 0x1a24097ec           ; <+52>

      ## 对 keys 进行非空校验

      # 开始计数，寄存器 x8 = 0
      0x1a24097d4 <+28>:  mov    x8, #0x0
      # 读取当前 key
      0x1a24097d8 <+32>:  ldr    x9, [x3, x8, lsl #3]
      # 如果某个 key 是 nil， 则抛出异常
      0x1a24097dc <+36>:  cbz    x9, 0x1a2409898           ; <+224>
      # 计数自增1
      0x1a24097e0 <+40>:  add    x8, x8, #0x1              ; =0x1
      # 判断是否等于 count
      0x1a24097e4 <+44>:  cmp    x4, x8
      # 如果不等于 count，则调到 +32 进行判断，直到遍历结束
      0x1a24097e8 <+48>:  b.ne   0x1a24097d8               ; <+32>

    # values 不等于 NULL，则调到 +60 处理
    0x1a24097ec <+52>:  cbnz   x2, 0x1a24097f4           ; <+60>
    # values 等于 NULL， count 不等于 0，则调到 +256 抛出异常
    0x1a24097f0 <+56>:  cbnz   x4, 0x1a24098b8           ; <+256>

    # values 等于 NULL，count 等于 0，调到 +88 进行处理
    0x1a24097f4 <+60>:  cbz    x4, 0x1a2409810           ; <+88>

      ## 对 values 进行非空校验
      0x1a24097f8 <+64>:  mov    x8, #0x0
      0x1a24097fc <+68>:  ldr    x9, [x2, x8, lsl #3]
      0x1a2409800 <+72>:  cbz    x9, 0x1a24098a0           ; <+232>
      0x1a2409804 <+76>:  add    x8, x8, #0x1              ; =0x1
      0x1a2409808 <+80>:  cmp    x4, x8
      0x1a240980c <+84>:  b.ne   0x1a24097fc               ; <+68>

    # 获取 ___immutablePlaceholderDictionary
->  0x1a2409810 <+88>:  adrp   x8, 334078
    0x1a2409814 <+92>:  add    x8, x8, #0x168            ; =0x168
    # self 等于 ___immutablePlaceholderDictionary 时，调整到 +144 进行创建任务
    0x1a2409818 <+96>:  cmp    x0, x8
    0x1a240981c <+100>: b.eq   0x1a2409848               ; <+144>

    # 获取 ___mutablePlaceholderDictionary
    0x1a2409820 <+104>: adrp   x8, 334078
    0x1a2409824 <+108>: add    x8, x8, #0x178            ; =0x178

    # self 等于 ___immutablePlaceholderDictionary 时，跳转到 +264 中断
    0x1a2409828 <+112>: cmp    x0, x8
    0x1a240982c <+116>: b.ne   0x1a24098c0               ; <+264>

    ## 可变字典创建任务
    0x1a2409830 <+120>: mov    x0, x3
    0x1a2409834 <+124>: mov    x1, x2
    0x1a2409838 <+128>: mov    x2, x4
    0x1a240983c <+132>: mov    w3, #0x3
    0x1a2409840 <+136>: ldp    x29, x30, [sp], #0x10
    0x1a2409844 <+140>: b      0x1a256c344               ; __NSDictionaryM_new

    ## 不可变字典创建任务
    0x1a2409848 <+144>: cmp    x4, #0x1                  ; =0x1
    0x1a240984c <+148>: b.eq   0x1a2409868               ; <+176>

    0x1a2409850 <+152>: cbnz   x4, 0x1a240987c           ; <+196>
    0x1a2409854 <+156>: adrp   x8, 334061
    0x1a2409858 <+160>: add    x8, x8, #0xdd0            ; =0xdd0
    0x1a240985c <+164>: ldr    x0, [x8]
    0x1a2409860 <+168>: ldp    x29, x30, [sp], #0x10
    0x1a2409864 <+172>: b      0x1a2153e58


    0x1a2409868 <+176>: ldr    x0, [x3]
    0x1a240986c <+180>: ldr    x1, [x2]
    0x1a2409870 <+184>: mov    w2, #0x1
    0x1a2409874 <+188>: ldp    x29, x30, [sp], #0x10
    0x1a2409878 <+192>: b      0x1a2462a90               ; __NSSingleEntryDictionaryI_new

    0x1a240987c <+196>: mov    x0, x3
    0x1a2409880 <+200>: mov    x1, x2
    0x1a2409884 <+204>: mov    x2, #0x0
    0x1a2409888 <+208>: mov    x3, x4
    0x1a240988c <+212>: mov    w4, #0x1
    0x1a2409890 <+216>: ldp    x29, x30, [sp], #0x10
    0x1a2409894 <+220>: b      0x1a2450e0c               ; __NSDictionaryI_new

    0x1a2409898 <+224>: mov    x0, x8
    0x1a240989c <+228>: bl     0x1a25841f4               ; -[__NSPlaceholderDictionary initWithObjects:forKeys:count:].cold.5
    0x1a24098a0 <+232>: mov    x0, x8
    0x1a24098a4 <+236>: bl     0x1a25841c4               ; -[__NSPlaceholderDictionary initWithObjects:forKeys:count:].cold.4
    0x1a24098a8 <+240>: mov    x0, x4
    0x1a24098ac <+244>: bl     0x1a2584134               ; -[__NSPlaceholderDictionary initWithObjects:forKeys:count:].cold.1

    # '*** -[__NSPlaceholderDictionary initWithObjects:forKeys:count:]: count (0) of objects array is ridiculous'
    0x1a24098b0 <+248>: mov    x0, x4
    0x1a24098b4 <+252>: bl     0x1a2584164               ; -[__NSPlaceholderDictionary initWithObjects:forKeys:count:].cold.2

    0x1a24098b8 <+256>: mov    x0, x4
    0x1a24098bc <+260>: bl     0x1a2584194               ; -[__NSPlaceholderDictionary initWithObjects:forKeys:count:].cold.3
    0x1a24098c0 <+264>: brk    #0x1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

struct KKDic_t {
    __strong Class isa;
    struct {
        const id *buffer;
        union {
            struct {
                unsigned long mutations;
            };
            struct {
                unsigned int muts;
                unsigned int other;
            };
            struct {
                unsigned mutbits : 31;
                unsigned copyKeys : 1;
                unsigned used : 25;
                unsigned kvo : 1;
                unsigned szidx : 6;
            };
        } state;
    } storage;
    struct __cow_state_t *cow;
};

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537

CoreFoundation`__NSDictionaryM_new:
    第0个参数是 keys
    第1个参数是 keys
    第2个参数是 keys
    第3个参数是 一个 NS_OPTIONS：可变字典Option

    根据汇编反推出的含义：
    typedef NS_OPTIONS(NSUInteger, 可变字典Option) {
        NSEnumeration初始化复制key = (1UL << 0), // 可以查看函数指令 +520 +556 处的逻辑
        NSEnumeration其它情况复制key = (1UL << 1),
        NSEnumeration屏蔽对Value进行Retain = (1UL << 2),
    };

    0x1a256c344 <+0>:   sub    sp, sp, #0xb0             ; =0xb0
    0x1a256c348 <+4>:   stp    x28, x27, [sp, #0x50]
    0x1a256c34c <+8>:   stp    x26, x25, [sp, #0x60]
    0x1a256c350 <+12>:  stp    x24, x23, [sp, #0x70]
    0x1a256c354 <+16>:  stp    x22, x21, [sp, #0x80]
    0x1a256c358 <+20>:  stp    x20, x19, [sp, #0x90]
    0x1a256c35c <+24>:  stp    x29, x30, [sp, #0xa0]
    0x1a256c360 <+28>:  add    x29, sp, #0xa0            ; =0xa0

    # 临时存储 keys 和 常量3 到栈上
    0x1a256c364 <+32>:  stp    x0, x3, [sp, #0x38]

    # x20 = x2，代表 count
    0x1a256c368 <+36>:  mov    x20, x2

    # values 放到 [sp, #0x30]
    0x1a256c36c <+40>:  str    x1, [sp, #0x30]

    ##### 一、下面的代码是计算 szidx 和字典的容量
    为了降低冲突，容量通常会大于 count；比如 count 等于 6，容量是 7

    1. 准备参数
    # x19 初始化为 0
    0x1a256c370 <+44>:  mov    x19, #0x0

    # x8代表 szidx * 8，初始化时是 0
    0x1a256c374 <+48>:  mov    x8, #0x0

    # 后续用来更新 szidx
    0x1a256c378 <+52>:  mov    x9, #0x400000000000000

    # x10 代表 __NSDictionaryCapacities
    0x1a256c37c <+56>:  adrp   x10, 464
    0x1a256c380 <+60>:  add    x10, x10, #0x900          ; =0x900
    (lldb) image lookup -a $x10
    Address: CoreFoundation[0x000000018069c900] (CoreFoundation.__TEXT.__const + 1749472)
    Summary: CoreFoundation`__NSDictionaryCapacities

    2. 通过循环方式查找 szidx 对应的值
    终止条件是 count 过大导致异常，或者  __NSDictionaryCapacities[szidx]>=count
    # x11 代表 __NSDictionaryCapacities[szidx]
    0x1a256c384 <+64>:  ldr    x11, [x10, x8]
    # 和 count 进行比较
    0x1a256c388 <+68>:  cmp    x11, x20
    #大于等于 count 时终止遍历，转到 +96
    0x1a256c38c <+72>:  b.hs   0x1a256c3a4               ; <+96>
    # 指向下一个值，x8 += 0x8
    0x1a256c390 <+76>:  add    x8, x8, #0x8              ; =0x8

    # x19 实际上就是 0x400000000000000 * szidx
    0x1a256c394 <+80>:  add    x19, x19, x9
    后面会将循环次数存到结构体的 szidx 位置
            struct {
                unsigned mutbits : 31;
                unsigned copyKeys : 1;
                unsigned used : 25;
                unsigned kvo : 1;
                unsigned szidx : 6;
            };


    # 安全校验：移量是否等于 0x140
    0x1a256c398 <+84>:  cmp    x8, #0x140                ; =0x140
    # 不等于才能转到 +64 继续遍历
    0x1a256c39c <+88>:  b.ne   0x1a256c384               ; <+64>
    # 等于  0x140 时触发中断，代表出现了字典无法处理的情况
    0x1a256c3a0 <+92>:  brk    #0x1


    3. 从 常量数组 取出桶的容量
    x22 保存 从 __NSDictionarySizes[szidx] 取出的字典容量
    0x1a256c3a4 <+96>:  adrp   x9, 464
    0x1a256c3a8 <+100>: add    x9, x9, #0xa40            ; =0xa40
    0x1a256c3ac <+104>: ldr    x22, [x9, x8]

    (lldb) image lookup -a $x9
        Address: CoreFoundation[0x000000018069ca40] (CoreFoundation.__TEXT.__const + 1749792)
        Summary: CoreFoundation`__NSDictionarySizes

    ##### 二、创建空间

    # 取出类 __NSDictionaryM
    0x1a256c3b0 <+108>: adrp   x0, 366160
    0x1a256c3b4 <+112>: add    x0, x0, #0x268            ; =0x268
    (lldb) image lookup -a $x0
      Address: CoreFoundation[0x00000001d9b1c268] (CoreFoundation.__DATA_DIRTY.__objc_data + 8680)
      Summary: (void *)0x00000001fbbbc290: __NSDictionaryM

    # 调用 objc_opt_self，等价于 [__NSDictionaryM self]
    0x1a256c3b8 <+116>: bl     0x1a25860a0               ; symbol stub for: -[NSSet intersectsOrderedSet:].cold.1

    # 调用 __CFAllocateObject 创建对象
    0x1a256c3bc <+120>: mov    x1, #0x0
    0x1a256c3c0 <+124>: bl     0x1a251b1d4               ; __CFAllocateObject

    ##### 三、更新 storage

    1、动态读取 实例变量 __NSDictionaryM.storage 的偏移量
    0x1a256c3c4 <+128>: adrp   x10, 367773
    0x1a256c3c8 <+132>: ldrsw  x8, [x10, #0xdb8]
      Address: CoreFoundation[0x00000001da169db8] (CoreFoundation.__DATA.__objc_ivar + 1192)
      Summary: CoreFoundation`__NSDictionaryM.storage

    # x8 指向 storage 位置
    0x1a256c3cc <+136>: add    x8, x0, x8

    2、初始化状态，等价于  dic->storage.state.muts = 1;
    0x1a256c3d0 <+140>: mov    w9, #0x1
    0x1a256c3d4 <+144>: str    w9, [x8, #0x8]

    3、更新 copyKeys
    # 再次动态读取 实例变量 __NSDictionaryM.storage 的偏移量
    0x1a256c3d8 <+148>: ldrsw  x8, [x10, #0xdb8]

    # 将 dic 临时存储到栈上
    0x1a256c3dc <+152>: str    x0, [sp, #0x10]

    # x21 指向 storage 位置
    0x1a256c3e0 <+156>: add    x21, x0, x8

    # x8 就是之前刚存入的 state
    0x1a256c3e4 <+160>: ldr    x8, [x21, #0x8]

    # 取出函数开头部分保存的 可变字典Option
    0x1a256c3e8 <+164>: ldr    x9, [sp, #0x40]
    # 可变字典Option<<30
    0x1a256c3ec <+168>: lsl    w9, w9, #30
    # x9 = (可变字典Option<<30)&0x80000000 = 0x80000000
    0x1a256c3f0 <+172>: and    x9, x9, #0x80000000
    通过和 x9 进行 orr 操作
    等价于根据 **可变字典Option & NSEnumeration其它情况复制key ** 决定是否将结构体的 copyKeys 置为 1
    struct {
                unsigned mutbits : 31;
                unsigned copyKeys : 1;
                unsigned used : 25;
                unsigned kvo : 1;
                unsigned szidx : 6;
            };


    # x10 = 0xffffffff7fffffff
    0x1a256c3f4 <+176>: mov    x10, #-0x80000001
    # 0x03ffffff7fffffff
    0x1a256c3f8 <+180>: movk   x10, #0x3ff, lsl #48
     前面两个指令等价于下面这个复杂的逻辑
    (lldb) p/x ((long)0-0x80000001)&(((long)0x3ff<<48)|(((long)1<<48)-1))
    (long) $57 = 0x 03ff ffff 7fff ffff

     # mutbits 与 x10 进行 and 计算
    0x1a256c3fc <+184>: and    x8, x8, x10
    前面的几个指令相当于对结构体的 copyKeys 和 szidx 做了置0操作。
            struct {
                unsigned mutbits : 31;
                unsigned copyKeys : 1;
                unsigned used : 25;
                unsigned kvo : 1;
                unsigned szidx : 6;
            };


    # 或计算
    0x1a256c400 <+188>: orr    x9, x19, x9
    x9 等价于下面的计算，其中 3是 __NSDictionaryM_new 函数接收的一个参数

    (lldb) p/x ((long)3<<30)&0x80000000|(0x0400000000000000*循环次数)
    高位的 0x04000000 代表循环1次，0x08000000 代表循环2次，依次类推

    低位的 0x80000000，代表是否进行 copyKeys，传入的 __NSDictionaryM_new 函数接收的**可变字典Option & NSEnumeration其它情况复制key ** 决定是否置为 0x80000000
    (long) $12 = 0x 0400 0000 8000 0000

            struct {
                unsigned mutbits : 31;
                unsigned copyKeys : 1;
                unsigned used : 25;
                unsigned kvo : 1;
                unsigned szidx : 6;
            };


    # x8 保存最后的新结构体
    0x1a256c404 <+192>: orr    x8, x9, x8

    # 存储到 dic->storage.state
    0x1a256c408 <+196>: str    x8, [x21, #0x8]

    #### 空字典执行逻辑 ####
    下面的箭头代表跳转
    0. +152 将 dic 临时存储到栈上
    1. +200 判断大小是否等于0
    2. +228 dic->storage.buffer 置为 NULL
    3. +664 cow 置为 NULL

    # x20 是字典的大小，如果等于0，跳转到 +228
    0x1a256c40c <+200>: cbz    x20, 0x1a256c428          ; <+228>

    # x22 代表字典容量
    0x1a256c410 <+204>: ubfiz  x1, x22, #4, #32

    # ubfiz 指令与下面的代码等价，代表最多有个 UINT32_MAX 个键值对
    NSLog(@"%x", INT32_MAX); // 7fffffff
    NSLog(@"%x", UINT32_MAX); // ffffffff
    (lldb) p/x  (0xabcdef1234567890&UINT32_MAX)<<4
    (unsigned long) $12 = 0x0000000345678900
    # 左移 4 位 的原因是：键值对需要2个指针保存 key 和 value，64位系统需要 8*2 的空间

    # 调用 calloc 申请一块合适的内存，内存大小是 1 * (size << 4)
    0x1a256c414 <+208>: mov    w0, #0x1
    0x1a256c418 <+212>: bl     0x1a2585770               ; symbol stub for: -[NSArray indexesOfObjectsWithOptions:passingTest:].cold.1

    # 更新字典的buffer *(dic->storage.buffer)
    0x1a256c41c <+216>: mov    x24, x0
    0x1a256c420 <+220>: str    x0, [x21]
    0x1a256c424 <+224>: b      0x1a256c430               ; <+236>

    # 字典大小等于0时，将 x24 置为0，并将 dic->storage.buffer 置为 NULL
    0x1a256c428 <+228>: mov    x24, #0x0
    0x1a256c42c <+232>: str    xzr, [x21]

    # 函数入口处曾经将 keys 和 values 指针临时保存到 [sp, #0x38],count 保存到 x20
    # 下面的代码会依次校验 keys values size 是否为0，如果是 0，则跳转到 +664 处理
    0x1a256c430 <+236>: ldr    x8, [sp, #0x38]
    0x1a256c434 <+240>: cbz    x8, 0x1a256c5dc           ; <+664>
    0x1a256c438 <+244>: ldr    x8, [sp, #0x30]
    0x1a256c43c <+248>: cbz    x8, 0x1a256c5dc           ; <+664>
    0x1a256c440 <+252>: cbz    x20, 0x1a256c5dc          ; <+664>

    # 后面会遍历 keys，x23 代表第几个
    0x1a256c444 <+256>: mov    x23, #0x0

    # x22 是容量，x26 后面用于将 key 打散的分母
    0x1a256c448 <+260>: and    x26, x22, #0xffffffff
    # buffer 的前 n 个是 key，后 n 个是 value，所以这里通过 buffer+容量*8 ,计算出 value 存储的起始区域
    0x1a256c44c <+264>: add    x8, x24, w22, uxtw #3
    # values 起始区域备用
    0x1a256c450 <+268>: str    x8, [sp, #0x48]

    # 获取 一个名为 hash 的 Selector 并存到  [sp, #0x20] 备用
    0x1a256c454 <+272>: adrp   x8, 309224
    0x1a256c458 <+276>: add    x8, x8, #0x6ba            ; =0x6ba
    将 hash 和 count 存储到 [sp, #0x20] 和 [sp, #0x28]
    0x1a256c45c <+280>: stp    x8, x20, [sp, #0x20]

      (lldb) image lookup -a $x8
            Address: libobjc.A.dylib[0x00000001cbcb46ba] (libobjc.A.dylib.__OBJC_RO + 9668282)
            Summary:
      (lldb) po (SEL)$x8
      "hash"

    # 获取一个名为 copyWithZone: 的 Selector，并存到 [sp, #0x8] 备用
    0x1a256c460 <+284>: adrp   x8, 308270
    0x1a256c464 <+288>: add    x8, x8, #0xbba            ; =0xbba
    0x1a256c468 <+292>: str    x8, [sp, #0x8]
    (lldb) image lookup -va ((($pc>>12)+308270)<<12)+0xbba
      Address: libobjc.A.dylib[0x00000001cb8fabba] (libobjc.A.dylib.__OBJC_RO + 5761978)
      Summary:
      (lldb) image lookup -a $x8
      Address: libobjc.A.dylib[0x00000001cb8fabba] (libobjc.A.dylib.__OBJC_RO + 5761978)
      (lldb) po (SEL)$x8
      "copyWithZone:"


    # 将字典取出来；+152 曾经将 dic 存到 [sp, #0x10]
    0x1a256c46c <+296>: ldr    x8, [sp, #0x10]

    # 将字典的 storage 地址存储到 [sp, #0x18]
    0x1a256c470 <+300>: add    x8, x8, #0x8              ; =0x8
    0x1a256c474 <+304>: str    x8, [sp, #0x18]

    # x25 保存 ___NSDictionaryM_DeletedMarker
    0x1a256c478 <+308>: adrp   x25, 333723
    0x1a256c47c <+312>: add    x25, x25, #0x1a8          ; =0x1a8
    (lldb) image lookup -a ((($pc>>12)+333723)<<12)+0x1a8
      Address: CoreFoundation[0x00000001d1c671a8] (CoreFoundation.__DATA_CONST.__const + 1939560)
      Summary: CoreFoundation`___NSDictionaryM_DeletedMarker


            # 获取 keys; +32 指令将 keys 存到了 [sp, #0x38]
            0x1a256c480 <+316>: ldr    x8, [sp, #0x38]

            # 开始取出 key
            0x1a256c484 <+320>: ldr    x27, [x8, x23, lsl #3]
            0x1a256c488 <+324>: mov    x0, x27
            # 开始取出 "hash"
            0x1a256c48c <+328>: ldr    x1, [sp, #0x20]
            # 发送消息
            0x1a256c490 <+332>: bl     0x1a2153e28

            # 字典容量等于 0 时，直接调到 +448 继续执行
            0x1a256c494 <+336>: mov    x20, x22
            0x1a256c498 <+340>: cbz    w22, 0x1a256c504          ; <+448>

    # 下面两个指令相当于 hash%字典容量，代表即将插入的桶相对起始位置的偏移量。以下简称“桶偏移量1”
    ; x8  = x0/x26
    ; x21 = x0-x8*x26
    ; x21 = x0-(x0/x26)*x26
    ; x21 = x0%x26
    0x1a256c49c <+344>: udiv   x8, x0, x26
    0x1a256c4a0 <+348>: msub   x21, x8, x26, x0

    # 获取一个名为 isEqual: 的 Selector
    0x1a256c4a4 <+352>: adrp   x8, 310043
    0x1a256c4a8 <+356>: add    x28, x8, #0x3a            ; =0x3a
    (lldb) p/x ((($pc>>12)+310043)<<12)+0x3a
    (unsigned long) $18 = 0x00000001ee08703a
    (lldb) po (SEL)$18
    "isEqual:"

    # x22 等于桶的可用容量，后面 key 的 hash冲突后会+1
    0x1a256c4ac <+360>: mov    x22, x26
    0x1a256c4b0 <+364>: mov    x19, x26

        # x24 指向 buffer，x21 是“桶偏移量1”。冲突后，x21 就会向后顺移一位，直到找到合适的位置
        # 所以， x0 指向桶的位置存储的内容
        0x1a256c4b4 <+368>: ldr    x0, [x24, x21, lsl #3]

        # 判断“桶偏移量1”位置是否有旧值，没有旧值，直接调到 +464 处理
        0x1a256c4b8 <+372>: cbz    x0, 0x1a256c514           ; <+464>

    # 此处开始处理  “桶偏移量1”存在旧值（hash 冲突）的场景

    # 判断是否被标为 ___NSDictionaryM_DeletedMarker ，相同直接调到 +412 处理
    0x1a256c4bc <+376>: cmp    x0, x25
    0x1a256c4c0 <+380>: b.eq   0x1a256c4e0               ; <+412>

        # 判断旧的位置和即将存入的 key 地址是否相同，如果相同，进入 +456 的逻辑（key 被放到“桶偏移量1”）
        0x1a256c4c4 <+384>: cmp    x0, x27
        0x1a256c4c8 <+388>: b.eq   0x1a256c50c               ; <+456>

    # 退化逻辑，通过 isEqual: 判断两个 key 是否相同
    0x1a256c4cc <+392>: mov    x1, x28
    0x1a256c4d0 <+396>: mov    x2, x27
    # 发送消息
    0x1a256c4d4 <+400>: bl     0x1a2153e28

    # 如果不等，则说明 key 真的冲突了，需要进入 key 冲突处理逻辑（计算新的“桶偏移量2”，并放入 key）
    0x1a256c4d8 <+404>: tbz    w0, #0x0, 0x1a256c4e8     ; <+420>
    # 如果相同，进入 +456 的逻辑（key 被放到“桶偏移量1”）
    0x1a256c4dc <+408>: b      0x1a256c50c               ; <+456>

    # 如果 x19 仍然等于 字典容量： x26，则 x19=x21,否则保持原样
    0x1a256c4e0 <+412>: cmp    x19, x26
    0x1a256c4e4 <+416>: csel   x19, x21, x19, eq

    loc_1804cc4e8:
    # key hash 冲突处理；
    # 1. 将“桶偏移量1”+1
    0x1a256c4e8 <+420>: add    x8, x21, #0x1             ; =0x1
    # 2. 相加后是否超过 桶的数量
    0x1a256c4ec <+424>: cmp    x8, x26
    # 3. 如果小于，则x9=0，否则等于 相加后的值
    0x1a256c4f0 <+428>: csel   x9, xzr, x26, lo
    # 4. 再将 x8-x9;
    0x1a256c4f4 <+432>: sub    x21, x8, x9
    上面的指令合并后如下：
    if {(x21+1)<x26) {
        x21 = x8-x9 = x8-0 = x21+1-0 = x21+1;
    } else {
        x21 = x8 -x9 = x8 - x26 = x21+1-x26;
    }
    简单来说就是“桶偏移量2” = (“桶偏移量1”+1) % 桶的数量

    # x22 等于桶的可用容量，减一后，再从 + 368 开始处理，会判断 “桶偏移量2” 位置是否存在冲突
    0x1a256c4f8 <+436>: subs   x22, x22, #0x1            ; =0x1
    0x1a256c4fc <+440>: b.ne   0x1a256c4b4               ; <+368>

    0x1a256c500 <+444>: b      0x1a256c51c               ; <+472>
    0x1a256c504 <+448>: mov    x19, #0x0
    0x1a256c508 <+452>: b      0x1a256c51c               ; <+472>

    x19=x21
    0x1a256c50c <+456>: mov    x19, x21
    0x1a256c510 <+460>: b      0x1a256c51c               ; <+472>

        # 如果 x19 仍然等于 x26，则 x19 等于 x21，否则保持原样
        0x1a256c514 <+464>: cmp    x19, x26
        0x1a256c518 <+468>: csel   x19, x21, x19, eq

    # 又一次取出 “桶偏移量“对应的桶存储的内容，如果不存在内容，则转到 +512 处理
    0x1a256c51c <+472>: ldr    x8, [x24, x19, lsl #3]
    0x1a256c520 <+476>: cbz    x8, 0x1a256c544           ; <+512>

    # 取出 buffer 对应 values 存储区域的起始位置
    0x1a256c524 <+480>: ldr    x8, [sp, #0x48]
    # 取出当前 key 对应的 value
    0x1a256c528 <+484>: ldr    x0, [x8, x19, lsl #3]
    0x1a256c52c <+488>: cmp    x0, #0x1                  ; =0x1
    x22 等于 桶的数量
    0x1a256c530 <+492>: mov    x22, x20
    x20 是 count
    0x1a256c534 <+496>: ldr    x20, [sp, #0x28]
    lt 代表小于0或者无序，如果 value 的值小于1，则调到 +616 执行对 value 的处理
    0x1a256c538 <+500>: b.lt   0x1a256c5ac               ; <+616>
    # 否则，调用 objc_release 释放旧的值
    0x1a256c53c <+504>: bl     0x1a2153e4c
    然后再跳转到 +616 执行对 value 的处理
    0x1a256c540 <+508>: b      0x1a256c5ac               ; <+616>

    # 找到了合适的位置，开始存储 key

    # [sp, #0x38] 是 keys
    0x1a256c544 <+512>: ldr    x8, [sp, #0x38]
    # x23 代表当前在处理的 key 索引，x0 等于 key
    0x1a256c548 <+516>: ldr    x0, [x8, x23, lsl #3]

    # [sp, #0x40] 存储了函数接收的一个控制参数，
    0x1a256c54c <+520>: ldr    x8, [sp, #0x40]
    如果参数末位非0，则跳转到 556 处理
    0x1a256c550 <+524>: tbnz   w8, #0x0, 0x1a256c570     ; <+556>

    否则，将 key 的直接直接存入对应位置
    0x1a256c554 <+528>: str    x0, [x24, x19, lsl #3]

    key 和 1 比较
    0x1a256c558 <+532>: cmp    x0, #0x1                  ; =0x1

    x22 等于 桶的数量
    x20 是 count
    0x1a256c55c <+536>: mov    x22, x20
    0x1a256c560 <+540>: ldr    x20, [sp, #0x28]

    如果是空，再跳转
    0x1a256c564 <+544>: b.lt   0x1a256c588               ; <+580>
    对 key 进行 retain 操作
    0x1a256c568 <+548>: bl     0x1a2153e58
    0x1a256c56c <+552>: b      0x1a256c588               ; <+580>

        # 获取前面保存的 SEL: copyWithZone:
        0x1a256c570 <+556>: ldr    x1, [sp, #0x8]
        0x1a256c574 <+560>: mov    x2, #0x0
        # 发送消息，目的是将 key 进行复制
        0x1a256c578 <+564>: bl     0x1a2153e28

        # 将复制的 key 存到对应的桶；x24 指向 buffer，加上偏移量 x19 后就可以执行真正的桶
        0x1a256c57c <+568>: str    x0, [x24, x19, lsl #3]

    ; x22 等于 桶的数量
    ; x20 是 count

    0x1a256c580 <+572>: mov    x22, x20
    0x1a256c584 <+576>: ldr    x20, [sp, #0x28]

    # 动态读取 实例变量 __NSDictionaryM.storage 的偏移量
    0x1a256c588 <+580>: adrp   x8, 367773
    0x1a256c58c <+584>: ldrsw  x8, [x8, #0xdb8]
      Address: CoreFoundation[0x00000001da169db8] (CoreFoundation.__DATA.__objc_ivar + 1192)
      Summary: CoreFoundation`__NSDictionaryM.storage


    取出 dic->storage
    0x1a256c590 <+588>: ldr    x11, [sp, #0x18]

    取出 dic->storage.state
    0x1a256c594 <+592>: ldr    x9, [x11, x8]

        下面的几个指令等价于 dic->storage.state.used += 1;

        used 宽度是 24位，右侧有32位（mutbits 和 copyKeys）
        先对 used+1 操作
        0x1a256c598 <+596>: mov    x10, #0x100000000
        0x1a256c59c <+600>: add    x10, x9, x10

        逻辑右移，移除 （mutbits 和 copyKeys）
        0x1a256c5a0 <+604>: lsr    x10, x10, #32

        位域操作，将 x10 持有的 24 位的 used 更新 x9
        0x1a256c5a4 <+608>: bfi    x9, x10, #32, #25

        将新的 state 放回 dic->storage.state
        0x1a256c5a8 <+612>: str    x9, [x11, x8]


    ; x22 等于 桶的数量
    ; x20 是 count

    # 取出 values
    0x1a256c5ac <+616>: ldr    x8, [sp, #0x30]
    # 取出与 key 配对的 value
    0x1a256c5b0 <+620>: ldr    x0, [x8, x23, lsl #3]

    # 再次取出 buffer 对应的 values
    0x1a256c5b4 <+624>: ldr    x8, [sp, #0x48]
    # 把 value 存进去
    0x1a256c5b8 <+628>: str    x0, [x8, x19, lsl #3]

    # 取出参数**可变字典Option**
    0x1a256c5bc <+632>: ldr    x8, [sp, #0x40]
    看看是否有 **NSEnumeration屏蔽对Value进行Retain**，如果有，则跳过对 value 的 objc_retain 操作
    0x1a256c5c0 <+636>: tbnz   w8, #0x2, 0x1a256c5d0     ; <+652>
        0x1a256c5c4 <+640>: cmp    x0, #0x1                  ; =0x1
        0x1a256c5c8 <+644>: b.lt   0x1a256c5d0               ; <+652>

        对 value 进行 objc_retain 操作
        0x1a256c5cc <+648>: bl     0x1a2153e58

    # x23 代表第几个 key，先 +1
    0x1a256c5d0 <+652>: add    x23, x23, #0x1            ; =0x1
    后与 x20 count 比较
    0x1a256c5d4 <+656>: cmp    x23, x20
    不等则继续遍历
    0x1a256c5d8 <+660>: b.ne   0x1a256c480               ; <+316>

    # 动态获取 cow 的偏移量
    0x1a256c5dc <+664>: adrp   x8, 367773
    0x1a256c5e0 <+668>: ldrsw  x8, [x8, #0xdbc]
    (lldb) image lookup -a ((($pc>>12)+367773)<<12)+0xdbc
      Address: CoreFoundation[0x00000001da169dbc] (CoreFoundation.__DATA.__objc_ivar + 1196)
      Summary: CoreFoundation`__NSDictionaryM.cow

    # 取出字典；+152 曾经将 dic 临时存储到栈上
    0x1a256c5e4 <+672>: ldr    x0, [sp, #0x10]

    # 等价于 dic->cow = NULL
    0x1a256c5e8 <+676>: add    x8, x0, x8
    0x1a256c5ec <+680>: stlr   xzr, [x8]

    恢复栈
    0x1a256c5f0 <+684>: ldp    x29, x30, [sp, #0xa0]
    0x1a256c5f4 <+688>: ldp    x20, x19, [sp, #0x90]
    0x1a256c5f8 <+692>: ldp    x22, x21, [sp, #0x80]
    0x1a256c5fc <+696>: ldp    x24, x23, [sp, #0x70]
    0x1a256c600 <+700>: ldp    x26, x25, [sp, #0x60]
    0x1a256c604 <+704>: ldp    x28, x27, [sp, #0x50]
    0x1a256c608 <+708>: add    sp, sp, #0xb0             ; =0xb0
    0x1a256c60c <+712>: ret

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

libobjc.A.dylib`objc_autorelease:
    0x1b6894d20 <+0>:  cmp    x0, #0x1                  ; =0x1
    0x1b6894d24 <+4>:  b.lt   0x1b6894d5c               ; <+60>
    0x1b6894d28 <+8>:  ldr    x8, [x0]
    0x1b6894d2c <+12>: and    x8, x8, #0xffffffff8
    0x1b6894d30 <+16>: ldrb   w8, [x8, #0x20]
    0x1b6894d34 <+20>: tbz    w8, #0x2, 0x1b6894d64     ; <+68>
    0x1b6894d38 <+24>: ldr    w8, [x30]
    0x1b6894d3c <+28>: mov    w9, #0x3fd
    0x1b6894d40 <+32>: movk   w9, #0xaa1d, lsl #16
    0x1b6894d44 <+36>: cmp    w8, w9
    0x1b6894d48 <+40>: b.ne   0x1b6894d60               ; <+64>
    0x1b6894d4c <+44>: mrs    x8, TPIDRRO_EL0
    0x1b6894d50 <+48>: and    x8, x8, #0xfffffffffffffff8
    0x1b6894d54 <+52>: mov    w9, #0x1
    0x1b6894d58 <+56>: str    x9, [x8, #0x160]
    0x1b6894d5c <+60>: ret
    0x1b6894d60 <+64>: b      0x1b6893a50               ; objc_object::rootAutorelease2()
    0x1b6894d64 <+68>: adrp   x8, 226945
    0x1b6894d68 <+72>: add    x1, x8, #0xaba            ; =0xaba
    0x1b6894d6c <+76>: b      0x1b6873460               ; objc_msgSend