深入分析golang多值返回以及闭包的实现

一、前言

golang有很多新颖的特性，不知道大家的使用的时候，有没想过，这些特性是如何实现的？当然你可能会说，不了解这些特性好像也不影响自己使用golang，你说的也有道理，但是，多了解底层的实现原理，对于在使用golang时的眼界是完全不一样的，就类似于看过http的实现之后，再来使用http框架，和未看过http框架时的眼界是不一样的，当然，你如果是一名it爱好者，求知欲自然会引导你去学习。

二、这篇文章主要就分析两点:

     1、golang多值返回的实现;

     2、golang闭包的实现;

三、golang多值返回的实现

我们在学c/c++时，很多人应该有了解过c/c++函数调用过程，参数是通过寄存器di和si(假设就两个参数)传递给被调用的函数，被调用函数的返回结果只能是通过eax寄存器返回给调用函数，因此c/c++函数只能返回一个值，那么我们是不是可以想象，golang的多值返回是否可以通过多个寄存器来实现的，正如用多个寄存器来传参一样？

这也是一种办法，但是golang并没有采用；我的理解是引入多个寄存器来存储返回值，会引起多个寄存器用途的重新约定，这无疑增加了复杂度；可以这么说，golang的abi与c/c++非常不一样；

在从汇编角度分析golang多值返回之前，需要先熟悉golang汇编代码的一些约定， golang官网 有说明，这里重点说明四个symbols，需要注意的是这里的寄存器是伪寄存器：

       1.fp 栈底寄存器，指向一个函数栈的顶部；

       2.pc 程序计数器，指向下一条执行指令;

       3.sb 指向静态数据的基指针，全局符号;

       4.sp 栈顶寄存器;

这里面最重要的就是fp和sp，fp寄存器主要用于取参数以及存返回值，golang函数调用的实现很大程度上都是依赖这两个寄存器，这里先给出结果，

+-----------+---\
| 返回值2 | \
+-----------+  \
| 返回值1 |  \
+---------+-+  
| 参数2 |  这些在调用函数中
+-----------+  
| 参数1 | 　 /
+-----------+  /
| 返回地址 | /
+-----------+--\/-----fp值
| 局部变量 | \
| ... | 被调用数栈祯
|   | /
+-----------+--/+---sp值

这个就是golang的一个函数栈，也是说函数传参是通过fp+offset来实现的，而多个返回值也是通过fp+offset存储在调用函数的栈帧中。

下面通过一个例子来分析

package main

import "fmt"

func test(i, j int) (int, int) {
a:=i+ j
b:=i- j
 return a,b
}

func main() {
a,b:= test(2,1)
 fmt.println(a, b)
}

这个例子很简单，主要是为了说明golang多值返回的过程；我们通过下面命令编译该程序

go tool compile -s test.go > test.s

然后，就可以打开test.s，来看下这个小程序的汇编代码。首先来看下test函数的汇编代码

"".test t=1size=32value=0args=0x20locals=0x0
0x000000000(test.go:5) text"".test(sb),$0-32//栈大小为32字节
0x000000000(test.go:5)nop
0x000000000(test.go:5)nop
0x000000000(test.go:5)movq"".i+8(fp),cx//取第一个参数i
0x000500005(test.go:5)movq"".j+16(fp),ax//取第二个参数j
0x000a00010(test.go:5) funcdata$0, gclocals·a8eabfc4a4514ed6b3b0c61e9680e440(sb)
0x000a00010(test.go:5) funcdata$1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(sb)
0x000a00010(test.go:6)movqcx,bx//将i放入bx
0x000d00013(test.go:6) addqax,cx//i+j放入cx
0x001000016(test.go:7) subqax,bx//i-j放入bx
 //将返回结果存入调用函数栈帧
0x001300019(test.go:8)movqcx,"".~r2+24(fp)
 //将返回结果存入调用函数栈帧
0x001800024(test.go:8)movqbx,"".~r3+32(fp)
0x001d00029(test.go:8)ret

由这个汇编代码可以看出来，在test函数内部，是通过fp+8取第一个参数，fp+16取第二个参数；然后将返回的第一个值存入fp+24,返回的第二个值存入fp+32，和我上述所说完全一致；golang函数调用过程，是通过fp+offset来实现传参和返回值，而不像c/c++都是通过寄存器实现传参和返回值；

但是，这里有个问题，我的变量都是int类型，为啥分配的都是8字节，这有待考证。

本来想通过查看main函数的栈帧来验证之前的结论，但是golang对小函数自动转为内联函数，因此你们可以自己编译出来看看，main函数内部是没有调用test函数的，而是将test函数的汇编代码直接拷贝进main函数执行了。

四、golang闭包的实现

之前有去看了下c++11的lambda函数的实现，其实实现原理就是仿函数；编译器在编译lambda函数时，会生成一个匿名的仿函数类，然后执行这个lambda函数时，会调用编译生成的匿名仿函数类重载函数调用方法，这个方法也就是lambda函数中定义的方法；其实golang闭包的实现和这个类似，我们通过例子来说明

packagemain

import"fmt"

functest(aint)func(iint)int{
returnfunc(iint)int{
 a = a + i
returna
 }
}

funcmain(){
 f := test(1)
 a := f(2)
 fmt.println(a)
 b := f(3)
 fmt.println(b)
}

这个例子程序很简单，test函数传入一个整型参数a，返回一个函数类型；这个函数类型传入一个整型参数以及返回一个整型值；main函数调用test函数，返回一个闭包函数。

来看下test函数的汇编代码:

"".test t=1size=160value=0args=0x10locals=0x20
0x000000000(test.go:5) text"".test(sb),$32-16
0x000000000(test.go:5)movq(tls),cx
0x000900009(test.go:5) cmpqsp,16(cx)
0x000d00013(test.go:5) jls142
0x000f00015(test.go:5) subq$32,sp
0x001300019(test.go:5) funcdata$0, gclocals·8edb5632446ada37b0a930d010725cc5(sb)
0x001300019(test.go:5) funcdata$1, gclocals·008e235a1392cc90d1ed9ad2f7e76d87(sb)
0x001300019(test.go:5) leaq type.int(sb),bx
0x001a00026(test.go:5)movqbx, (sp)
0x001e00030(test.go:5) pcdata$0,$0
 //生成一个int型对象，即a
0x001e00030(test.go:5)callruntime.newobject(sb)
 //8(sp)即生成的a的地址，放入ax
0x002300035(test.go:5)movq8(sp),ax
 //将a的地址存入sp+24的位置
0x002800040(test.go:5)movqax,"".&a+24(sp)
 //取出main函数传入的第一个参数，即a
0x002d00045(test.go:5)movq"".a+40(fp),bp
 //将a放入(ax)指向的内存，即上述新生成的int型对象
0x003200050(test.go:5)movqbp, (ax)
0x003500053(test.go:6) leaq type.struct { f uintptr; a *int }(sb), bx
0x003c00060(test.go:6)movqbx, (sp)
0x004000064(test.go:6) pcdata$0,$1
0x004000064(test.go:6)callruntime.newobject(sb)
 //8(sp)这就是上述生成的struct对象地址
0x004500069(test.go:6)movq8(sp),ax
0x004a00074(test.go:6)nop
 //test内部匿名函数地址存入bp
0x004a00074(test.go:6) leaq"".test.func1(sb),bp
 //将匿名函数地址放入(ax)指向的地址，即给上述
 //f uintptr赋值
0x005100081(test.go:6)movqbp, (ax)
0x005400084(test.go:6)movqax,"".autotmp_0001+16(sp)
0x005900089(test.go:6)nop
 //将上述生成的整型对象a的地址存入bp
0x005900089(test.go:6)movq"".&a+24(sp),bp
0x005e00094(test.go:6) cmpb runtime.writebarrier(sb),$0
0x006500101(test.go:6)jne$0,117
 //将a地址存入ax指向内存+8，
 //即为上述结构体a *int赋值
0x006700103(test.go:6)movqbp,8(ax)
 //将上述结构体的地址存入main函数栈帧中；
0x006b00107(test.go:9)movqax,"".~r1+48(fp)
0x007000112(test.go:9) addq$32,sp
0x007400116(test.go:9)ret

之前有看到一句话，很形象地描述了闭包

类是有行为的数据，为闭包是有数据的行为；

也就是说闭包是有上下文的，我们以测试例子为例，通过test函数生成的闭包函数，都有各自的a，这个a就是闭包的上下文数据，而且这个a一直伴随着他的闭包函数，每调用一次，a都会发生变化；

我们分析了上述汇编代码，来看下闭包实现原理；在这个测试例子中，由于a是闭包的上下文数据，因此a必须在堆上分配，如果在栈上分配，函数结束，a也被回收了；然后会定义出一个匿名结构体:

type.struct{
 f uintptr//这个就是闭包调用的函数指针
 a *int//这就是闭包的上下文数据
}

接着生成一个该对象，并将之前在堆上分配的整型对象a的地址赋值给结构体中的a指针，接下来将闭包调用的func函数地址赋值给结构体中f指针；这样，每生成一个闭包函数，其实就是生成一个上述结构体对象，每个闭包对象也就有自己的数据a和调用函数f；最后将这个结构体的地址返回给main函数；

来看下main函数获取闭包的过程；

"".main t=1size=528value=0args=0x0locals=0x88
0x000000000(test.go:12) text"".main(sb),$136-0
0x000000000(test.go:12)movq(tls),cx
0x000900009(test.go:12) leaq -8(sp),ax
0x000e00014(test.go:12) cmpqax,16(cx)
0x001200018(test.go:12) jls506
0x001800024(test.go:12) subq$136,sp
0x001f00031(test.go:12) funcdata$0, gclocals·f5be5308b59e045b7c5b33ee8908cfb7(sb)
0x001f00031(test.go:12) funcdata$1, gclocals·9d868b227cedd8dd4b1bec8682560fff(sb)
 //将参数1(f:=test(1))放入main函数栈顶
0x001f00031(test.go:13)movq$1, (sp)
0x002700039(test.go:13) pcdata$0,$0
 //调用main函数生成闭包对象
0x002700039(test.go:13)call"".test(sb)
 //将闭包对象的地址放入dx
0x002c00044(test.go:13)movq8(sp),dx
 //将参数2(a:=f(2))放入栈顶
0x003100049(test.go:14)movq$2, (sp)
0x003900057(test.go:14)movqdx,"".f+56(sp)
 //将闭包对象的函数指针赋值给bx
0x003e00062(test.go:14)movq(dx),bx
0x004100065(test.go:14) pcdata$0,$1
 //这里调用闭包函数，并且将闭包对象的地址也传进
 //闭包函数，为了修改a嘛
0x004100065(test.go:14)calldx,bx
0x004300067(test.go:14)movq8(sp),bx

很明显，main函数调用test函数获取的是闭包对象的地址，通过这个闭包对象地址找到闭包函数，然后执行这个闭包函数，并且把闭包对象的地址传进函数，这点和c++传this指针原理一样，为了修改成员变量a；

最后看下test内部的匿名函数(闭包函数实现):

"".test.func1t=1size=32value=0args=0x10 locals=0x0
0x000000000(test.go:6) text"".test.func1(sb), $0-16
0x000000000(test.go:6) nop
0x000000000(test.go:6) nop
0x000000000(test.go:6) funcdata $0, gclocals·23e8278e2b69a3a75fa59b23c49ed6ad(sb)
0x000000000(test.go:6) funcdata $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(sb)
//dx是闭包对象的地址，+8即a的地址
0x000000000(test.go:6) movq8(dx), ax
//ax为a的地址，(ax)即为a的值
0x000400004(test.go:7) movq (ax), bp
//将参数i存入r8
0x000700007(test.go:7) movq"".i+8(fp), r8
//a+i的值存入bp
0x000c00012(test.go:7) addq r8, bp
//将a+i存入a的地址
0x000f00015(test.go:7) movq bp, (ax)
//将a地址最新数据存入bp
0x001200018(test.go:8) movq (ax), bp
//将a最新值作为返回值放入main函数栈中
0x001500021(test.go:8) movq bp,"".~r1+16(fp)
0x001a00026(test.go:8) ret

闭包函数的调用过程:

      1、通过闭包对象地址获取闭包上下文数据a的地址;

      2、接着通过a的地址获取到a的值，并与参数i相加；

      3、将a+i作为最新值存入a的地址；

      4、将a最新值返回给main函数；

五、总结

这篇文章简单地从汇编角度分析了golang多值返回和闭包的实现；

      多值返回主要是通过fp寄存器+offset获取参数以及存入返回值实现；

      闭包主要是通过在编译时生成包含闭包函数和闭包上下文数据的结构体实现；

以上就是这篇文章的全部内容，希望对大家学习或只用golang能有一定的帮助，如果有疑问大家可以留言交流。