延遲存儲屬性

class HotpotCat {
    lazy var age: Int = 20
}

var hotpot = HotpotCat()
hotpot.age = 30

延遲屬性賦值&大小

在hotpot.age賦值前和賦值后各打個(gè)斷點(diǎn)，x/8g看下內(nèi)存地址，可以看到賦值前是0x0，沒有值。

image.png

我們知道不加lazy的情況下內(nèi)存大小為24，那么加了lazy后呢？

print(class_getInstanceSize(HotpotCat.self))
32
(lldb) 

發(fā)現(xiàn)變?yōu)?2了，多了8字節(jié)。那么分析下SIL：
這里有個(gè)小細(xì)節(jié)是加xcrun swift-demangle，會還原sil中swift的符號，方便閱讀

 swiftc -emit-sil main.swift | xcrun swift-demangle  >> ./main.sil && open main.sil

我們可以看到在main函數(shù)中，會給age賦值，調(diào)用了age的setter方法

  %14 = class_method %9 : $HotpotCat, #HotpotCat.age!setter : (HotpotCat) -> (Int) -> (), $@convention(method) (Int, @guaranteed HotpotCat) -> () // user: %15

在age的setter方法中，可以看到是個(gè)可選值。

image.png

image.png

那么延遲加載屬性本質(zhì)上是可選類型，在沒有被訪問前，默認(rèn)值是nil(0x0) 。在getter方法中枚舉值分支進(jìn)行賦值操作。
那這里就解釋了為什么這里存儲屬性加上lazy就變成32字節(jié)了。因?yàn)橐鎯γ杜e信息，實(shí)際大小為9字節(jié)，字節(jié)對齊16字節(jié)。

print(MemoryLayout<Optional<Int>>.size)
print(MemoryLayout<Optional<Int>>.stride)
9
16

swift enum默認(rèn)大小為Int8類型，編譯器會根據(jù)枚舉數(shù)量調(diào)整（Int8、Int16、Int32、Int64）。如果只有一個(gè)枚舉值系統(tǒng)也會優(yōu)化size為0，stride為1。
獲取實(shí)例的大小可以通過MemoryLayout.size(ofValue:)獲取。

延遲存儲屬性不能保證線程安全

上面我們分析了在getter方法中，會有bb1和bb2兩個(gè)分支，假設(shè)此時(shí)線程1在訪問bb2并且沒有結(jié)束，線程2也調(diào)用getter那么也可能會走bb2分支。這里就不能保證線程安全。

image.png

• 用關(guān)鍵字lazy來標(biāo)識一個(gè)延遲存儲屬性。
• 延遲存儲屬性必須有一個(gè)默認(rèn)的初始值。
• 延遲存儲屬性在第一次訪問的時(shí)候才被賦值。
• 延遲存儲屬性并不能保證線程安全。
• 延遲存儲屬性對實(shí)例對象大小有影響。

類型屬性

class HotpotCat {
    static var age: Int = 20
}

var age = HotpotCat.age

// globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_token0
sil_global private @globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_token0 : $Builtin.Word
// static HotpotCat.age
sil_global hidden @static main.HotpotCat.age : Swift.Int : $Int

生成的age變成了全局的變量sil_global

image.png

// HotpotCat.age.unsafeMutableAddressor
sil hidden [global_init] @main.HotpotCat.age.unsafeMutableAddressor : Swift.Int : $@convention(thin) () -> Builtin.RawPointer {
bb0:
  %0 = global_addr @globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_token0 : $*Builtin.Word // user: %1
  %1 = address_to_pointer %0 : $*Builtin.Word to $Builtin.RawPointer // user: %3
  // function_ref globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_func0
  %2 = function_ref @globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_func0 : $@convention(c) () -> () // user: %3
  %3 = builtin "once"(%1 : $Builtin.RawPointer, %2 : $@convention(c) () -> ()) : $()
  %4 = global_addr @static main.HotpotCat.age : Swift.Int : $*Int // user: %5
  %5 = address_to_pointer %4 : $*Int to $Builtin.RawPointer // user: %6
  return %5 : $Builtin.RawPointer                 // id: %6
} // end sil function 'main.HotpotCat.age.unsafeMutableAddressor : Swift.Int'

這個(gè)方法執(zhí)行了全局函數(shù)globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC,并且這里有個(gè)builtin "once"。

// globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_func0
sil private @globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_func0 : $@convention(c) () -> () {
bb0:
  alloc_global @static main.HotpotCat.age : Swift.Int       // id: %0
  %1 = global_addr @static main.HotpotCat.age : Swift.Int : $*Int // user: %4
  %2 = integer_literal $Builtin.Int64, 20         // user: %3
  %3 = struct $Int (%2 : $Builtin.Int64)          // user: %4
  store %3 to %1 : $*Int                          // id: %4
  %5 = tuple ()                                   // user: %6
  return %5 : $()                                 // id: %6
} // end sil function 'globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_func0'

這個(gè)函數(shù)將初始值賦值給了全局變量age。
前面說到的once就是swift_once，我們源碼里面搜索一下swift_once

image.png

• 用static聲明類型屬性
• 類型屬性屬于類本身，不論有多少個(gè)實(shí)例，類型屬性只有一份
• 全局的
• 線程安全的

單例

首先回顧下OC單類的寫法，需要dispatch_once確保線程安全并初始化一次,并且為了保證安全還要重寫allocWithZone

+ (instancetype)sharedInstance {
    static HotpotCat *instance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[HotpotCat alloc] init];
    });
    return instance;
}

swift 2.0的時(shí)候swift的單類也是翻譯的oc的寫法，現(xiàn)在已經(jīng)不用了。

swift單類只需要兩點(diǎn):

• static修飾一個(gè)常量。
• 給init添加一個(gè)訪問控制權(quán)限。

class HotpotCat {
    static let sharedInstance = HotpotCat()
    private init(){
    }
}
var hotpot = HotpotCat.sharedInstance

值類型

struct

struct HotpotCatStruct {
    var age: Int
    var name: String
    
}

class HotpotCatClass {
    var age: Int
    var name: String
}

image.png

struct HotpotCatStruct {
  @_hasStorage var age: Int { get set }
  @_hasStorage var name: String { get set }
  init(age: Int, name: String)
}

已經(jīng)有了init(age: Int, name: String)方法。
那么我們給age一個(gè)默認(rèn)值呢?

struct HotpotCatStruct {
    var age: Int = 1
}
//sil
struct HotpotCatStruct {
  @_hasStorage @_hasInitialValue var age: Int { get set }
  init(age: Int = 1)
  init()
}

可以看到既有默認(rèn)的初始化方法，也有age初始化方法。
那么我們自己實(shí)現(xiàn)了init方法呢?

struct HotpotCatStruct {
    var age: Int = 1
    
    init(age: Int) {
        self.age = age
    }
}
//sil
struct HotpotCatStruct {
  @_hasStorage @_hasInitialValue var age: Int { get set }
  init(age: Int)
}

可以看到編譯器不會幫我們生成了。

• 結(jié)構(gòu)體不需要自定義初始化方法，系統(tǒng)自動合成。
• 如果屬性有默認(rèn)值，系統(tǒng)會提供不同的默認(rèn)初始化方法。
• 如果自定義初始化方法，系統(tǒng)不會幫我們生成。

struct值類型

首先明白下基本概念

• 地址存儲的就是值
• 傳遞過程中傳遞副本

struct HotpotCat {
    var age: Int = 1
    var age2: Int = 18
}
var hotpot = HotpotCat()
//lldb
(lldb) po hotpot
? HotpotCat
  - age : 1
  - age2 : 18

po直接打印出來是值，不是地址。說明是值類型，我們再打印一下內(nèi)存地址看下存儲的內(nèi)容

(lldb) po withUnsafeMutablePointer(to: &hotpot){print($0)}
0x0000000100008028
0 elements

image.png

image.png

image.png

image.png

引用類型

那么如果是class呢？

class HotpotClass {
    var age: Int = 1
    var age2: Int = 18
}

var hotpotClass = HotpotClass()

(lldb) po hotpotClass
<HotpotClass: 0x100634610>

po直接顯示地址。

image.png

struct HotpotStruct {
    var age: Int = 1
    var age2: Int = 18
    var hotpotClass: HotpotClass = HotpotClass()
}

class HotpotClass {
    var age: Int = 1
    var age2: Int = 18
}

var hotpotStruct = HotpotStruct()
var hotpotStruct2 = hotpotStruct

image.png

可以看出依然傳遞的是地址，所以應(yīng)當(dāng)避免值類型中包含引用類型。
我們再通過SIL看一下

struct HotpotStruct {
    var age: Int = 1
    var age2: Int = 18
    var hotpotClass: HotpotClass
}

class HotpotClass {
    var name: String = "HotpotCat"
}

var hotpotClass = HotpotClass()
var hotpotStruct = HotpotStruct(hotpotClass: hotpotClass)
var hotpotStruct2 = hotpotStruct

看到這里有引用計(jì)數(shù)了,strong_retain搜索查看下發(fā)現(xiàn)一共有3處。

image.png

(lldb) po CFGetRetainCount(hotpotStruct.hotpotClass)
3

mutating

image.png

struct HotpotStruct {
    var count: Int = 0
    init() {
        self.count = 10
    }
    mutating func clear() {
        self.count = 0
    }
}

值類型本身創(chuàng)建后不允許修改，要修改需要加上mutating關(guān)鍵字
那么mutating到底干了什么呢？
先看個(gè)正常訪問變量的例子

struct HotpotStruct {
    var count: Int = 0
    func clear() {
        print(count)
    }
}

對應(yīng)的SIL中clear實(shí)現(xiàn)如下，可以看到隱藏參數(shù)self為let修飾，修改count就為修改地址也就是修改值類型self本身，所以方法中不能修改count。

image.png

image.png

那如果self我們用var接收再修改呢？修改是可以修改，只不過修改的是self的另外一份拷貝（值傳遞）。

    func clear() {
        var s = self
        s.count = 10
    }

加了mutaing進(jìn)行了什么操作呢?可以看到self是用var修飾的添加了inout關(guān)鍵字,debug_value也變成了debug_value_addr。

image.png

mutaing本質(zhì)就是給參數(shù)添加了inout關(guān)鍵字傳遞地址，只用于值類型，因?yàn)橐妙愋捅旧砭褪菍Φ刂返牟僮?/strong>
再用&操作驗(yàn)證下

func swap(_ a:inout Int, _ b:inout Int) {
    a = a ^ b
    b = a ^ b
    a = a ^ b
}

var valueA = 1
var valueB = 2
swap(&valueA, &valueB)

image.png

struct函數(shù)調(diào)用方式

struct HotpotStruct {
    func clear() {
       print("clear")
    }
}

var hotpotStruct =  HotpotStruct()
hotpotStruct.clear()

在函數(shù)調(diào)用處打個(gè)斷點(diǎn)，直接看下匯編代碼看到是直接調(diào)用的函數(shù)地址(0x100003da0)

image.png

control +step into跟進(jìn)去可以看到執(zhí)行的就是HotpotStruct.clear()。
接著我們直接分析下可執(zhí)行文件

image.png

可以確定編譯鏈接完成后，可執(zhí)行文件調(diào)用的函數(shù)地址就已經(jīng)確定了。
結(jié)構(gòu)體中的方法是靜態(tài)調(diào)度（編譯、鏈接完成后函數(shù)地址就已經(jīng)確定存放在了代碼段）
剛才可執(zhí)行程序分析的時(shí)候并沒有對應(yīng)的符號SwiftStructMutating.HotpotStruct.clear()，符號從哪里來的呢？符號表（Symbol Table 存儲符號位于字符串表的偏移）。clear在字符串表偏移0x2。靜態(tài)函數(shù)只在debug下有符號，release下會生成dsym文件。不能確定地址的當(dāng)然還會有。Debug模式下只是方便我們調(diào)試

image.png

符號表不直接存放字符串，字符串存放在字符串表（String Table,存放了所有的變量名、函數(shù)名）。

image.png

偏移兩個(gè)字節(jié)，從005F開始~005F結(jié)束，都是clear的符號。這里的字符串經(jīng)過了命名重整。
我們直接在終端nm 可執(zhí)行文件路徑 dump下符號

0000000100003da0 T _$s19SwiftStructMutating06HotpotB0V5clearyyF
0000000100003e90 T _$s19SwiftStructMutating06HotpotB0VACycfC
0000000100003f64 s _$s19SwiftStructMutating06HotpotB0VMF
0000000100003ea0 T _$s19SwiftStructMutating06HotpotB0VMa
0000000100004018 s _$s19SwiftStructMutating06HotpotB0VMf
0000000100003f40 S _$s19SwiftStructMutating06HotpotB0VMn
0000000100004020 S _$s19SwiftStructMutating06HotpotB0VN
0000000100003f24 s _$s19SwiftStructMutatingMXM

還原一下符號名稱

xcrun swift-demangle s19SwiftStructMutating06HotpotB0V5clearyyF
$s19SwiftStructMutating06HotpotB0V5clearyyF ---> SwiftStructMutating.HotpotStruct.clear() -> ()

搜索符號nm 可執(zhí)行文件路徑 | grep 地址這里地址不帶0x

nm /Users/***/Library/Developer/Xcode/DerivedData/SwiftStructMutating-bdtkkopulnojomaeuxaauwsnscxz/Build/Products/Debug/SwiftStructMutating | grep 0100003da0
0000000100003da0 T _$s19SwiftStructMutating06HotpotB0V5clearyyF

與之對應(yīng)的我們看一下print的調(diào)度方式

image.png

image.png

c/oc中方法的調(diào)度

void test(){
    
}

int main(int argc, const char * argv[]) {
    test();
    return 0;
}

可以看到c語言中符號直接就是_test,所以這也是c語言不允許函數(shù)重載的原因。OC同理-[Class selector]。

image.png

這也就解釋了Swift命名重整規(guī)則復(fù)雜的原因（確保符號的唯一）。

struct HotpotCat {
    func pot123() {
    }
}

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        var hotpot = HotpotCat()
        hotpot.pot123()
    }
}

打下斷點(diǎn)看下函數(shù)地址0x10ff42bb0

image.png

image.png

可以看到兩個(gè)地址有偏差，這里偏差的就是ALSR(隨機(jī)地址偏移)
可以通過image list查看,這里首地址0x0ff3f000就是ALSR。

[  0] A3D54669-3D78-3CA1-A48F-958F7718E05B 0x000000010ff3f000

VM Address靜態(tài)基地址，首地址就是根據(jù)靜態(tài)及地址+偏移量確定的。

image.png

pot123的地址0000000100003BB0+隨機(jī)偏移地址(0x0ff3f000)=運(yùn)行時(shí)地址(0x10ff42bb0)

image.png