探索 iOS 編碼對包大小的影響

本文講述的技術點屬于比較極致和新穎的包大小優化技術，文章會從二進制、匯編指令的層面來分析 oc 代碼對包大小的影響。接下來會從以下三個方面進行講述：

1. 二進制層面分析 oc 代碼對包大小的影響
2. 編碼上優化包大小的 tips
3. 總結各種 tips 的收益

從二進制文件層面來分析編碼對包大小影響

以分析屬性為例子，介紹一種“從二進制文件層面來分析編碼對包大小影響”的分析方法。

文章底部有抖音直播內推群二維碼。

實驗背景：用真機 iphone11，iOS13.5.1，release，build setting 默認設置，linkmap file 使用 arm64 進行實驗。

.o 級別對比

通過對比 ViewControler 沒有屬性、有一個屬性、兩個屬性的情況：

@interface ViewController : UIViewController

@property (nonatomic, strong) NSString *myString1;

@property (nonatomic, strong) NSString *myString2;

@end

ViewController.o占用字節

• 沒有屬性 0.36k
• 一個屬性 0.67k
• 兩個屬性 0.92k

當一個類減少一個屬性，會減少 0.25k，這里有一個前提，這個類還有其他屬性。

因此，我們可以得到一個結論：一個屬性占用 0.25K。

查看 linkmap file 中的符號屬于哪個 section 的 tips

# Sections:
# Address        Size            Segment        Section
0x10000623C        0x00000224        __TEXT        __text
0x100006460        0x00000090        __TEXT        __stubs

__TEXT.__text 的地址范圍是 0x10000623C - 0x100006460，那么 linkmap file 中的 Symbols 對應的地址，如果是在這個范圍內，就屬于__TEXT__.text。

0x10000623C        0x00000034        [  1] -[ViewController viewDidLoad]
0x100006270        0x00000010        [  1] -[ViewController myString1]
0x100006280        0x00000014        [  1] -[ViewController setMyString1:]
0x100006294        0x00000010        [  1] -[ViewController myString2]
0x1000062A4        0x00000014        [  1] -[ViewController setMyString2:]
0x1000062B8        0x00000040        [  1] -[ViewController .cxx_destruct]
0x1000062F8        0x00000008        [  2] -[AppDelegate application:didFinishLaunchingWithOptions:]
0x100006300        0x0000008C        [  2] -[AppDelegate application:configurationForConnectingSceneSession:options:]
0x10000638C        0x00000004        [  2] -[AppDelegate application:didDiscardSceneSessions:]
0x100006390        0x00000080        [  3] _main
0x100006410        0x00000004        [  4] -[SceneDelegate scene:willConnectToSession:options:]
0x100006414        0x00000004        [  4] -[SceneDelegate sceneDidDisconnect:]
0x100006418        0x00000004        [  4] -[SceneDelegate sceneDidBecomeActive:]
0x10000641C        0x00000004        [  4] -[SceneDelegate sceneWillResignActive:]
0x100006420        0x00000004        [  4] -[SceneDelegate sceneWillEnterForeground:]
0x100006424        0x00000004        [  4] -[SceneDelegate sceneDidEnterBackground:]
0x100006428        0x00000010        [  4] -[SceneDelegate window]
0x100006438        0x00000014        [  4] -[SceneDelegate setWindow:]
0x10000644C        0x00000014        [  4] -[SceneDelegate .cxx_destruct]
0x100006460        0x0000000C        [  5] _NSStringFromClass

0x10000623C 到 0x100006460 的符號都屬于__TEXT.__text。

探索一個屬性會產生哪些符號

將 section(節) size 不同拎出來，數字的單位：字節

__TEXT 段：

__DATA 段：

分析：

$1 表示沒有屬性和一個屬性的對比

$2 表示一個屬性和兩個屬性的對比

TEXT.text 分析

Linkmap File 差異：

// ViewController沒有屬性，差異點是沒有-[ViewController .cxx_destruct]符號
// 一個屬性: 16 + 20 + 20 = 56(與上方的 $1是對應上的)
0x100006318        0x00000010        [  1] -[ViewController myString1]
0x100006328        0x00000014        [  1] -[ViewController setMyString1:]
0x10000633C        0x00000014        [  1] -[ViewController .cxx_destruct]
// 兩個屬性 16 + 20 + 16 + 20 +64 = 136
// 一個屬性與兩個屬性比較 136 - 56 = 80(與上方的 $2是對應上的)
0x100006270        0x00000010        [  1] -[ViewController myString1]
0x100006280        0x00000014        [  1] -[ViewController setMyString1:]
0x100006294        0x00000010        [  1] -[ViewController myString2]
0x1000062A4        0x00000014        [  1] -[ViewController setMyString2:]
0x1000062B8        0x00000040        [  1] -[ViewController .cxx_destruct]

疑惑點：.cxx_destruct的大小不一樣，以下用兩個截圖回答這個問題，因為.cxx_destruct 內部的實現不一樣，導致匯編的指令數量也不一樣。

一個屬性 .cxx_destruct內部實現的匯編代碼：

兩個屬性 .cxx_destruct內部實現的匯編代碼：

TEXT.objc_methname 分析

// 比較字節方法如上
// 一個屬性
0x1000065FC        0x0000000A        [  1] literal string: myString1
0x100006606        0x0000000E        [  1] literal string: setMyString1:
0x100006614        0x0000000E        [  1] literal string: .cxx_destruct
0x100006622        0x0000000B        [  1] literal string: _myString1
// 兩個屬性
0x1000065A4        0x0000000A        [  1] literal string: myString1
0x1000065AE        0x0000000E        [  1] literal string: setMyString1:
0x1000065BC        0x0000000A        [  1] literal string: myString2
0x1000065C6        0x0000000E        [  1] literal string: setMyString2:
0x1000065D4        0x0000000E        [  1] literal string: .cxx_destruct
0x1000065E2        0x0000000B        [  1] literal string: _myString1
0x1000065ED        0x0000000B        [  1] literal string: _myString2

這里補充額外的一個點Dead Stripped Symbols相關的知識點：

// Text.text
0x1000062B8        0x00000040        [  1] -[ViewController .cxx_destruct]
0x10000644C        0x00000014        [  4] -[SceneDelegate .cxx_destruct]
// TEXT.objc_methname
0x1000065D4        0x0000000E        [  1] literal string: .cxx_destruct
<<dead>>         0x0000000E            [  4] literal string: .cxx_destruct

Dead Stripped Symbols的意思是.o 文件中不必要的符號去掉；

例如[ 4] literal string: .cxx_destruct就是不必要的符號，[ 4]是指SceneDelegate.o之所以不必要是因為對于objc_methname節來說，不需要有同名的符號。

// linkfile map內容，[ 4]指SceneDelegate.o
[  4] /Users/xxxx/Library/Developer/Xcode/DerivedData/PacketSize-athynpqwkehwhtfsynewxvtjyvdz/Build/Intermediates.noindex/PacketSize.build/Release-iphoneos/PacketSize.build/Objects-normal/arm64/SceneDelegate.o

Xcode 中Dead Stripped Symbols相關的設置：

TEXT.objc_methtype

// 有NSString屬性，有以下符號
0x1000073CF        0x00000008        [  1] literal string: @16@0:8
0x1000073D7        0x0000000B        [  1] literal string: v24@0:8@16
0x1000073E2        0x0000000C        [  1] literal string: @"NSString"
// 同樣Dead Stripped Symbols中也有@16@0:8、v24@0:8@16

TEXT.cstring 分析

// 一個屬性 10 + 29 = 39
0x100007EE2        0x0000000A        [  1] literal string: myString1
0x100007EEC        0x0000001D        [  1] literal string: T@"NSString",&,N,V_myString1
// 兩個屬性
0x100007EAF        0x0000000A        [  1] literal string: myString1
0x100007EB9        0x0000001D        [  1] literal string: T@"NSString",&,N,V_myString1
0x100007ED6        0x0000000A        [  1] literal string: myString2
0x100007EE0        0x0000001D        [  1] literal string: T@"NSString",&,N,V_myString2

TEXT.objc_classname 分析

兩個屬性，比其他多占用了兩個字節，目前還不知道這兩個字節是怎么排列出來的，字節對齊？
0x100007322        0x0000000F        [  1] literal string: ViewController
0x100007331        0x00000002        [  1] literal string: 
0x100007333        0x0000000C        [  2] literal string: AppDelegate
0x10000733F        0x00000016        [  2] literal string: UIApplicationDelegate
0x100007355        0x00000009        [  2] literal string: NSObject
0x10000735E        0x0000000E        [  4] literal string: SceneDelegate
0x10000736C        0x00000016        [  4] literal string: UIWindowSceneDelegate
0x100007382        0x00000010        [  4] literal string: UISceneDelegate
0x100007392        0x00000002        [  4] literal string: 

DATA.objc_const 分析

沒有屬性
0x100008110        0x00000020        [  1] __OBJC_$_INSTANCE_METHODS_ViewController

一個屬性 40 + 24 + (104 - 32) = 136
0x100008178        0x00000028        [  1] __OBJC_$_INSTANCE_VARIABLES_ViewController
0x100008110        0x00000068        [  1] __OBJC_$_INSTANCE_METHODS_ViewController
0x1000081A0        0x00000018        [  1] __OBJC_$_PROP_LIST_ViewController

兩個屬性 (152 - 104) + (72 - 40) + (40 - 24) = 96
0x100008110        0x00000098        [  1] __OBJC_$_INSTANCE_METHODS_ViewController
0x1000081A8        0x00000048        [  1] __OBJC_$_INSTANCE_VARIABLES_ViewController
0x1000081F0        0x00000028        [  1] __OBJC_$_PROP_LIST_ViewController

DATA.objc_ivar 分析

一個屬性
0x1000094B0        0x00000004        [  1] _OBJC_IVAR_$_ViewController._myString1
兩個屬性
0x100009510        0x00000004        [  1] _OBJC_IVAR_$_ViewController._myString1
0x100009514        0x00000004        [  1] _OBJC_IVAR_$_ViewController._myString2

總結：通過以上的介紹，我們掌握了“從二進制文件層面分析編碼對包大小的影響”的分析方法，用此方法我們可以繼續分析“函數、direct、block”對包大小的影響。

編碼上優化包大小的 Tips

屬性動態化

探索對屬性添加@dynamic 會對二進制文件產生的影響，探索方式跟上面一樣，還是通過 link file map 的符號分析：

@interface ViewController()

// 對比myString1屬性有無添加@dynamic修飾的區別
@property (nonatomic, copy) NSString *myString1;

@end

TEXT.text 分析

| segment | section | 無 dynamic | 有dynamic |比較 |
| ----- | ----- | ----- | ----- | ----- | ----- | ----- | | TEXT | text |412 |468 | 56|

// 添加dynamic修飾沒有以下部分
// 16 + 20 + 20 = 56
0x100006318        0x00000010        [  1] -[ViewController myString1]
0x100006328        0x00000014        [  1] -[ViewController setMyString1:]
0x10000633C        0x00000014        [  1] -[ViewController .cxx_destruct]

說明添加了@dynamic修飾不會生成 getter、setter，并且沒有實例變量，自然也不需要在dealloc中執行置 nil 的代碼。

TEXT.objc_methname 分析

| segment | section | 無 dynamic | 有dynamic |比較 |
| ----- | ----- | ----- | ----- | ----- | ----- | ----- | | TEXT | objc_methname |3431 | 3396 | 35|

// 添加dynamic修飾沒有以下部分
// 10 + 14 + 11 = 35
0x1000065FC        0x0000000A        [  1] literal string: myString1
0x100006606        0x0000000E        [  1] literal string: setMyString1:
0x100006622        0x0000000B        [  1] literal string: _myString1

說明添加了@dynamic修飾不會生成 getter、setter，并且沒有實例變量，自然就不需要生成對應的常量符號。

TEXT.objc_methtype 分析

| segment | section | 無 dynamic | 有dynamic |比較 |
| ----- | ----- | ----- | ----- | ----- | ----- | ----- | | TEXT | objc_methtype |2831 |2843 | 12|

// 添加dynamic修飾沒有下面的符號
// 但是在計算添加dynamic收益時，不能將這個計算入內，原因是一個項目一般都是這些符號的
0x1000073E2        0x0000000C        [  1] literal string: @"NSString"

TEXT.cstring 分析

| segment | section | 無 dynamic | 有dynamic |比較 |
| ----- | ----- | ----- | ----- | ----- | ----- | ----- | | TEXT | cstring |173 |183 | 10|

一個屬性
0x100007EEC        0x0000001D        [  1] literal string: T@"NSString",&,N,V_myString1
dynamic屬性
0x100007EF9        0x00000013        [  1] literal string: T@"NSString",&,D,N

【T@"NSString",&,N,V_myString1】和【T@"NSString",&,D,N】是屬性類型字符串， property type stringapple 的官方文檔中有這個介紹

https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtPropertyIntrospection.html#//apple_ref/doc/uid/TP40008048-CH101 // 關于屬性類型字符串介紹

DATA.objc_const 分析

| segment | section | 無 dynamic | 有dynamic |比較 |
| ----- | ----- | ----- | ----- | ----- | ----- | ----- | | DATA | objc_const |4928 |5040 | 112|

一個屬性
0x100008110        0x00000068        [  1] __OBJC_$_INSTANCE_METHODS_ViewController
0x100008178        0x00000028        [  1] __OBJC_$_INSTANCE_VARIABLES_ViewController

dynamic屬性
0x100008110        0x00000020        [  1] __OBJC_$_INSTANCE_METHODS_ViewController

(104 - 32) + 40 = 112

實例方法列表沒有 myString1 的 getter、setter。

DATA.objc_ivar 分析

| segment | section | 無 dynamic | 有dynamic |比較 |
| ----- | ----- | ----- | ----- | ----- | ----- | ----- | | DATA | objc_ivar|4 |8 | 4|

dynamic 屬性沒有以下符號
0x1000094B0        0x00000004        [  1] _OBJC_IVAR_$_ViewController._myString1

沒有實例變量，自然就沒有_OBJC_IVAR_$_ViewController._myString1符號。

結論：用@dynamic優化一個屬性，收益是(229 - 12)= 217B，12 是__objc_methtype 不能算進來；應用場景是對 model 類添加@dynamic。

方法調用、函數調用、direct 方法調用

實驗數據

實驗方法：

// 對照組
#define Test // 先空實現
void func(ViewController *mSelf)
{
  [mSelf method];
}

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  [self test];
}

- (void)method
{
  NSLog(@"");
}

- (void)test
{
    // 2000個 Test 宏的調用，注意，對照組的宏是空實現
}

// 方法調用 的 實驗
// 修改Test宏
#define Test [self method];

// 函數調用 的 實驗
#define Test func(self);

// direct方法調用 的 實驗
#define Test [self method];
- (void)test __attribute__((objc_direct));

使用函數的匯編指令：

使用方法的匯編指令：

以上兩個截圖的匯編指令基本一樣，說明在調用 func(self)函數時，因為函數內部實現過于簡單，被編譯優化了，直接優化為內斂函數。

修改 func 函數的實現，避開編譯優化：

// 不影響調用邏輯的情況下，將函數實現改復雜點
void func(ViewController *mSelf)
{
  if ([mSelf isKindOfClass:[ViewController class]]) {
    [mSelf method];
  }
}

另外還做了一組方法名長度不同的實驗：

短方法名：method

長方法名：methodmethodmethodmethodmethodmethodmethodmethod

短方法名和長方法名對二進制大小的影響？

分別查看短方法名和長方法名的 TEXT.text

// 短方法名
0x100004560        0x00005FB4        __TEXT        __text
0x1000045CC        0x00005DDC        [  1] -[ViewController test]
// 長方法名
0x100004534        0x00005FB4        __TEXT        __text
0x1000045A0        0x00005DDC        [  1] -[ViewController test]

大小都是0x00005FB4

短方法：

長方法：

短方法名和長方法名對二進制大小的影響非常小，TEXT.text 的大小是一樣的，原因是方法調用主要是操作函數指針，此時方法名長度對此沒有影響；

那么主要影響是TEXT.objc_methname

// 短方法名
0x10000A664        0x00000D96        __TEXT        __objc_methname
// 長方法名
0x10000A638        0x00000DC0        __TEXT        __objc_methname

本實驗中，函數調用和方法調用的區別？

先對比下方法調用和函數調用，在二進制上的區別：

// 函數和方法的區別
// 函數調用
0x100006448        0x000040CC        __TEXT        __text
// 方法調用
0x100004560        0x00005FB4        __TEXT        __text

區別還是在 TEXT.text 上。

函數調用的匯編：

方法調用的匯編：

方法調用需要更多的指令，因此將方法調用改為函數調用，隨著調用處越多，包大小的收益越大。

函數調用和 direct 方法調用的區別？

// 函數和direct的區別
// 函數調用
0x100006448        0x000040CC        __TEXT        __text
0x10000A664        0x00000D96        __TEXT        __objc_methname
0x10000BF90        0x00000070        __TEXT        __unwind_info
0x10000C0F0        0x00001358        __DATA        __objc_const
0x10000D448        0x00000038        __DATA        __objc_selrefs
0x10000D480        0x00000018        __DATA        __objc_classrefs
// direct調用
0x1000064C4        0x00004060        __TEXT        __text
0x10000A674        0x00000D8F        __TEXT        __objc_methname
0x10000BF9C        0x00000064        __TEXT        __unwind_info
0x10000C0F0        0x00001340        __DATA        __objc_const
0x10000D430        0x00000028        __DATA        __objc_selrefs
0x10000D458        0x00000010        __DATA        __objc_classrefs

// direct方法調用TEXT.text中沒有[ViewController method]符號，但是當method方法內部的實現比較多時，就會有[ViewController method]符號；原因是method過于簡單被編譯器優化為內聯了
// 因為method被內聯了，所以__objc_selrefs少了一個符號；但是當method實現復雜了，會多一個method方法的調用，__objc_selrefs就多一個符號

// 函數在TEXT.objc_methname多了以下兩個符號
0x10000A664        0x00000006        [  1] literal string: class
0x10000A66A        0x0000000F        [  1] literal string: isKindOfClass:

// 函數調用實例方法列表尺寸比direct方法調用大，原因direct沒有實例方法
// 函數調用
0x10000C138        0x00000050        [  1] __OBJC_$_INSTANCE_METHODS_ViewController
// direct方法調用
0x10000C138        0x00000038        [  1] __OBJC_$_INSTANCE_METHODS_ViewController

結論：direct 方法收益和函數調用基本一致，每一處調用優化收益是 3.93b。

函數調用、direct 方法調用為何可以減少二進制文件大??？

正常方法調用：

函數調用：

direct 方法調用：

x0是儲存函數的第一個參數，msgSend的第一個參數肯定是self，所以x0是self
cbz先判斷self是否存在，如果不存在，goto 0x1000063ac->ret,ret是return；

- (void)method
{
  NSLog(@"");
}
如果self存在，則執行 NSLog

因為method方法實現過于簡單，被編譯器優化為內聯了。

當方法實現比較簡單，使用 direct 修飾，可以優化調用效率，但是包大小收益可能是負收益；因為很多處調用 direct 方法被內聯。

回到一開始的問題：函數調用、direct 方法調用可以減少二進制文件大小的原因是因為相比方法調用，指令變少了。

去 Block

實驗內容：

// 有block和無block的代碼區別
- (void)blockTest
{
    [self.blockProvider blockInterface1:1];
}
- (void)blockTest
{
    [self.blockProvider blockInterface:^{

    }];
}

block 調用會產生哪些符號？

// 一個block調用與兩個block調用的區別
// __DATA.const（沒有初始化過的常量） 多一個調用就會多一個___block_literal_global符號，這個占用32個字節
0x100008070        0x00000020        [  1] ___block_descriptor_32_e5_v8?0l
0x100008090        0x00000020        [  1] ___block_literal_global
0x1000080B0        0x00000020        [  1] ___block_literal_global.12

// ___block_literal_global就是Block_layout結構體對象
struct Block_layout {
void *isa; int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
/* Imported variables. */
};

每多一處 block 的調用，會多一個___block_literal_global 符號，占用 32b。

// 無block調用
0x1000060A4        0x00000044        [  1] -[ViewController blockTest]
// 一個block調用
0x100006094        0x00000048        [  1] -[ViewController blockTest]
0x1000060DC        0x00000004        [  1] ___27-[ViewController blockTest]_block_invoke
// 包含_block_invoke這個符號，則說明[ViewController blockTest]方法的實現中，有實現block

// 兩個block調用
// 如果有兩個block調用，會多出 ___29-[ViewController viewDidLoad]_block_invoke_2

// 有一個block調用比無block調用多出 36 + 4 = 40b
// 有兩個block調用比有一個block調用多出24 + 4 = 28b

每多一處 block 的調用，會多一個_block_invoke_2 符號，占用 4b。

block 調用和方法調用，在調用處的匯編指令差別？

方法調用：

- (void)blockTest
{
  [self.blockProvider blockInterface1:1];
}

block 調用：

在調用處的指令，block 調用只是比方法調用多了一個指令，多了 4 個字節（maplinkfile 計算出來的）。

去 Block 優化的示例

含有 block 參數方法的實現：

// 定義含有block的方法
- (void)blockInterface:(void(^)(void))block
{
  [self shill];

  !block ? : block();
}

- (void)shill
{
  NSString *string = @"123";
  if ([string isKindOfClass:[NSString class]]) {
    NSLog(@"123");
  }
}

// 去Block的優化
#define CallBlock(blockProvider,BLOCK)\
[blockProvider shill];\
BLOCK

實驗對比：

- (void)blockTest
{
  [self.blockProvider blockInterface:^{
    NSLog(@"block");
  }];
}

- (void)blockTest
{
  CallBlock(self.blockProvider,{
    NSLog(@"block");
  })
}

// 去Block，相當于把block的實現內聯了
0x100006064        0x00000050        [  1] -[ViewController blockTest]

// 調用含有block的方法
// TEXT.text
0x10000604C        0x00000048        [  1] -[ViewController blockTest]
0x100006094        0x0000001C        [  1] ___27-[ViewController blockTest]_block_invoke
// DATA.const
0x100008070        0x00000020        [  1] ___block_descriptor_32_e5_v8?0l
0x100008090        0x00000020        [  1] ___block_literal_global

調用含有 block 的方法：

去 Block：

結論：去 Block 的主要收益在于減少了___block_literal_global 和_block_invoke 符號，但是去 block 相當于把 block 的實現內聯了，_block_invoke 主要大小的占用是 block 的實現，這塊內聯和_block_invoke 的差異差不多有 0x0000001C(28) - (0x00000050 - 0x00000048) = 20b；

___block_literal_global 固定 20b；

所以去 block 的收益是 40b。

總結

1. 介紹了從二進制文件層面分析編碼對包大小的影響；
2. 介紹了屬性、方法調用、函數調用、direct 方法調用、block 調用在匯編下的差別，讓我們在平時編碼中，能有個大概的印象，該代碼對應的匯編大概是什么樣子；
3. 得出一些收益數據：

https://mp.weixin.qq.com/s/3Z_IFBpjwDTrB6ynu2bKcQ