您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

深入解析 Objective-C:方法在記憶體中如何存放

編輯:iOS 開發基礎

本文授權轉載,作者:左書祺(關注倉庫,及時獲得更新:iOS-Source-Code-Analyze)

由於 Objective-C 的 runtime 只能在 Mac OS 下編譯,文中程式碼都運行在 Mac OS(x86_64 架構)環境;對於 arm64 上的差異會特別說明。

上一篇分析 isa 的文章〈從 NSObject 的初始化了解 isa〉中提到過:實例方法被呼叫時,會透過持有的 isa 指標找到對應的類,再到其中的 class_data_bits_t 裡查找方法。本文要說的就是——方法在 Objective-C 中究竟是如何存儲的。

文章先依據源代碼分析方法在記憶體中的存儲結構,然後在 lldb 除錯器中一步步驗證分析結果。

方法在記憶體中的位置

先來看 Objective-C 中類的結構圖:

  • isa:指向元類的指標。不清楚元類的可以參考 Classes and Metaclasses
  • super_class:指向當前類的父類
  • cache:用於快取指標與 vtable,加速方法呼叫
  • bits:存儲類的方法、屬性、遵循的協議等資訊的地方

class_data_bits_t 結構體

這小節分析類結構體中的 class_data_bits_t bits。它只包含一個 64 位的 bits,用於存儲與類有關的資訊:

objc_class 結構體中的註解寫道:class_data_bits_t 相當於一個 class_rw_t 指標加上 rr/alloc 標誌。

class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags

它提供了便捷方法來取出其中的 class_rw_t *:

class_rw_t *data() {
    return (class_rw_t *)(bits & FAST_DATA_MASK);
}

把 bits 與 FAST_DATA_MASK 做位運算,只取其中的 [3, 47] 位,轉型成 class_rw_t * 回傳。

在 x86_64 架構上,Mac OS 只使用其中 47 位來為物件配置位址;而且由於位址必須在記憶體中按字節對齊,所以掩碼的後三位都是 0。

因為 class_rw_t * 只佔第 [3, 47] 位,最後三位空了下來,可以用來存儲關於當前類的其他資訊:

#define FAST_IS_SWIFT          (1UL<<0)
#define FAST_HAS_DEFAULT_RR    (1UL<<1)
#define FAST_REQUIRES_RAW_ISA  (1UL<<2)
#define FAST_DATA_MASK         0x00007ffffffffff8UL
  • isSwift():FAST_IS_SWIFT,用於判斷是否為 Swift 類
  • hasDefaultRR():FAST_HAS_DEFAULT_RR,當前類或父類含有預設的 retain/release/autorelease/retainCount/_tryRetain/_isDeallocating/retainWeakReference/allowsWeakReference 方法
  • requiresRawIsa():FAST_REQUIRES_RAW_ISA,當前類的實例需要 raw isa

執行 class_data_bits_t 的 data(),或呼叫 objc_class 中的 data(),會回傳同一個 class_rw_t *——因為後者只是對前者的封裝:

// objc_class 中的 data() 方法
class_data_bits_t bits;

class_rw_t *data() {
    return bits.data();
}

// class_data_bits_t 中的 data() 方法
uintptr_t bits;

class_rw_t *data() {
    return (class_rw_t *)(bits & FAST_DATA_MASK);
}

class_rw_t 與 class_ro_t

Objective-C 類中的屬性、方法與遵循的協議等資訊都保存在 class_rw_t 中:

struct class_rw_t {
    uint32_t flags;
    uint32_t version;

    const class_ro_t *ro;

    method_array_t   methods;
    property_array_t properties;
    protocol_array_t protocols;

    Class firstSubclass;
    Class nextSiblingClass;
};

其中還有一個指向常量的指標 ro,裡面存儲了當前類在編譯期就已經確定的屬性、方法與協議:

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;
    uint32_t reserved;

    const uint8_t * ivarLayout;

    const char * name;
    method_list_t * baseMethodList;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars;
    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;
};

在編譯期間,類結構中的 class_data_bits_t *data 指向的其實是一個 class_ro_t *:

而在載入 Objective-C runtime 的過程中,realizeClass 方法會:

  • 從 class_data_bits_t 呼叫 data,把結果從 class_rw_t 強制轉型為 class_ro_t 指標
  • 配置一個 class_rw_t 結構體
  • 設定結構體的 ro 值與 flag
  • 最後設定正確的 data
const class_ro_t *ro = (const class_ro_t *)cls->data();

class_rw_t *rw = (class_rw_t *)calloc(sizeof(class_rw_t), 1);
rw->ro    = ro;
rw->flags = RW_REALIZED | RW_REALIZING;

cls->setData(rw);

下圖是 realizeClass 執行之後類所占記憶體的佈局,可以與執行前的佈局對照看有哪些變化:

不過在這段程式碼跑完之後,class_rw_t 中的方法、屬性與協議列表仍為空。此時 realizeClass 會呼叫 methodizeClass,把類自己實作的方法(包括分類)、屬性與遵循的協議載入 methods、properties、protocols 列表中。

以 XXObject 為例

下面分析一個類 XXObject 在 runtime 初始化過程中的記憶體變化。這是它的介面與實作:

// XXObject.h 文件
#import 

@interface XXObject : NSObject
- (void)hello;
@end

// XXObject.m 文件
#import "XXObject.h"

@implementation XXObject
- (void)hello {
    NSLog(@"Hello");
}
@end

這段程式碼運行於 Mac OS X 10.11.3(x86_64),而不是 iPhone 模擬器或真機,兩者可能存在差異。

主程式如下:

#import 
#import "XXObject.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Class cls = [XXObject class];
        NSLog(@"%p", cls);
    }
    return 0;
}

編譯後記憶體中類的結構

因為類在記憶體中的位置是編譯期就確定的,先執行一次取得 XXObject 的位址:

0x100001168

接著在整個 runtime 初始化之前,也就是 _objc_init 方法中下中斷點:

然後在 lldb 中輸入:

(lldb) p (objc_class *)0x100001168
(objc_class *) $0 = 0x0000000100001168

(lldb) p (class_data_bits_t *)0x100001188
(class_data_bits_t *) $1 = 0x0000000100001188

(lldb) p $1->data()
warning: could not load any Objective-C class information.
This will significantly reduce the quality of type information available.
(class_rw_t *) $2 = 0x00000001000010e8

(lldb) p (class_ro_t *)$2   // 將 class_rw_t 強制轉化為 class_ro_t
(class_ro_t *) $3 = 0x00000001000010e8

(lldb) p *$3
(class_ro_t) $4 = {
    flags         = 128
    instanceStart = 8
    instanceSize  = 8
    reserved      = 0
    ivarLayout    = 0x0000000000000000
    name          = 0x0000000100000f7a "XXObject"
    baseMethodList = 0x00000001000010c8
    baseProtocols = 0x0000000000000000
    ivars         = 0x0000000000000000
    weakIvarLayout = 0x0000000000000000
    baseProperties = 0x0000000000000000
}

這就是類經過編譯器處理後的唯讀屬性 class_ro_t。可以看到只有 baseMethodList 與 name 有值,其餘 ivarLayout、baseProtocols、ivars、weakIvarLayout、baseProperties 都指向空指標——因為類中沒有實例變數、協議與屬性,完全符合預期。

查看 baseMethodList 的內容:

(lldb) p $4.baseMethodList
(method_list_t *) $5 = 0x00000001000010c8

(lldb) p $5->get(0)
(method_t) $6 = {
    name  = "hello"
    types = 0x0000000100000fa4 "v16@0:8"
    imp   = 0x0000000100000e90 (method`-[XXObject hello] at XXObject.m:13)
}

(lldb) p $5->get(1)
Assertion failed: (i < count), function get,
file /Users/apple/Desktop/objc-runtime/runtime/objc-runtime-new.h, line 110.
error: Execution was interrupted, reason: signal SIGABRT.
The process has been returned to the state before expression evaluation.

用 $5->get(0) 成功取得了 -[XXObject hello] 的方法結構體 method_t;而嘗試取下一個時,斷言直接告訴我們:當前類只有一個方法。

realizeClass

本文不深入分析 realizeClass。它的主要作用是對類做第一次初始化,包括:

  • 配置可讀寫資料空間
  • 回傳真正的類結構
static Class realizeClass(Class cls)

我們在這個方法中下一個條件中斷點,判斷當前類是否為 XXObject:

這裡直接判斷兩個指標是否相等,而不用 [NSStringFromClass(cls) isEqualToString:@"XXObject"],是因為在這個時間點那些方法都不能呼叫——runtime 裡還沒有它們,只能靠指標相等來確認當前類是 XXObject。

直接用指標比較之所以可行,是因為類在記憶體中的位置在編譯期就確定了,只要程式碼不變,位置就不變(這點已經說過很多遍了)。

中斷點設在這裡,因為 XXObject 是一個正常的類,會走 else 分支配置可寫的類資料。

執行時,由於每次都要判斷當前類指標是否指向 XXObject,會等一會兒才進入中斷點。此時列印類結構體中 data 的值,發現佈局依舊:

執行完這段程式碼之後:

我們再列印類的結構:

(lldb) p (objc_class *)cls                  // 打印類指針
(objc_class *) $262 = 0x0000000100001168

(lldb) p (class_data_bits_t *)0x0000000100001188   // 在類指針上加 32 的 offset
(class_data_bits_t *) $263 = 0x0000000100001188

(lldb) p *$263                                // 訪問 class_data_bits_t 的內容
(class_data_bits_t) $264 = (bits = 4302315312)

(lldb) p $264.data()                          // 獲取 class_rw_t
(class_rw_t *) $265 = 0x0000000100701f30

(lldb) p *$265                                // 訪問 class_rw_t,發現 ro 已設置好
(class_rw_t) $266 = {
  flags   = 2148007936
  version = 0
  ro      = 0x00000001000010e8
  methods = {
    list_array_tt<method_t, method_t> = {
      = { list = 0x0000000000000000, arrayAndFlag = 0 }
    }
  }
  properties = {
    list_array_tt<property_t, property_t> = {
      = { list = 0x0000000000000000, arrayAndFlag = 0 }
    }
  }
  protocols = {
    list_array_tt<protocol_t, protocol_t> = {
      = { list = 0x0000000000000000, arrayAndFlag = 0 }
    }
  }
  firstSubclass    = nil
  nextSiblingClass = nil
  demangledName    = 0x0000000000000000
}

(lldb) p $266.ro                              // 獲取 class_ro_t 指針
(const class_ro_t *) $267 = 0x00000001000010e8

(lldb) p *$267                                // 訪問 class_ro_t 的內容
(const class_ro_t) $268 = {
  flags          = 128
  instanceStart  = 8
  instanceSize   = 8
  reserved       = 0
  ivarLayout     = 0x0000000000000000
  name           = 0x0000000100000f7a "XXObject"
  baseMethodList = 0x00000001000010c8
  baseProtocols  = 0x0000000000000000
  ivars          = 0x0000000000000000
  weakIvarLayout = 0x0000000000000000
  baseProperties = 0x0000000000000000
}

(lldb) p $268.baseMethodList                  // 獲取基本方法列表
(method_list_t *const) $269 = 0x00000001000010c8

(lldb) p $269->get(0)                          // 訪問第一個方法
(method_t) $270 = {
  name  = "hello"
  types = 0x0000000100000fa4 "v16@0:8"
  imp   = 0x0000000100000e90 (method`-[XXObject hello] at XXObject.m:13)
}

(lldb) p $269->get(1)                          // 嘗試訪問第二個方法,越界
error: Execution was interrupted, reason: signal SIGABRT.
The process has been returned to the state before expression evaluation.
Assertion failed: (i < count), function get,
file /Users/apple/Desktop/objc-runtime/runtime/objc-runtime-new.h, line 110.

最後一個操作實在是截不到圖。

const class_ro_t *ro = (const class_ro_t *)cls->data();

class_rw_t *rw = (class_rw_t *)calloc(sizeof(class_rw_t), 1);
rw->ro    = ro;
rw->flags = RW_REALIZED | RW_REALIZING;

cls->setData(rw);

這段程式碼跑完之後,類的唯讀指標 class_ro_t 與可讀寫指標 class_rw_t 都被正確設定。但此時 class_rw_t 中的方法等成員指標仍為空,這些會在 methodizeClass 中補上:

這裡呼叫了 method_array_t 的 attachLists,把 baseMethods 中的方法附加到 methods 陣列之後。此時我們存取 methods 才能取得當前類的實例方法。

方法的結構

說了這麼多,我們终于可以看看方法的結構。與類和物件一樣,方法在記憶體中也是一個結構體:

struct method_t {
    SEL name;
    const char *types;
    IMP imp;
};

它包含方法名、類型,以及方法實作的指標 IMP:

前面 -[XXObject hello] 的結構體是這樣:

name  = "hello"
types = 0x0000000100000fa4 "v16@0:8"
imp   = 0x0000000100000e90 (method`-[XXObject hello] at XXObject.m:13)

方法名沒什麼好說的。方法類型則是一個看起來很奇怪的字符串 "v16@0:8",這在 Objective-C 中叫做類型編碼(Type Encoding),相關資訊可參考官方文件。

至於方法實作,lldb 已經幫我們標註了它在檔案中的位置。

小結

在分析方法在記憶體中的位置時,我最一開始一直在找唯讀結構體 class_ro_t 中的 baseMethods 第一次被設定的位置(想知道類的方法是如何被載入的)。從 methodizeClass 一路往上找,直到 _objc_init 都沒有找到。

而且在 runtime 初始化之後、realizeClass 之前,從 class_data_bits_t 取出的 class_rw_t 一直是錯的。這讓我困惑了很久,直到在 realizeClass 中發現此時它其實是 class_ro_t,才明白錯誤的根源。

後來突然想到:類的方法、屬性與協議是在編譯期決定的(baseMethods 等成員以及類在記憶體中的位置都是編譯期決定的),這才感覺豁然開朗。

  • 類在記憶體中的位置在編譯期間就決定了,之後修改程式碼也不會改變。
  • 類的方法、屬性與協議在編譯期間被放到了「錯誤」的位置,直到 realizeClass 執行之後才移到 class_rw_t 指向的唯讀區域 class_ro_t。這樣設計的好處是:我們既能在 runtime 為 class_rw_t 添加方法,又不會影響類的唯讀結構。
  • class_ro_t 中的屬性在運行期間不能再改變。添加方法時改動的是 class_rw_t 中的 methods 列表,而不是 class_ro_t 中的 baseMethods——關於方法的添加,會在後續文章中分析。

參考資料

Classes and Metaclasses

Tagged Pointer

類型編碼

Type Encodings

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved