深入分析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能有一定的帮助,如果有疑问大家可以留言交流。

(0)

相关推荐

  • 简单了解Go语言中函数作为值以及函数闭包的使用

    函数作为值 Go编程语言提供灵活性,以动态创建函数,并使用它们的值.在下面的例子中,我们已经与初始化函数定义的变量.此函数变量的目仅仅是为使用内置的Math.sqrt()函数.下面是一个例子: 复制代码 代码如下: package main import (    "fmt"    "math" ) func main(){    /* declare a function variable */    getSquareRoot := func(x float64

  • 举例讲解Go语言中函数的闭包使用

    和变量的声明不同,Go语言不能在函数里声明另外一个函数.所以在Go的源文件里,函数声明都是出现在最外层的. "声明"就是把一种类型的变量和一个名字联系起来. Go里有函数类型的变量,这样,虽然不能在一个函数里直接声明另一个函数,但是可以在一个函数中声明一个函数类型的变量,此时的函数称为闭包(closure). 例: 复制代码 代码如下: packagemain   import"fmt"   funcmain(){     add:=func(baseint)fun

  • JavaScript.The.Good.Parts阅读笔记(二)作用域&闭包&减缓全局空间污染

    如代码块 复制代码 代码如下: if (true) { int i = 100; } print(i); //错误,变量i没有声明 如上面例子所示,代码块外的函数是无法访问i变量的. 但在javaScript里,情况则完全不同. 复制代码 代码如下: if (true) { var i = 100; } alert(i); //弹出框并显示100 很多现代语言都推荐尽可能迟地声明变量,但在Javascript里这是一个最糟糕的建议.由于缺少块级作用域,最好在函数体的顶部声明函数中可能用到的所有变

  • 深入理解Go语言中的闭包

    闭包 在函数编程中经常用到闭包,闭包是什?它是怎么产生的及用来解决什么问题呢?先给出闭包的字面定义:闭包是由函数及其相关引用环境组合而成的实体(即:闭包=函数+引用环境).这个从字面上很难理解,特别对于一直使用命令式语言进行编程的程序员们. Go语言中的闭包 先看一个demo: func f(i int) func() int { return func() int { i++ return i } } 函数f返回了一个函数,返回的这个函数就是一个闭包.这个函数中本身是没有定义变量i的,而是引用

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

    一.前言 golang有很多新颖的特性,不知道大家的使用的时候,有没想过,这些特性是如何实现的?当然你可能会说,不了解这些特性好像也不影响自己使用golang,你说的也有道理,但是,多了解底层的实现原理,对于在使用golang时的眼界是完全不一样的,就类似于看过http的实现之后,再来使用http框架,和未看过http框架时的眼界是不一样的,当然,你如果是一名it爱好者,求知欲自然会引导你去学习. 二.这篇文章主要就分析两点:      1.golang多值返回的实现;      2.golan

  • Python中用函数作为返回值和实现闭包的教程

    函数作为返回值 高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回. 我们来实现一个可变参数的求和.通常情况下,求和的函数是这样定义的: def calc_sum(*args): ax = 0 for n in args: ax = ax + n return ax 但是,如果不需要立刻求和,而是在后面的代码中,根据需要再计算怎么办?可以不返回求和的结果,而是返回求和的函数! def lazy_sum(*args): def sum(): ax = 0 for n in args:

  • golang函数的返回值实现

    函数可以有0或多个返回值,返回值需要指定数据类型,返回值通过return关键字来指定. return可以有参数,也可以没有参数,这些返回值可以有名称,也可以没有名称.go中的函数可以有多个返回值. return关键字中指定了参数时,返回值可以不用名称.如果return省略参数,则返回值部分必须带名称 当返回值有名称时,必须使用括号包围,逗号分隔,即使只有一个返回值 但即使返回值命名了,return中也可以强制指定其它返回值的名称,也就是说return的优先级更高 命名的返回值是预先声明好的,在函

  • python递归调用中的坑:打印有值, 返回却None

    今天给大家分享小编遇到的一个坑有关python递归调用中的坑:打印有值, 返回却None问题. 问题: 前几天写一个小面试题, 忽然有个惊悚的发现, 如下: s1 = 'abcdefg' def right_shift(s, n): """ 把传入的字符串,前n个字符移动到最后面 """ if n < 1: print(s) # 此步输出结果为 "efgabcd" return s s = s[1:] + s[0] n

  • 深入分析Golang Server源码实现过程

    func (srv *Server) Serve(l net.Listener) error { ...... for { rw, err := l.Accept() if err != nil { select { case <-srv.getDoneChan(): return ErrServerClosed default: } if ne, ok := err.(net.Error); ok && ne.Temporary() { if tempDelay == 0 { te

  • jquery获取css的color值返回RGB的方法

    本文实例讲述了jquery获取css的color值返回RGB的方法.分享给大家供大家参考,具体如下: css代码如下: a, a:link, a:visited { color:#4188FB; } a:active, a:focus, a:hover { color:#FFCC00; } js代码如下: var link_col = $("a:link").css("color"); alert(link_col); // returns rgb(65, 136,

  • golang中值类型/指针类型的变量区别总结

    前言 值类型:所有像int.float.bool和string这些类型都属于值类型,使用这些类型的变量直接指向存在内存中的值,值类型的变量的值存储在栈中.当使用等号=将一个变量的值赋给另一个变量时,如 j = i ,实际上是在内存中将 i 的值进行了拷贝.可以通过 &i 获取变量 i 的内存地址 指针类型:简单地说go语言的指针类型和C/C++的指针类型用法是一样的,除了出去安全性的考虑,go语言增加了一些限制,包括如下几条: 不同类型的指针不能互相转化,例如*int, int32, 以及int

  • Golang Http请求返回结果处理

    在 Go 中 Http 请求的返回结果为 *http.Response 类型,Response.Body 类型为 io.Reader,把请求结果转化为Map需要进行一些处理. 写一个公共方法来进行Response转Map处理: package util import (     "encoding/json"     "net/http"     "io/ioutil" ) func ParseResponse(response *http.Re

  • php数组函数序列之array_search()- 按元素值返回键名

    array_search()定义和用法 array_search() 函数与 in_array() 一样,在数组中查找一个键值.如果找到了该值,匹配元素的键名会被返回.如果没找到,则返回 false. 在 PHP 4.2.0 之前,函数在失败时返回 null 而不是 false. 如果第三个参数 strict 被指定为 true,则只有在数据类型和值都一致时才返回相应元素的键名. 语法 array_search(value,array,strict)参数 描述 value 必需.规定在数组中搜索

随机推荐