Swift汇编分析闭包-内存布局

1、闭包表达式与闭包

闭包表达式也就是定义一个函数。
一般我们可以通过func定义一个函数，也可以通过闭包表达式定义一个函数。
闭包与闭包表达式的区别是闭包会捕获外部变量/常量，但有时候会将闭包表达式也称为闭包，但实际上只是简称。

func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
}

进一步写成闭包表达式：
var sum = {
    (v1: Int, v2: Int) -> Int in
    v1 + v2
}

可以看到上面的函数与闭包表达式的作用是一样的。
而闭包表达式也是可以作为函数的参数

func test(v1: Int, v2: Int, fn: (Int, Int) -> Int) -> Int {
    return fn(v1, v2)
}

test(v1: 1, v2: 2, fn: sum)

也可以这样写，也就是直接传入闭包表达式：
test(v1: 1, v2: 2, fn: {
    (v1: Int, v2: Int) -> Int in
    v1 + v2
})

可以更简化一步
test(v1: 1, v2: 2, fn: {
    v1, v2 in
    v1 + v2
})

再来简化一下：
test(v1: 1, v2: 2, fn: {
    $0 + $1
})

甚至于直接传入一个+号
test(v1: 1, v2: 2, fn: +)

尾随闭包
如果将闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性。
因此在我们实际写代码的时候编译器有时候会提示将最后的闭包表达式修改为尾随闭包的形式。
上面所述的例子既可以写成尾随闭包的形式

test(v1: 1, v2: 3) {
    v1, v2 in
    v1 + v2
}

test(v1: 1, v2: 3) {
    $0 + $1
}

如果闭包表达式是函数的唯一实参，而且使用了尾随闭包的语法，那么不需要在函数后写圆括号。

2、闭包

一个函数和它捕获的变量常量环境组合起来称为闭包
一般情况下这个函数是定义在函数内部的，也就是这个内部的函数与这个包裹其的函数内部定义的变量一起称之为闭包。
如下面的例子plus以及其捕获的变量a一起才是闭包。
下面我们先看一下代码，可以看到这里内部的函数捕获变量a：


typealias Fn = (Int) -> (Int)

var a = 10
func exec() -> Fn {
    func plus (_ i: Int) -> Int {
        a += i
        return a
    }
    return plus
}


let fn = exec()
print(fn(1))
print(fn(2))

此时可以想一下打印的结果是多少

11
13

因为这里的a是一个全局变量，因此我们调用了两次访问的都是同一个变量地址，因此这里的结果显而易见了。
那如果a是一个局部变量呢？

func exec() -> Fn {
    var a = 10
    func plus (_ i: Int) -> Int {
        a += i
        return a
    }
    return plus
}

此时我们再去调用的结果是什么？
实际上这里的结果与上面一致，按道理我们在执行完exec函数获得返回值fn之后其内部的变量a应该是会被释放掉的。
此时我们添加断点到 return plus然后查看汇编代码。

image.png

此时我们可以看到在第9行处调用了一个函数，后边有描述为swift_allocObject，这说明了为其在堆空间分配了内存。而实际上我们的变量都是局部变量，按道理应该是在栈上使用，使用完后就会被销毁释放掉。也就是我们在返回plus时，捕获了外部变量，但是这个变量是局部变量，因为为了延长变量a的生命周期因为将其放入了堆空间。
那么之前打印结果的问题也就解释了，我们调用一次exec，此时就会分配一次堆空间，堆空间内存放着的就是变量的值。因此我们每次调用fn的时候使用了同一个变量。
那么我们再调用exec获取一个函数

let fn = exec()
print(fn(1))
print(fn(2))

let fn1 = exec()
print(fn1(3))
print(fn1(4))

此时的打印结果也就知道，这里是分开的两个堆空间。
那么我们来看一下当前的堆空间中是否是存放着局部变量。
此时也在return a处添加上断点，执行然后进入到汇编代码，
因为我们在分配堆空间处也有断点

image.png

因此我们着这个断点处查看一下当前堆空间的地址。之前我们也提到过call函数后的返回值一般都是在rax中，所以这里我们只需要读取一下rax中的值即可。

(lldb) register read rax
     rax = 0x000000010055f0e0

实际上这个地址存放的也就是变量a的值，但是这块地址是刚刚分配的，也就是这里面还没有数据或者有的也是垃圾数据。
此时我们进入到上面提到过的return a处的断点，根据代码我们是return了一个变量，那么也就是这个变量实际上已经是有值的，此时我们查看上面分配的堆空间里边的数据

(lldb) x/5xg 0x000000010055f0e0
0x10055f0e0: 0x0000000100008158 0x0000000200000002
0x10055f0f0: 0x000000000000000b 0x0000000000000000
0x10055f100: 0x0000000000000000

前16个字节不用管，直接从第17个字节开始看，可以看到我们第一次执行fn(1)的结果存放在里边。所以这里也就印证了前面所说的分配的堆空间存放的正是变量a的值。
同时我们也可以返回再看一下exec()的汇编截图中的第13行处movq $0xa, 0x10(%rax)，这是是有个move执行操作，上述我们知道rax中存放着变量的堆空间地址，这里是直接将值赋值到了这个地址的第3个8个字节，也就是跳过了前面的16个字节。也就是直接将这个变量从栈空间拷贝到了堆空间。

那么这里分配了多大的堆空间呢。我们再回到exec汇编的截图处，此时在swift_allocObjec之前我们可以看到对应有3个参数传递rdi、rsi、rdx，但是我们再看一其前面传递的数据大概可以知道 rsi里边才是存放的需要的空间大小为24，但是因为内存对齐的缘故，所以应该是分配了32个字节。

rax、rdx常作为函数返回值使用
rdi、rsi、rdx、rcx、r8、r9等寄存器常用于存放函数参数
rsp、rbp用于栈操作

我们可以通过实例化类的方式来确认一下上面所说的。
定义一个类，并实例化一个对象

image.png

进入汇编，在SwiftStudy.Person.__allocating_init()处打上断点

image.png

进入到allocating_init

image.png

可以看到这里也是即将分配堆空间swift_allocObject，此时我们看第6行，通过rsi传参时，这里传递了32个字节，前16个字节固定，后16为内部变量。

其实我们可以将闭包看做是一个类对象，上面定义的exec可以看做是一个类对象，其内部函数捕获的变量a就是其成员变量，而函数就是其内部的函数。并且类对象就是分配在堆空间上的。甚至其在堆空间上的数据分配也是和类对象基本一致的，类的前16个字节存放类信息以及引用计数，同样闭包的堆空间的前16个字节也是存放着一些信息，真正的数据是从第17个字节开始。

问题：前面我们分析的是局部变量，那如果是全局变量此时还会在堆是哪个分配对应的空间吗？