Go 函數調用 ━ 棧和寄存器視角
函數的調用過程主要要點在於藉助寄存器和內存幀棧傳遞參數和返回值。雖然同爲編譯型語言，Go 相較 C 對寄存器和棧的使用有一些差異，同時，Go 語言自帶協程並引入 defer 等語句，在調用過程上顯得更加複雜。 理解Go函數調用在CPU指令層的過程有助於編寫高效的代碼，在性能優化、Bug排查的時候，能更迅速的肯定要點。本文以簡短的示例代碼和對應的彙編代碼演示了Go的調用過程，展現了不一樣數據類型的參數的實際傳遞過程，同時分析了匿名函數、閉包做爲參數或者返回值傳遞時，在內存上的實際數據結構。對於協程對棧的使用和實現細節，本文不展開。
閱讀本文須要掌握計算機體系結構基礎知識(至少了解程序內存佈局、棧、寄存器)、Go 基礎語法。參考文檔提供了這些主題更詳細的知識。
如下：html
術語
- 棧：每一個進程/線程/goroutine有本身的調用棧，參數和返回值傳遞、函數的局部變量存放一般經過棧進行。和數據結構中的棧同樣，內存棧也是後進先出，地址是從高地址向低地址生長。
- 棧幀：（stack frame）又常被稱爲幀（frame）。一個棧是由不少幀構成的，它描述了函數之間的調用關係。每一幀就對應了一次還沒有返回的函數調用，幀自己也是以棧的形式存放數據的。
- caller 調用者
- callee 被調用者，如在 函數 A 裏 調用 函數 B，A 是 caller，B 是 callee
寄存器(X86)git
-
ESP：棧指針寄存器(extended stack pointer)，存放着一個指針，該指針指向棧最上面一個棧幀(即當前執行的函數的棧)的棧頂。注意：github
- ESP指向的是已經存儲了內容的內存地址，而不是一個空閒的地址。例如從 0xC0000000 到 0xC00000FF是已經使用的棧空間，ESP指向0xC00000FF
- EBP：基址指針寄存器(extended base pointer)，也叫幀指針，存放着一個指針，該指針指向棧最上面一個棧幀的底部。
- EIP：寄存器存放下一個CPU指令存放的內存地址，當CPU執行完當前的指令後，從EIP寄存器中讀取下一條指令的內存地址，而後繼續執行。
注意：16位寄存器沒有前綴(SP、BP、IP)，32位前綴是E(ESP、EBP、EIP)，64位前綴是R(RSP、RBP、RIP)golang
彙編指令macos
- PUSH：進棧指令，PUSH指令執行時會先將ESP減4，接着將內容寫入ESP指向的棧內存。
-
POP ：出棧指令，POP指令執行時先將ESP指向的棧內存的一個字長的內容讀出，接着將ESP加4。注意：編程
- 用PUSH指令和POP指令時只能按字訪問棧，不能按字節訪問棧。
- CALL：調用函數指令，將返回地址（call指令的下一條指令）壓棧，接着跳轉到函數入口。
- RET：返回指令，將棧頂返回地址彈出到EIP，接着根據EIP繼續執行。
- LEAVE：等價於 mov esp,ebp; pop ebp;
- MOVL：在內存與寄存器、寄存器與寄存器之間轉移值
- LEAL：用來將一個內存地址直接賦給目的操做數
注意：8位指令後綴是B、16位是S、32位是L、64位是Qc#
調用慣例
調用慣例(calling convention)是指程序裏調用函數時關於如何傳參如何分配和清理棧等的方案。一個調用慣例的內容包括：segmentfault
- 參數是經過寄存器傳遞仍是棧傳遞或者兩者混合
- 經過棧傳遞時參數是從左至右壓棧仍是從右至左壓棧
- 函數結果是經過寄存器傳遞仍是經過棧傳遞
- 調用者(caller)仍是被調用者(callee)清理棧空間
- 被調用者應該爲調用者保存哪些寄存器
例如，C 的調用慣例(cdecl, C declaration)是：數組
- 函數實參在線程棧上按照從右至左的順序依次壓棧。
- 函數結果保存在寄存器EAX/AX/AL中
- 浮點型結果存放在寄存器ST0中
- 編譯後的函數名前綴以一個下劃線字符
- 調用者負責從線程棧中彈出實參（即清棧）
- 8比特或者16比特長的整形實參提高爲32比特長。
- 受到函數調用影響的寄存器（volatile registers）：EAX, ECX, EDX, ST0 - ST7, ES, GS
- 不受函數調用影響的寄存器： EBX, EBP, ESP, EDI, ESI, CS, DS
- RET指令從函數被調用者返回到調用者（實質上是讀取寄存器EBP所指的線程棧之處保存的函數返回地址並加載到IP寄存器）
cdecl 將函數返回值保存在寄存器中，因此 C 語言不支持多個返回值。另外，cdecl 是調用者負責清棧，於是能夠實現可變參數的函數。若是是被調用者負責清理的話，沒法實現可變參數的函數，可是編譯代碼的效率會高一點，由於清理棧的代碼不用在每次調用的時候(編譯器計算)生成一遍。(x86的ret指令容許一個可選的16位參數說明棧字節數，用來在返回給調用者以前解堆棧。代碼相似ret 12這樣，若是遇到這樣的彙編代碼，說明是被調用者清棧。)安全
注意，雖然 C 語言 裏都是藉助寄存器傳遞返回值，可是返回值大小不一樣時有不一樣的處理情形。若小於4字節，返回值存入eax寄存器，由函數調用方讀取eax。若返回值5到8字節，採用eax和edx聯合返回。若大於8個字節，首先在棧上額外開闢一部分空間temp，將temp對象的地址作爲隱藏參數入棧。函數返回時將數據拷貝給temp對象，並將temp對象的地址用寄存器eax傳出。調用方從eax指向的temp對象拷貝內容。
能夠看到，設計一個編程語言的特性時，須要爲其選擇合適調用慣例才能在底層實現這些特性。(調用慣例是編程語言的編譯器選擇的，一樣的語言不一樣的編譯器可能會選擇實現不一樣的調用慣例）
一次典型的 C 函數調用過程
在caller裏：
- 將實參從右至左壓棧(X86-64下是：將實參寫入寄存器，若是實參超過 6 個，超出的從右至左壓棧)
- 執行 call 指令(會將返回地址壓棧，並跳轉到 callee 入口)
進入callee裏：
- push ebp; mov ebp,esp; 此時EBP和ESP已經分別表示callee的棧底和棧頂了。以後 EBP 的值會保持固定。此後局部變量和臨時存儲均可以經過基準指針EBP加偏移量找到了。
- sub xxx, esp; 棧頂下移，爲callee分配空間，用於存放局部變量等。分配的內存單元能夠經過 EBP - K 或者 ESP + K 獲得地址訪問。
- 將某些寄存器的值壓棧(可能)
- callee執行
- 將某些寄存器值彈出棧(可能)
- mov esp,ebp; pop ebp; (這兩條指令也能夠用 leave 指令替代)此時 EBP 和 ESP 回到了進入callee以前的狀態，即分別表示caller的棧底和棧頂狀態。
- 執行 ret 指令
回到了caller裏的代碼
int add(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8) {
return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8;
}
int main() {
int i = add(1, 2, 3 , 4, 5, 6, 7, 8);
}
x86版彙編
.section __TEXT,__text,regular,pure_instructions
.build_version macos, 10, 14 sdk_version 10, 14
.globl _add ## -- Begin function add
.p2align 4, 0x90
_add: ## @add
.cfi_startproc
## %bb.0:
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset %ebp, -8
movl %esp, %ebp
.cfi_def_cfa_register %ebp
pushl %ebx
pushl %edi
pushl %esi
subl $32, %esp
.cfi_offset %esi, -20
.cfi_offset %edi, -16
.cfi_offset %ebx, -12
movl 36(%ebp), %eax
movl 32(%ebp), %ecx
movl 28(%ebp), %edx
movl 24(%ebp), %esi
movl 20(%ebp), %edi
movl 16(%ebp), %ebx
movl %eax, -16(%ebp) ## 4-byte Spill
movl 12(%ebp), %eax
movl %eax, -20(%ebp) ## 4-byte Spill
movl 8(%ebp), %eax
movl %eax, -24(%ebp) ## 4-byte Spill
movl 8(%ebp), %eax
addl 12(%ebp), %eax
addl 16(%ebp), %eax
addl 20(%ebp), %eax
addl 24(%ebp), %eax
addl 28(%ebp), %eax
addl 32(%ebp), %eax
addl 36(%ebp), %eax
movl %ebx, -28(%ebp) ## 4-byte Spill
movl %ecx, -32(%ebp) ## 4-byte Spill
movl %edx, -36(%ebp) ## 4-byte Spill
movl %esi, -40(%ebp) ## 4-byte Spill
movl %edi, -44(%ebp) ## 4-byte Spill
addl $32, %esp
popl %esi
popl %edi
popl %ebx
popl %ebp
retl
.cfi_endproc
## -- End function
.globl _main ## -- Begin function main
.p2align 4, 0x90
_main: ## @main
.cfi_startproc
## %bb.0:
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset %ebp, -8
movl %esp, %ebp
.cfi_def_cfa_register %ebp
subl $40, %esp
movl $1, (%esp)
movl $2, 4(%esp)
movl $3, 8(%esp)
movl $4, 12(%esp)
movl $5, 16(%esp)
movl $6, 20(%esp)
movl $7, 24(%esp)
movl $8, 28(%esp)
calll _add
xorl %ecx, %ecx
movl %eax, -4(%ebp)
movl %ecx, %eax
addl $40, %esp
popl %ebp
retl
.cfi_endproc
## -- End function
.subsections_via_symbols
x86-64版彙編
.section __TEXT,__text,regular,pure_instructions
.build_version macos, 10, 14 sdk_version 10, 14
.globl _add ## -- Begin function add
.p2align 4, 0x90
_add: ## @add
.cfi_startproc
## %bb.0:
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq %rsp, %rbp
.cfi_def_cfa_register %rbp
movl 24(%rbp), %eax
movl 16(%rbp), %r10d
movl %edi, -4(%rbp)
movl %esi, -8(%rbp)
movl %edx, -12(%rbp)
movl %ecx, -16(%rbp)
movl %r8d, -20(%rbp)
movl %r9d, -24(%rbp)
movl -4(%rbp), %ecx
addl -8(%rbp), %ecx
addl -12(%rbp), %ecx
addl -16(%rbp), %ecx
addl -20(%rbp), %ecx
addl -24(%rbp), %ecx
addl 16(%rbp), %ecx
addl 24(%rbp), %ecx
movl %eax, -28(%rbp) ## 4-byte Spill
movl %ecx, %eax
movl %r10d, -32(%rbp) ## 4-byte Spill
popq %rbp
retq
.cfi_endproc
## -- End function
.globl _main ## -- Begin function main
.p2align 4, 0x90
_main: ## @main
.cfi_startproc
## %bb.0:
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset %rbp, -16
movq %rsp, %rbp
.cfi_def_cfa_register %rbp
subq $32, %rsp
movl $1, %edi
movl $2, %esi
movl $3, %edx
movl $4, %ecx
movl $5, %r8d
movl $6, %r9d
movl $7, (%rsp)
movl $8, 8(%rsp)
callq _add
xorl %ecx, %ecx
movl %eax, -4(%rbp)
movl %ecx, %eax
addq $32, %rsp
popq %rbp
retq
.cfi_endproc
## -- End function
.subsections_via_symbols
能夠看到 Clang 編譯出的X86目標代碼並不使用寄存器傳遞參數，而X86-64目標代碼裏，使用寄存器傳遞前六個參數。
一次典型的Go函數調用過程
Go 選擇的調用慣例是：
- 參數徹底經過棧傳遞，從參數列表的右至左壓棧
- 返回值經過棧傳遞，返回值的棧空間在參數以前，即返回值在更接近caller棧底的位置
- caller負責清理棧
package main
func main() {
add(1,2)
}
//go:noinline
func add(a , b int) int {
c := 3
d := a + b + c
return d
}
TEXT main.main(SB) /Users/user/go/src/test/main.go main.go:4 0x104ea20 65488b0c2530000000 MOVQ GS:0x30, CX main.go:4 0x104ea29 483b6110 CMPQ 0x10(CX), SP main.go:4 0x104ea2d 762e JBE 0x104ea5d main.go:4 0x104ea2f 4883ec20 SUBQ $0x20, SP ; 增長 32 bytes 的棧空間(四個 qword，8個bytes 爲一個 qword) main.go:4 0x104ea33 48896c2418 MOVQ BP, 0x18(SP) ; 將 BP 的值寫入到剛分配的棧空間的第一個qword main.go:4 0x104ea38 488d6c2418 LEAQ 0x18(SP), BP ; 將剛分配的棧空間的第一個字的地址賦值給BP(即BP此時指向了剛纔存放舊BP值的地址) main.go:5 0x104ea3d 48c7042401000000 MOVQ $0x1, 0(SP); 將給add函數的第一個實參值1 寫入到剛分配棧空間的最後一個qword main.go:5 0x104ea45 48c744240802000000 MOVQ $0x2, 0x8(SP); 將給add函數的第二個實參值2 寫入到剛分配棧空間的第三個qword。第二個 qword 沒有用到，其實是給callee用來存放返回值的。 main.go:5 0x104ea4e e81d000000 CALL main.add(SB); 調用 add 函數 main.go:6 0x104ea53 488b6c2418 MOVQ 0x18(SP), BP; 將從棧裏第四個qword將舊的BP值取回賦值到BP main.go:6 0x104ea58 4883c420 ADDQ $0x20, SP; 增長SP的值，棧收縮，收回 32 bytes的棧空間 main.go:6 0x104ea5c c3 RET TEXT main.add(SB) /Users/user/go/src/test/main.go main.go:11 0x104ea70 4883ec18 SUBQ $0x18, SP; 分配 24 bytes 的棧空間（3 個 qword）。 main.go:11 0x104ea74 48896c2410 MOVQ BP, 0x10(SP); 將 BP值 寫入第一個qword main.go:11 0x104ea79 488d6c2410 LEAQ 0x10(SP), BP; 將剛分配的24 bytes 棧空間的第一個字的地址賦值給BP(即BP此時指向了剛纔存放舊BP值的地址) main.go:11 0x104ea7e 48c744243000000000 MOVQ $0x0, 0x30(SP);將存放返回值的地址清零，0x30(SP) 對應的內存位置是上一段 main.main 裏分配的棧空間的第二個qword。 main.go:12 0x104ea87 48c744240803000000 MOVQ $0x3, 0x8(SP); 對應 c := 3 這行代碼。局部變量 c 對應的是棧上內存。3 被寫入到剛分配的 24 bytes 空間的第二個qword。 main.go:13 0x104ea90 488b442420 MOVQ 0x20(SP), AX; 將add的實參 1 寫入到AX 寄存器。 main.go:13 0x104ea95 4803442428 ADDQ 0x28(SP), AX; 將add的實參 2 增長到 AX 寄存器。 main.go:13 0x104ea9a 4883c003 ADDQ $0x3, AX; 將局部變量值 3 增長到 AX 寄存器 main.go:13 0x104ea9e 48890424 MOVQ AX, 0(SP); 將 AX 的值(計算結果) 寫入到剛分配的 24 bytes 空間的第三個qword。(對應代碼 d := a + b + c) main.go:14 0x104eaa2 4889442430 MOVQ AX, 0x30(SP); 將 AX 的值寫入到main裏爲返回值留的棧空間(main裏分配的32 bytes 中的第二個 qword) main.go:14 0x104eaa7 488b6c2410 MOVQ 0x10(SP), BP; 恢復BP的值爲函數入口處保存的舊BP的值。 main.go:14 0x104eaac 4883c418 ADDQ $0x18, SP; 將 SP 增長三個字，收回add入口處分配的棧空間。 main.go:14 0x104eab0 c3 RET
函數調用過程當中，棧的變化狀況如圖：
初始狀態：
call add執行前棧狀態：
進入add裏以後棧狀態：
add裏ret執行前棧狀態：
main裏ret執行前棧狀態：
能夠看到 Go 的調用過程和 C 相似，區別在於 Go 的參數徹底經過棧傳遞，Go 的返回值也是經過棧傳遞。對於每種數據類型在做爲參數傳遞時的表現，能夠測試一下：
不一樣數據類型做爲參數時的傳遞方式
Go 基礎數據類型的參數傳遞
package main
import (
"fmt"
"runtime/debug"
)
func main() {
str := "hello"
int8 := int8(8)
int64 := int64(64)
boolValue := true
ExampleStr(str)
ExampleBool(boolValue)
ExampleInt8(int8)
ExampleInt64(int64)
ExampleMultiParams(false, 9, 8, 7)
}
func ExampleStr(str string){
fmt.Println(string(debug.Stack()))
}
func ExampleBool(boolValue bool){
boolValue = false
fmt.Println(string(debug.Stack()))
}
func ExampleInt64(v int64){
fmt.Println(string(debug.Stack()))
}
func ExampleInt8(v int8){
fmt.Println(string(debug.Stack()))
}
func ExampleMultiParams(b bool, x, y, z int8){
bl := b
xl := x
yl := y
zl := z
fmt.Println(bl, xl, yl, zl)
fmt.Println(string(debug.Stack()))
}
goroutine 1 [running]:
runtime/debug.Stack(0xc000084f38, 0x1057aad, 0x10aeb20)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleStr(0x10c6c34, 0x5)
/Users/user/go/src/test/main.go:25 +0x26
main.main()
/Users/user/go/src/test/main.go:16 +0x36
goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f58)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleBool(0x10c6c01)
/Users/user/go/src/test/main.go:32 +0x26
main.main()
/Users/user/go/src/test/main.go:17 +0x3f
goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f58)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleInt8(0x10c6c08)
/Users/user/go/src/test/main.go:42 +0x26
main.main()
/Users/user/go/src/test/main.go:18 +0x48
goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f58)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleInt64(0x40)
/Users/user/go/src/test/main.go:38 +0x26
main.main()
/Users/user/go/src/test/main.go:19 +0x55
false 9 8 7
goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f28)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleMultiParams(0x7080900)
/Users/user/go/src/test/main.go:52 +0xf6
main.main()
/Users/user/go/src/test/main.go:20 +0x61
能夠看到：
- string傳遞時，分爲pointer和length兩個參數傳遞。
- int64傳遞時，複製了值進行傳遞。
- 看debug.Stack()打印出的調用棧，int8和bool傳遞時，傳遞的是一個內存地址，這彷佛容易引發誤解，難道傳遞的是caller裏變量的內存地址？那不是會致使callee修改也致使caller裏值也發生改變？固然不是這樣！int和bool固然都是值傳遞。當caller傳遞給callee的時候，int和bool都會被在caller的棧裏複製一份給callee使用。(在callee直接經過引用參數名修改參數值，這個參數的內存位置其實是在caller的棧上)。
- ExampleMultiParams函數雖然有四個參數，可是調用棧打印出來只傳遞了一個值 0x7080900，這是爲何？原來這四個參數都是一個byte，合起來是一個雙字。查看彙編代碼能夠發現編譯器作了優化，直接組合成一個值，並在caller裏用指令
MOVL $0x7080900, 0(SP)寫入棧上。固然，在caller裏取值的時候，仍是藉助MOVB去一個字節一個字節取值的。固然，若是是這四個參數是main裏的四個局部變量，調用ExampleMultiParams的時候經過傳遞變量名的形式調用(ExampleMultiParams(b, x, y, z)而不是 ExampleMultiParams(true, 9, 8, 7)的形式)，體如今彙編代碼裏又是另外一種形式。
Go 組合數據類型的參數傳遞
package main
import (
"fmt"
"runtime/debug"
)
type MyStruct struct {
a int
b string
}
func main() {
slice := make([]string, 2, 4)
array := [...]int{9,8,7,6,7,8,9}
myMap := make(map[string]int)
myStruct := MyStruct{8, "test"}
myStructPtr := &myStruct
myChan := make(chan int, 4)
ExampleSlice(slice)
ExampleArray(array)
ExampleMap(myMap)
ExampleStruct(myStruct)
ExamplePtr(myStructPtr)
ExampleChan(myChan)
}
func ExampleSlice(slice []string){
fmt.Println(string(debug.Stack()))
}
func ExampleArray(array [7]int){
fmt.Println(string(debug.Stack()))
}
func ExampleMap(myMap map[string]int){
fmt.Println(string(debug.Stack()))
}
func ExampleStruct(myStruct MyStruct){
fmt.Println(string(debug.Stack()))
}
func ExamplePtr(ptr *MyStruct){
fmt.Println(string(debug.Stack()))
}
func ExampleChan(myChan chan int){
fmt.Println(string(debug.Stack()))
}
調用棧
goroutine 1 [running]:
runtime/debug.Stack(0x130a568, 0xc00007eda8, 0x1004218)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleSlice(0xc00007ee78, 0x2, 0x4)
/Users/user/go/src/test/main.go:62 +0x26
main.main()
/Users/user/go/src/test/main.go:46 +0x159
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleArray(0x9, 0x8, 0x7, 0x6, 0x7, 0x8, 0x9)
/Users/user/go/src/test/main.go:66 +0x26
main.main()
/Users/user/go/src/test/main.go:48 +0x185
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleMap(0xc00007ee48)
/Users/user/go/src/test/main.go:74 +0x26
main.main()
/Users/user/go/src/test/main.go:52 +0x1af
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleStruct(0x8, 0x10c6f88, 0x4)
/Users/user/go/src/test/main.go:78 +0x26
main.main()
/Users/user/go/src/test/main.go:54 +0x1d7
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExamplePtr(0xc00007ee30)
/Users/user/go/src/test/main.go:82 +0x26
main.main()
/Users/user/go/src/test/main.go:56 +0x1e5
goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleChan(0xc000092000)
/Users/user/go/src/test/main.go:86 +0x26
main.main()
/Users/user/go/src/test/main.go:58 +0x1f3
能夠看到：
- 對於數組、結構體、指針，是複製一份拷貝傳遞給callee。
- 數組做爲參數時，編譯後參數的數量是數組元素的數量。
- 結構體做爲參數時，編譯後參數的數量須要再次分析結構體裏元素的類型。如上述代碼裏結構體由一個int和一個string組成，傳遞參數時是int值、string的地址、string的長度三個參數。
- slice傳遞時，會將slice底層的pointer、len、cap做爲三個參數分開傳遞。(即編譯後，參數數量由源代碼裏的一個參數變爲了三個參數)。因此slice其實也是值傳遞。
- map、chan傳遞時，是將map、chan的地址指針做爲參數傳遞。
方法：pointer receiver 與 value receiver
在 Java 中，當咱們調用一個對象的方法的時候，固然是能夠修改對象的成員變量的。可是在 Go 中，結果取決於定義方法時方法的接收者是值仍是指針(value receiver 和 pointer receiver)。
Go 的方法接收者有兩種，一種是值接收者(value receiver)，一種是指針接收者(pointer receiver)。值接收者，是接收者的類型是一個值，是一個副本，方法內部沒法對其真正的接收者作更改。指針接收者，接收者的類型是一個指針，是接收者的引用，對這個引用的修改會影響真正的接收者。
看以下代碼：
package main
import "fmt"
type XAxis int
type Point struct{
X int
Y int
}
func (x XAxis)VIncr(offset XAxis){
x += offset
fmt.Printf("In VIncr, new x = %d\n", x)
}
func (x *XAxis)PIncr(offset XAxis){
*x += offset
fmt.Printf("In PIncr, new x = %d\n", *x)
}
func (p Point)VScale(factor int){
p.X *= factor
p.Y *= factor
fmt.Printf("In VScale, new p = %v\n", p)
}
func (p *Point)PScale(factor int){
p.X *= factor
p.Y *= factor
fmt.Printf("In PScale, new p = %v\n", p)
}
func main(){
var x XAxis = 10
fmt.Printf("In main, before VIncr, x = %v\n", x)
x.VIncr(5)
fmt.Printf("In main, after VIncr, new x = %v\n", x)
fmt.Println()
fmt.Printf("In main, before PIncr, x = %v\n", x)
x.PIncr(5)
fmt.Printf("In main, after PIncr, new x = %v\n", x)
fmt.Println()
p := Point{2, 2}
fmt.Printf("In main, before VScale, p = %v\n", p)
p.VScale(5)
fmt.Printf("In main, after VScale, new p = %v\n", p)
fmt.Println()
fmt.Printf("In main, before PScale, p = %v\n", p)
p.PScale(5)
fmt.Printf("In main, after PScale, new p = %v\n", p)
}
輸出：
In main, before VIncr, x = 10
In VIncr, new x = 15
In main, after VIncr, new x = 10
In main, before PIncr, x = 10
In PIncr, new x = 15
In main, after PIncr, new x = 15
In main, before VScale, p = {2 2}
In VScale, new p = {10 10}
In main, after VScale, new p = {2 2}
In main, before PScale, p = {2 2}
In PScale, new p = &{10 10}
In main, after PScale, new p = {10 10}
在定義方法的時候，receiver 是在方法名的前面，而不是在參數列表裏，那在方法執行的時候，方法內的指令怎麼找到receiver的呢？
咱們精簡一下代碼(註釋掉 print 相關語句)，而後把反編譯：
TEXT %22%22.XAxis.VIncr(SB) gofile../Users/user/go/src/test/main.go main.go:14 0xbb0 488b442408 MOVQ 0x8(SP), AX main.go:14 0xbb5 4803442410 ADDQ 0x10(SP), AX main.go:14 0xbba 4889442408 MOVQ AX, 0x8(SP) main.go:16 0xbbf c3 RET TEXT %22%22.(*XAxis).PIncr(SB) gofile../Users/user/go/src/test/main.go main.go:19 0xbd4 488b442408 MOVQ 0x8(SP), AX main.go:19 0xbd9 8400 TESTB AL, 0(AX) main.go:19 0xbdb 488b4c2408 MOVQ 0x8(SP), CX main.go:19 0xbe0 8401 TESTB AL, 0(CX) main.go:19 0xbe2 488b00 MOVQ 0(AX), AX main.go:19 0xbe5 4803442410 ADDQ 0x10(SP), AX main.go:19 0xbea 488901 MOVQ AX, 0(CX) main.go:21 0xbed c3 RET TEXT %22%22.Point.VScale(SB) gofile../Users/user/go/src/test/main.go main.go:24 0xc0a 488b442408 MOVQ 0x8(SP), AX main.go:24 0xc0f 488b4c2418 MOVQ 0x18(SP), CX main.go:24 0xc14 480fafc1 IMULQ CX, AX main.go:24 0xc18 4889442408 MOVQ AX, 0x8(SP) main.go:25 0xc1d 488b442410 MOVQ 0x10(SP), AX main.go:25 0xc22 488b4c2418 MOVQ 0x18(SP), CX main.go:25 0xc27 480fafc1 IMULQ CX, AX main.go:25 0xc2b 4889442410 MOVQ AX, 0x10(SP) main.go:28 0xc30 c3 RET TEXT %22%22.(*Point).PScale(SB) gofile../Users/user/go/src/test/main.go main.go:32 0xc47 488b442408 MOVQ 0x8(SP), AX main.go:32 0xc4c 8400 TESTB AL, 0(AX) main.go:32 0xc4e 488b4c2408 MOVQ 0x8(SP), CX main.go:32 0xc53 8401 TESTB AL, 0(CX) main.go:32 0xc55 488b00 MOVQ 0(AX), AX main.go:32 0xc58 488b542410 MOVQ 0x10(SP), DX main.go:32 0xc5d 480fafc2 IMULQ DX, AX main.go:32 0xc61 488901 MOVQ AX, 0(CX) main.go:33 0xc64 488b442408 MOVQ 0x8(SP), AX main.go:33 0xc69 8400 TESTB AL, 0(AX) main.go:33 0xc6b 488b4c2408 MOVQ 0x8(SP), CX main.go:33 0xc70 8401 TESTB AL, 0(CX) main.go:33 0xc72 488b4008 MOVQ 0x8(AX), AX main.go:33 0xc76 488b542410 MOVQ 0x10(SP), DX main.go:33 0xc7b 480fafc2 IMULQ DX, AX main.go:33 0xc7f 48894108 MOVQ AX, 0x8(CX) main.go:36 0xc83 c3 RET TEXT %22%22.main(SB) gofile../Users/user/go/src/test/main.go main.go:38 0xcaa 65488b0c2500000000 MOVQ GS:0, CX [5:9]R_TLS_LE main.go:38 0xcb3 483b6110 CMPQ 0x10(CX), SP main.go:38 0xcb7 0f86b3000000 JBE 0xd70 main.go:38 0xcbd 4883ec50 SUBQ $0x50, SP main.go:38 0xcc1 48896c2448 MOVQ BP, 0x48(SP) main.go:38 0xcc6 488d6c2448 LEAQ 0x48(SP), BP main.go:39 0xccb 48c74424300a000000 MOVQ $0xa, 0x30(SP) main.go:42 0xcd4 48c704240a000000 MOVQ $0xa, 0(SP) main.go:42 0xcdc 48c744240805000000 MOVQ $0x5, 0x8(SP) main.go:42 0xce5 e800000000 CALL 0xcea [1:5]R_CALL:%22%22.XAxis.VIncr main.go:48 0xcea 488d442430 LEAQ 0x30(SP), AX main.go:48 0xcef 48890424 MOVQ AX, 0(SP) main.go:48 0xcf3 48c744240805000000 MOVQ $0x5, 0x8(SP) main.go:48 0xcfc e800000000 CALL 0xd01 [1:5]R_CALL:%22%22.(*XAxis).PIncr main.go:53 0xd01 0f57c0 XORPS X0, X0 main.go:53 0xd04 0f11442438 MOVUPS X0, 0x38(SP) main.go:53 0xd09 48c744243802000000 MOVQ $0x2, 0x38(SP) main.go:53 0xd12 48c744244002000000 MOVQ $0x2, 0x40(SP) main.go:56 0xd1b 48c7042402000000 MOVQ $0x2, 0(SP) main.go:56 0xd23 48c744240802000000 MOVQ $0x2, 0x8(SP) main.go:56 0xd2c 48c744241005000000 MOVQ $0x5, 0x10(SP) main.go:56 0xd35 e800000000 CALL 0xd3a [1:5]R_CALL:%22%22.Point.VScale main.go:62 0xd3a 488d442438 LEAQ 0x38(SP), AX main.go:62 0xd3f 48890424 MOVQ AX, 0(SP) main.go:62 0xd43 48c744240805000000 MOVQ $0x5, 0x8(SP) main.go:62 0xd4c e800000000 CALL 0xd51 [1:5]R_CALL:%22%22.(*Point).PScale main.go:64 0xd51 48c7042400000000 MOVQ $0x0, 0(SP) main.go:64 0xd59 0f57c0 XORPS X0, X0 main.go:64 0xd5c 0f11442408 MOVUPS X0, 0x8(SP) main.go:64 0xd61 e800000000 CALL 0xd66 [1:5]R_CALL:fmt.Println main.go:65 0xd66 488b6c2448 MOVQ 0x48(SP), BP main.go:65 0xd6b 4883c450 ADDQ $0x50, SP main.go:65 0xd6f c3 RET main.go:38 0xd70 e800000000 CALL 0xd75 [1:5]R_CALL:runtime.morestack_noctxt main.go:38 0xd75 e930ffffff JMP %22%22.main(SB)
以main.go 42行 x.VIncr(5)爲例，在main裏面，傳遞參數對應的指令是
main.go:42 0xcd4 48c704240a000000 MOVQ $0xa, 0(SP); 將值 10 做爲第一個參數 main.go:42 0xcdc 48c744240805000000 MOVQ $0x5, 0x8(SP); 將值 5 做爲第二個參數 main.go:42 0xce5 e800000000 CALL 0xcea [1:5]R_CALL:%22%22.XAxis.VIncr
再看 x.VIncr 的彙編代碼：
main.go:14 0xbb0 488b442408 MOVQ 0x8(SP), AX; 取第一個參數到寄存器AX main.go:14 0xbb5 4803442410 ADDQ 0x10(SP), AX; 取第二個參數加到寄存器AX main.go:14 0xbba 4889442408 MOVQ AX, 0x8(SP); 將和寫入到了第一個參數在棧上的位置 main.go:16 0xbbf c3 RET
能夠看到，方法 VIncr 的 receiver 是值，則caller在調用VIncr的時候，將這個值複製到棧上給VIncr的參數區裏，在 VIncr 對receiver的修改，其實是修改的這個參數區裏的值，而不是 caller 棧裏保存局部變量的區裏的 receiver 的值（在語言使用者視角，就是 修改的是拷貝而不是原值）。
接着咱們看main.go第48行 x.PIncr(5)，在main裏面，調用的指令是：
main.go:39 0xccb 48c74424300a000000 MOVQ $0xa, 0x30(SP) ... main.go:48 0xcea 488d442430 LEAQ 0x30(SP), AX; 將SP+0x30這個內存地址保存到AX; SP+0x30這個內存地址裏存的是 10(執行 var x XAxis = 10 時定義的局部變量) main.go:48 0xcef 48890424 MOVQ AX, 0(SP); 將AX的值做爲第一個參數。 main.go:48 0xcf3 48c744240805000000 MOVQ $0x5, 0x8(SP); 將 5 做爲第二個參數 main.go:48 0xcfc e800000000 CALL 0xd01 [1:5]R_CALL:%22%22.(*XAxis).PIncr
PIncr的彙編代碼：
main.go:19 0xbd4 488b442408 MOVQ 0x8(SP), AX; 將第一個參數(即main的幀棧上局部變量 x 的內存地址)讀取到AX main.go:19 0xbd9 8400 TESTB AL, 0(AX) main.go:19 0xbdb 488b4c2408 MOVQ 0x8(SP), CX; 將第一個參數(即main的幀棧上局部變量 x 的內存地址)讀取到 CX main.go:19 0xbe0 8401 TESTB AL, 0(CX) main.go:19 0xbe2 488b00 MOVQ 0(AX), AX; 從 AX 裏讀到內存地址，從內存地址裏拿到值，再讀到AX(就是main的局部變量 x 的值) main.go:19 0xbe5 4803442410 ADDQ 0x10(SP), AX; 將 第二個參數 5 加到 AX 裏 main.go:19 0xbea 488901 MOVQ AX, 0(CX); 將計算結果寫入到 CX 裏的內存地址(即 main的幀棧上局部變量 x 的內存地址) main.go:21 0xbed c3 RET
能夠看到，方法 PIncr 的 receiver 是指針(pointer)，則caller在調用PIncr的時候，將這個pointer複製到棧上給PIncr的參數區裏，在 PIncr 對receiver的修改，其實是修改pointer指向的內存區域，也就是main的局部變量 x。（在語言使用者視角，就是 修改的是原值）。
打印調用棧，相比彙編更方便的看實際傳遞的參數：
goroutine 1 [running]:
runtime/debug.Stack(0x1036126, 0x10a4360, 0xc000098000)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.XAxis.VIncr(0xa, 0x5)
/Users/user/go/src/test/main.go:18 +0x26
main.main()
/Users/user/go/src/test/main.go:47 +0x40
goroutine 1 [running]:
runtime/debug.Stack(0x10e0480, 0xc000094000, 0xc000080f10)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.(*XAxis).PIncr(0xc000080f70, 0x5)
/Users/user/go/src/test/main.go:24 +0x33
main.main()
/Users/user/go/src/test/main.go:53 +0x57
goroutine 1 [running]:
runtime/debug.Stack(0x10e0480, 0xc000094000, 0xc000080f10)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.Point.VScale(0x2, 0x2, 0x5)
/Users/user/go/src/test/main.go:31 +0x26
main.main()
/Users/user/go/src/test/main.go:61 +0x90
goroutine 1 [running]:
runtime/debug.Stack(0x10e0480, 0xc000094000, 0xc000080f10)
/usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.(*Point).PScale(0xc000080f78, 0x5)
/Users/user/go/src/test/main.go:39 +0x46
main.main()
/Users/user/go/src/test/main.go:67 +0xa7
當方法的receiver是value的時候，調用方法時是把value拷貝一份做爲第一個參數傳遞給callee的，這樣caller裏對receiver的修改其實是修改的拷貝，不影響原值。當方法的receiver是pointer的時候，調用方法時是把pointer拷貝一份做爲第一個參數傳遞給caller的，這樣callee能夠經過這個pointer修改原值。
一點補充
- 若是在方法裏修改receiver的值要對caller生效，使用 pointer receiver
- 出於性能優化，若是receiver是結構體或者數組這樣佔用較多內存的數據類型，優先使用pointer receiver
注意：
- 值接收器是併發安全的，而指針接收器不是併發安全的。
調用規則：
- 類型 T 的可調用方法集包含接受者爲 T 或 T 的全部方法集
- 類型 T 的可調用方法集包含接受者爲 T 的全部方法
- 類型 T 的可調用方法集不包含接受者爲 *T 的方法
方法的接收者與函數/方法的參數的比較：
- 函數/方法的實參類型和形參類型必須一致，(在語法上)不能一個是pointer而另外一個是value。
- 方法的接收者比較智能，若是是 pointer receiver，在值上也能夠調用這個方法（編譯器會自動插入從值取到指針的指令）。若是是 value receiver，那麼當在pointer上調用這個方法時，編譯器會自動將pointer轉換爲pointer所對應的值。
匿名函數和閉包
匿名函數
匿名函數由一個不帶函數名的函數聲明和函數體組成，匿名函數能夠賦值給變量，做爲結構體字段，或者在channel中傳遞。在底層實現中，實際上傳遞的是匿名函數的入口地址。
package main
func test() func(int) int {
return func(x int) int {
x += x
return x
}
}
func main() {
f := test()
f(100)
}
TEXT %22%22.test(SB) gofile../Users/user/go/src/test/main.go main.go:4 0x4e7 48c744240800000000 MOVQ $0x0, 0x8(SP) main.go:5 0x4f0 488d0500000000 LEAQ 0(IP), AX [3:7]R_PCREL:%22%22.test.func1·f main.go:5 0x4f7 4889442408 MOVQ AX, 0x8(SP) main.go:5 0x4fc c3 RET TEXT %22%22.main(SB) gofile../Users/user/go/src/test/main.go main.go:11 0x517 65488b0c2500000000 MOVQ GS:0, CX [5:9]R_TLS_LE main.go:11 0x520 483b6110 CMPQ 0x10(CX), SP main.go:11 0x524 7633 JBE 0x559 main.go:11 0x526 4883ec20 SUBQ $0x20, SP main.go:11 0x52a 48896c2418 MOVQ BP, 0x18(SP) main.go:11 0x52f 488d6c2418 LEAQ 0x18(SP), BP main.go:12 0x534 e800000000 CALL 0x539 [1:5]R_CALL:%22%22.test main.go:12 0x539 488b1424 MOVQ 0(SP), DX main.go:12 0x53d 4889542410 MOVQ DX, 0x10(SP) main.go:13 0x542 48c7042464000000 MOVQ $0x64, 0(SP) main.go:13 0x54a 488b02 MOVQ 0(DX), AX main.go:13 0x54d ffd0 CALL AX [0:0]R_CALLIND main.go:14 0x54f 488b6c2418 MOVQ 0x18(SP), BP main.go:14 0x554 4883c420 ADDQ $0x20, SP main.go:14 0x558 c3 RET main.go:11 0x559 e800000000 CALL 0x55e [1:5]R_CALL:runtime.morestack_noctxt main.go:11 0x55e ebb7 JMP %22%22.main(SB) TEXT %22%22.test.func1(SB) gofile../Users/user/go/src/test/main.go main.go:5 0x58a 48c744241000000000 MOVQ $0x0, 0x10(SP) main.go:6 0x593 488b442408 MOVQ 0x8(SP), AX main.go:6 0x598 4803442408 ADDQ 0x8(SP), AX main.go:6 0x59d 4889442408 MOVQ AX, 0x8(SP) main.go:7 0x5a2 4889442410 MOVQ AX, 0x10(SP)
閉包
當函數引用外部做用域的變量時，咱們稱之爲閉包。在底層實現上，閉包由函數地址和引用到的變量的地址組成，並存儲在一個結構體裏，在閉包被傳遞時，實際是該結構體的地址被傳遞。由於棧幀上的值在該幀的函數退出後就失效了，所以閉包引用的外部做用域的變量會被分配到堆上。在如下的實現中，test()函數返回一個閉包賦值給f，實際是main裏收到閉包結構體(堆上)的地址，並保存在DX寄存器上，地址對應的內存值是閉包函數地址(函數地址取到寄存器以後，就能夠經過 call 調用)，地址偏移8個字節(+8bytes)是變量x的的地址，在main裏調用閉包函數f時，f內部依然是經過讀取DX的值來獲得變量x的地址。即main調用f雖然沒有傳遞參數也沒有返回值，可是他們卻共享了一個寄存器DX的值。
package main
func test() func() {
x := 100
return func() {
x += 100
}
}
func main() {
f := test()
f()
f()
f()
}
TEXT %22%22.test(SB) gofile../Users/user/go/src/test/main.go
main.go:3 0x6ad 65488b0c2500000000 MOVQ GS:0, CX [5:9]R_TLS_LE
main.go:3 0x6b6 483b6110 CMPQ 0x10(CX), SP
main.go:3 0x6ba 0f869b000000 JBE 0x75b
main.go:3 0x6c0 4883ec28 SUBQ $0x28, SP
main.go:3 0x6c4 48896c2420 MOVQ BP, 0x20(SP)
main.go:3 0x6c9 488d6c2420 LEAQ 0x20(SP), BP
main.go:3 0x6ce 48c744243000000000 MOVQ $0x0, 0x30(SP)
main.go:4 0x6d7 488d0500000000 LEAQ 0(IP), AX [3:7]R_PCREL:type.int
main.go:4 0x6de 48890424 MOVQ AX, 0(SP)
main.go:4 0x6e2 e800000000 CALL 0x6e7 [1:5]R_CALL:runtime.newobject
main.go:4 0x6e7 488b442408 MOVQ 0x8(SP), AX
main.go:4 0x6ec 4889442418 MOVQ AX, 0x18(SP)
main.go:4 0x6f1 48c70064000000 MOVQ $0x64, 0(AX)
main.go:5 0x6f8 488d0500000000 LEAQ 0(IP), AX [3:7]R_PCREL:type.noalg.struct { F uintptr; %22%22.x *int }
main.go:5 0x6ff 48890424 MOVQ AX, 0(SP)
main.go:5 0x703 e800000000 CALL 0x708 [1:5]R_CALL:runtime.newobject
main.go:5 0x708 488b442408 MOVQ 0x8(SP), AX
main.go:5 0x70d 4889442410 MOVQ AX, 0x10(SP)
main.go:5 0x712 488d0d00000000 LEAQ 0(IP), CX [3:7]R_PCREL:%22%22.test.func1
main.go:5 0x719 488908 MOVQ CX, 0(AX)
main.go:5 0x71c 488b442410 MOVQ 0x10(SP), AX
main.go:5 0x721 8400 TESTB AL, 0(AX)
main.go:5 0x723 488b4c2418 MOVQ 0x18(SP), CX
main.go:5 0x728 488d7808 LEAQ 0x8(AX), DI
main.go:5 0x72c 833d0000000000 CMPL $0x0, 0(IP) [2:6]R_PCREL:runtime.writeBarrier+-1
main.go:5 0x733 7402 JE 0x737
main.go:5 0x735 eb1a JMP 0x751
main.go:5 0x737 48894808 MOVQ CX, 0x8(AX)
main.go:5 0x73b eb00 JMP 0x73d
main.go:5 0x73d 488b442410 MOVQ 0x10(SP), AX
main.go:5 0x742 4889442430 MOVQ AX, 0x30(SP)
main.go:5 0x747 488b6c2420 MOVQ 0x20(SP), BP
main.go:5 0x74c 4883c428 ADDQ $0x28, SP
main.go:5 0x750 c3 RET
main.go:5 0x751 4889c8 MOVQ CX, AX
main.go:5 0x754 e800000000 CALL 0x759 [1:5]R_CALL:runtime.gcWriteBarrier
main.go:5 0x759 ebe2 JMP 0x73d
main.go:3 0x75b e800000000 CALL 0x760 [1:5]R_CALL:runtime.morestack_noctxt
main.go:3 0x760 e948ffffff JMP %22%22.test(SB)
TEXT %22%22.main(SB) gofile../Users/user/go/src/test/main.go
main.go:10 0x7bc 65488b0c2500000000 MOVQ GS:0, CX [5:9]R_TLS_LE
main.go:10 0x7c5 483b6110 CMPQ 0x10(CX), SP
main.go:10 0x7c9 763f JBE 0x80a
main.go:10 0x7cb 4883ec18 SUBQ $0x18, SP
main.go:10 0x7cf 48896c2410 MOVQ BP, 0x10(SP)
main.go:10 0x7d4 488d6c2410 LEAQ 0x10(SP), BP
main.go:11 0x7d9 e800000000 CALL 0x7de [1:5]R_CALL:%22%22.test
main.go:11 0x7de 488b1424 MOVQ 0(SP), DX
main.go:11 0x7e2 4889542408 MOVQ DX, 0x8(SP)
main.go:12 0x7e7 488b02 MOVQ 0(DX), AX
main.go:12 0x7ea ffd0 CALL AX [0:0]R_CALLIND
main.go:13 0x7ec 488b542408 MOVQ 0x8(SP), DX
main.go:13 0x7f1 488b02 MOVQ 0(DX), AX
main.go:13 0x7f4 ffd0 CALL AX [0:0]R_CALLIND
main.go:14 0x7f6 488b542408 MOVQ 0x8(SP), DX
main.go:14 0x7fb 488b02 MOVQ 0(DX), AX
main.go:14 0x7fe ffd0 CALL AX [0:0]R_CALLIND
main.go:15 0x800 488b6c2410 MOVQ 0x10(SP), BP
main.go:15 0x805 4883c418 ADDQ $0x18, SP
main.go:15 0x809 c3 RET
main.go:10 0x80a e800000000 CALL 0x80f [1:5]R_CALL:runtime.morestack_noctxt
main.go:10 0x80f ebab JMP %22%22.main(SB)
TEXT %22%22.test.func1(SB) gofile../Users/user/go/src/test/main.go
main.go:5 0x84b 4883ec10 SUBQ $0x10, SP
main.go:5 0x84f 48896c2408 MOVQ BP, 0x8(SP)
main.go:5 0x854 488d6c2408 LEAQ 0x8(SP), BP
main.go:5 0x859 488b4208 MOVQ 0x8(DX), AX
main.go:5 0x85d 48890424 MOVQ AX, 0(SP)
main.go:6 0x861 48830064 ADDQ $0x64, 0(AX)
main.go:7 0x865 488b6c2408 MOVQ 0x8(SP), BP
main.go:7 0x86a 4883c410 ADDQ $0x10, SP
main.go:7 0x86e c3 RET
遞歸函數
從本質上講遞歸函數與普通函數並沒有特殊之處，只是不斷調用自身，棧不斷增長而已。在 C 裏面棧大小是固定的，所以須要關心棧溢出(Stack overflow)的問題。不過 Go 裏面棧根據須要自動擴容，不須要擔憂這個問題。
關於 defer 語句
defer與return
能夠先看一下下面三個函數，嘗試推理函數的返回值：
func f() (result int) {
defer func() {
result++
}()
return 0
}
func f() (r int) {
t := 5
defer func() {
t = t + 5
}()
return t
}
func f() (r int) {
defer func(r int) {
r = r + 5
}(r)
return 1
}
正確答案分別是：1，5，1。若是你的答案正確，能夠略過下面的解釋了 :)
"defer 後的函數調用 在 return 語句以前執行"這句話並不容易理解正確。實際上 return xxx 語句不是原子的，而是先將xxx寫入到 caller 爲返回值分配的棧空間，接着執行 RET 指令這兩步操做。defer函數就是插入在 RET 指令前執行。
goroutine的控制結構裏有一張記錄defer表達式的表，編譯器在defer出現的地方插入了指令 call runtime.deferproc，它將defer的表達式記錄在表中。而後在函數返回以前依次從defer表中將表達式出棧執行，這時插入的指令是call runtime.deferreturn。
defer 與閉包
defer 語句調用的函數的參數是在defer註冊時求值或複製的。所以局部變量做爲參數傳遞給defer的函數語句後，後面對局部變量的修改將再也不影響defer函數內對該變量值的使用。可是defer函數裏使用非參數傳入的外部函數的變量，將使用到該變量在外部函數生命週期內最終的值。
package main
import "fmt"
func test() {
x, y := 10, 20
defer func(i int) {
fmt.Println("defer:", i, y)
}(x)
x += 10
y += 100
fmt.Println(x, y)
}
func main(){
test()
}
輸出： 20 120 defer: 10 120
備註：
- 內存中棧從高地址空間向低地址空間增加，棧頂比棧底的內存地址小，分配棧空間對應的是 sp 值的減少。
- 寫值是從低地址往高地址寫，好比 SP 指向 0xff00，往棧裏寫入一個字(8 字節)，佔用的是 0xff00 到 0xff07 這 8 個字節。
- intel存儲字節的順序爲小端優先：即低有效字節存儲在內存低地址中。
- 在IA-32和X86-64中，字長定義爲16位，dword（雙倍字）是 32 位，qword（四倍字）是64位。
生成彙編文件的方法
- 使用
go tool compile -N -l -S go_file.go生成 - 使用
go tool compile -N -l go_file.go編譯成二進制文件，接着執行go tool objdump bin_name.o反彙編出代碼，能夠經過 -s 指定函數名從而只反彙編特定函數：go tool objdump -s YOUR_FUNC_NAME bin_name.o - 使用
go build -gcflags -S生成
注意：go tool compile 和 go build -gcflags -S 生成的是過程當中的彙編，go tool objdump生成的是最終的機器碼的彙編。
總結
Go 語言徹底使用棧來傳遞參數和返回值並由調用者負責清棧，經過棧傳遞返回值使得Go函數能支持多返回值，調用者清棧則能夠實現可變參數的函數。Go 使用值傳遞的模式傳遞參數，所以傳遞數組和結構體時，應該儘可能使用指針做爲參數來避免大量數據拷貝從而提高性能。
Go 方法調用的時候是將接收者做爲參數傳遞給了callee，接收者分值接收者和指針接收者。
當傳遞匿名函數的時候，傳遞的其實是函數的入口指針。當使用閉包的時候，Go 經過逃逸分析機制將變量分配到堆內存，變量地址和函數入口地址組成一個存在堆上的結構體，傳遞閉包的時候，傳遞的就是這個結構體的地址。
Go 的數據類型分爲值類型和引用類型，但 Go 的參數傳遞是值傳遞。當傳遞的是值類型的時候，是徹底的拷貝，callee裏對參數的修改不影響原值；當傳遞的是引用類型的時候，callee裏的修改會影響原值。
帶返回值的return語句對應的是多條機器指令，首先是將返回值寫入到caller在棧上爲返回值分配的空間，而後執行ret指令。有defer語句的時候，defer語句裏的函數就是插入到 ret 指令以前執行。
參考和深刻閱讀：
關於調用慣例
x86 calling conventions
Calling convention
關於內存佈局和函數幀棧
x86-64 下函數調用及棧幀原理
Process Memory Layout
Anatomy of a Program in Memory
Linux進程地址空間 && 進程內存佈局
運行時內存佈局與棧幀結構
C程序的內存佈局(Memory Layout
C函數調用過程原理及函數棧幀分析
關於Plan9彙編
plan9 彙編入門
golang彙編基礎知識
golang 彙編
關於Go
Function declarations, Method declarations
Effective Go Functions
深刻研究goroutine棧
Go defer關鍵字
Go語言高級編程 再論函數
本文從這些文章中引用了代碼樣例和語句
Stack Traces In Go
淺談Go語言實現原理-函數調用
相關文章
- 1. 函數調用前後棧和寄存器的變化
- 2. 函數調用棧空間以及fp寄存器
- 3. X86-64寄存器和棧幀
- 4. 函數調用和棧幀
- 5. Stm32用寄存器仍是庫函數
- 6. [譯] 解析 Go 中的函數調用
- 7. 函數調用--函數棧
- 8. 從彙編視角看函數調用
- 9. X86-64寄存器和棧幀--牛掰降解彙編函數寄存器相關操做
- 10. 函數調用棧
- 更多相關文章...
- • Scala 函數傳名調用(call-by-name) - Scala教程
- • C# 堆棧（Stack） - C#教程
- • TiDB 在摩拜單車在線數據業務的應用和實踐
- • Git可視化極簡易教程 — Git GUI使用方法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 函數調用前後棧和寄存器的變化
- 2. 函數調用棧空間以及fp寄存器
- 3. X86-64寄存器和棧幀
- 4. 函數調用和棧幀
- 5. Stm32用寄存器仍是庫函數
- 6. [譯] 解析 Go 中的函數調用
- 7. 函數調用--函數棧
- 8. 從彙編視角看函數調用
- 9. X86-64寄存器和棧幀--牛掰降解彙編函數寄存器相關操做
- 10. 函數調用棧