bmf mysql_bmf 的动态 - SegmentFault 思否
函數(shù)的調(diào)用過程主要要點(diǎn)在于借助寄存器和內(nèi)存幀棧傳遞參數(shù)和返回值。雖然同為編譯型語言，Go 相較 C 對(duì)寄存器和棧的使用有一些差別，同時(shí)，Go 語言自帶協(xié)程并引入 defer 等語句，在調(diào)用過程上顯得更加復(fù)雜。 理解Go函數(shù)調(diào)用在CPU指令層的過程有助于編寫高效的代碼，在性能優(yōu)化、Bug排查的時(shí)候，能更迅速的確定要點(diǎn)。本文以簡(jiǎn)短的示例代碼和對(duì)應(yīng)的匯編代碼演示了Go的調(diào)用過程，展示了不同數(shù)據(jù)類型的參數(shù)的實(shí)際傳遞過程，同時(shí)分析了匿名函數(shù)、閉包作為參數(shù)或者返回值傳遞時(shí)，在內(nèi)存上的實(shí)際數(shù)據(jù)結(jié)構(gòu)。對(duì)于協(xié)程對(duì)棧的使用和實(shí)現(xiàn)細(xì)節(jié)，本文不展開。
閱讀本文需要掌握計(jì)算機(jī)體系結(jié)構(gòu)基礎(chǔ)知識(shí)(至少了解程序內(nèi)存布局、棧、寄存器)、Go 基礎(chǔ)語法。參考文檔提供了這些主題更詳細(xì)的知識(shí)。
以下：
術(shù)語棧：每個(gè)進(jìn)程/線程/goroutine有自己的調(diào)用棧，參數(shù)和返回值傳遞、函數(shù)的局部變量存放通常通過棧進(jìn)行。和數(shù)據(jù)結(jié)構(gòu)中的棧一樣，內(nèi)存棧也是后進(jìn)先出，地址是從高地址向低地址生長(zhǎng)。
棧幀：(stack frame)又常被稱為幀(frame)。一個(gè)棧是由很多幀構(gòu)成的，它描述了函數(shù)之間的調(diào)用關(guān)系。每一幀就對(duì)應(yīng)了一次尚未返回的函數(shù)調(diào)用，幀本身也是以棧的形式存放數(shù)據(jù)的。
caller 調(diào)用者
callee 被調(diào)用者，如在 函數(shù) A 里 調(diào)用 函數(shù) B，A 是 caller，B 是 callee
寄存器(X86)ESP：棧指針寄存器(extended stack pointer)，存放著一個(gè)指針，該指針指向棧最上面一個(gè)棧幀(即當(dāng)前執(zhí)行的函數(shù)的棧)的棧頂。注意：ESP指向的是已經(jīng)存儲(chǔ)了內(nèi)容的內(nèi)存地址，而不是一個(gè)空閑的地址。例如從 0xC0000000 到 0xC00000FF是已經(jīng)使用的棧空間，ESP指向0xC00000FF
EBP：基址指針寄存器(extended base pointer)，也叫幀指針，存放著一個(gè)指針，該指針指向棧最上面一個(gè)棧幀的底部。
EIP：寄存器存放下一個(gè)CPU指令存放的內(nèi)存地址，當(dāng)CPU執(zhí)行完當(dāng)前的指令后，從EIP寄存器中讀取下一條指令的內(nèi)存地址，然后繼續(xù)執(zhí)行。
注意：16位寄存器沒有前綴(SP、BP、IP)，32位前綴是E(ESP、EBP、EIP)，64位前綴是R(RSP、RBP、RIP)
匯編指令PUSH：進(jìn)棧指令，PUSH指令執(zhí)行時(shí)會(huì)先將ESP減4，接著將內(nèi)容寫入ESP指向的棧內(nèi)存。
POP ：出棧指令，POP指令執(zhí)行時(shí)先將ESP指向的棧內(nèi)存的一個(gè)字長(zhǎng)的內(nèi)容讀出，接著將ESP加4。注意：用PUSH指令和POP指令時(shí)只能按字訪問棧，不能按字節(jié)訪問棧。
CALL：調(diào)用函數(shù)指令，將返回地址(call指令的下一條指令)壓棧，接著跳轉(zhuǎn)到函數(shù)入口。
RET：返回指令，將棧頂返回地址彈出到EIP，接著根據(jù)EIP繼續(xù)執(zhí)行。
LEAVE：等價(jià)于 mov esp,ebp; pop ebp;
MOVL：在內(nèi)存與寄存器、寄存器與寄存器之間轉(zhuǎn)移值
LEAL：用來將一個(gè)內(nèi)存地址直接賦給目的操作數(shù)
注意：8位指令后綴是B、16位是S、32位是L、64位是Q
調(diào)用慣例
調(diào)用慣例(calling convention)是指程序里調(diào)用函數(shù)時(shí)關(guān)于如何傳參如何分配和清理?xiàng)５鹊姆桨?。一個(gè)調(diào)用慣例的內(nèi)容包括：參數(shù)是通過寄存器傳遞還是棧傳遞或者二者混合
通過棧傳遞時(shí)參數(shù)是從左至右壓棧還是從右至左壓棧
函數(shù)結(jié)果是通過寄存器傳遞還是通過棧傳遞
調(diào)用者(caller)還是被調(diào)用者(callee)清理?xiàng)？臻g
被調(diào)用者應(yīng)該為調(diào)用者保存哪些寄存器
例如，C 的調(diào)用慣例(cdecl, C declaration)是：
函數(shù)實(shí)參在線程棧上按照從右至左的順序依次壓棧。
函數(shù)結(jié)果保存在寄存器EAX/AX/AL中
浮點(diǎn)型結(jié)果存放在寄存器ST0中
編譯后的函數(shù)名前綴以一個(gè)下劃線字符
調(diào)用者負(fù)責(zé)從線程棧中彈出實(shí)參(即清棧)
8比特或者16比特長(zhǎng)的整形實(shí)參提升為32比特長(zhǎng)。
受到函數(shù)調(diào)用影響的寄存器(volatile registers)：EAX, ECX, EDX, ST0 - ST7, ES, GS
不受函數(shù)調(diào)用影響的寄存器： EBX, EBP, ESP, EDI, ESI, CS, DS
RET指令從函數(shù)被調(diào)用者返回到調(diào)用者(實(shí)質(zhì)上是讀取寄存器EBP所指的線程棧之處保存的函數(shù)返回地址并加載到IP寄存器)
cdecl 將函數(shù)返回值保存在寄存器中，所以 C 語言不支持多個(gè)返回值。另外，cdecl 是調(diào)用者負(fù)責(zé)清棧，因而可以實(shí)現(xiàn)可變參數(shù)的函數(shù)。如果是被調(diào)用者負(fù)責(zé)清理的話，無法實(shí)現(xiàn)可變參數(shù)的函數(shù)，但是編譯代碼的效率會(huì)高一點(diǎn)，因?yàn)榍謇項(xiàng)５拇a不用在每次調(diào)用的時(shí)候(編譯器計(jì)算)生成一遍。(x86的ret指令允許一個(gè)可選的16位參數(shù)說明棧字節(jié)數(shù)，用來在返回給調(diào)用者之前解堆棧。代碼類似ret 12這樣，如果遇到這樣的匯編代碼，說明是被調(diào)用者清棧。)
注意，雖然 C 語言 里都是借助寄存器傳遞返回值，但是返回值大小不同時(shí)有不同的處理情形。若小于4字節(jié)，返回值存入eax寄存器，由函數(shù)調(diào)用方讀取eax。若返回值5到8字節(jié)，采用eax和edx聯(lián)合返回。若大于8個(gè)字節(jié)，首先在棧上額外開辟一部分空間temp，將temp對(duì)象的地址做為隱藏參數(shù)入棧。函數(shù)返回時(shí)將數(shù)據(jù)拷貝給temp對(duì)象，并將temp對(duì)象的地址用寄存器eax傳出。調(diào)用方從eax指向的temp對(duì)象拷貝內(nèi)容。
可以看到，設(shè)計(jì)一個(gè)編程語言的特性時(shí)，需要為其選擇合適調(diào)用慣例才能在底層實(shí)現(xiàn)這些特性。(調(diào)用慣例是編程語言的編譯器選擇的，同樣的語言不同的編譯器可能會(huì)選擇實(shí)現(xiàn)不同的調(diào)用慣例)
一次典型的 C 函數(shù)調(diào)用過程
在caller里：將實(shí)參從右至左壓棧(X86-64下是：將實(shí)參寫入寄存器，如果實(shí)參超過 6 個(gè)，超出的從右至左壓棧)
執(zhí)行 call 指令(會(huì)將返回地址壓棧，并跳轉(zhuǎn)到 callee 入口)
進(jìn)入callee里：push ebp; mov ebp,esp; 此時(shí)EBP和ESP已經(jīng)分別表示callee的棧底和棧頂了。之后 EBP 的值會(huì)保持固定。此后局部變量和臨時(shí)存儲(chǔ)都可以通過基準(zhǔn)指針EBP加偏移量找到了。
sub xxx, esp; 棧頂下移，為callee分配空間，用于存放局部變量等。分配的內(nèi)存單元可以通過 EBP - K 或者 ESP + K 得到地址訪問。
將某些寄存器的值壓棧(可能)
callee執(zhí)行
將某些寄存器值彈出棧(可能)
mov esp,ebp; pop ebp; (這兩條指令也可以用 leave 指令替代)此時(shí) EBP 和 ESP 回到了進(jìn)入callee之前的狀態(tài)，即分別表示caller的棧底和棧頂狀態(tài)。
執(zhí)行 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目標(biāo)代碼并不使用寄存器傳遞參數(shù)，而X86-64目標(biāo)代碼里，使用寄存器傳遞前六個(gè)參數(shù)。
一次典型的Go函數(shù)調(diào)用過程
Go 選擇的調(diào)用慣例是：參數(shù)完全通過棧傳遞，從參數(shù)列表的右至左壓棧
返回值通過棧傳遞，返回值的?？臻g在參數(shù)之前，即返回值在更接近c(diǎn)aller棧底的位置
caller負(fù)責(zé)清理?xiàng)ackage 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 的?？臻g(四個(gè) qword，8個(gè)bytes 為一個(gè) qword)
main.go:4 0x104ea33 48896c2418 MOVQ BP, 0x18(SP) ; 將 BP 的值寫入到剛分配的棧空間的第一個(gè)qword
main.go:4 0x104ea38 488d6c2418 LEAQ 0x18(SP), BP ; 將剛分配的?？臻g的第一個(gè)字的地址賦值給BP(即BP此時(shí)指向了剛才存放舊BP值的地址)
main.go:5 0x104ea3d 48c7042401000000 MOVQ $0x1, 0(SP); 將給add函數(shù)的第一個(gè)實(shí)參值1 寫入到剛分配?？臻g的最后一個(gè)qword
main.go:5 0x104ea45 48c744240802000000 MOVQ $0x2, 0x8(SP); 將給add函數(shù)的第二個(gè)實(shí)參值2 寫入到剛分配棧空間的第三個(gè)qword。第二個(gè) qword 沒有用到，實(shí)際上是給callee用來存放返回值的。
main.go:5 0x104ea4e e81d000000 CALL main.add(SB); 調(diào)用 add 函數(shù)
main.go:6 0x104ea53 488b6c2418 MOVQ 0x18(SP), BP; 將從棧里第四個(gè)qword將舊的BP值取回賦值到BP
main.go:6 0x104ea58 4883c420 ADDQ $0x20, SP; 增加SP的值，棧收縮，收回 32 bytes的?？臻g
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 個(gè) qword)。
main.go:11 0x104ea74 48896c2410 MOVQ BP, 0x10(SP); 將 BP值 寫入第一個(gè)qword
main.go:11 0x104ea79 488d6c2410 LEAQ 0x10(SP), BP; 將剛分配的24 bytes ?？臻g的第一個(gè)字的地址賦值給BP(即BP此時(shí)指向了剛才存放舊BP值的地址)
main.go:11 0x104ea7e 48c744243000000000 MOVQ $0x0, 0x30(SP);將存放返回值的地址清零，0x30(SP) 對(duì)應(yīng)的內(nèi)存位置是上一段 main.main 里分配的棧空間的第二個(gè)qword。
main.go:12 0x104ea87 48c744240803000000 MOVQ $0x3, 0x8(SP); 對(duì)應(yīng) c := 3 這行代碼。局部變量 c 對(duì)應(yīng)的是棧上內(nèi)存。3 被寫入到剛分配的 24 bytes 空間的第二個(gè)qword。
main.go:13 0x104ea90 488b442420 MOVQ 0x20(SP), AX; 將add的實(shí)參 1 寫入到AX 寄存器。
main.go:13 0x104ea95 4803442428 ADDQ 0x28(SP), AX; 將add的實(shí)參 2 增加到 AX 寄存器。
main.go:13 0x104ea9a 4883c003 ADDQ $0x3, AX; 將局部變量值 3 增加到 AX 寄存器
main.go:13 0x104ea9e 48890424 MOVQ AX, 0(SP); 將 AX 的值(計(jì)算結(jié)果) 寫入到剛分配的 24 bytes 空間的第三個(gè)qword。(對(duì)應(yīng)代碼 d := a + b + c)
main.go:14 0x104eaa2 4889442430 MOVQ AX, 0x30(SP); 將 AX 的值寫入到main里為返回值留的?？臻g(main里分配的32 bytes 中的第二個(gè) qword)
main.go:14 0x104eaa7 488b6c2410 MOVQ 0x10(SP), BP; 恢復(fù)BP的值為函數(shù)入口處保存的舊BP的值。
main.go:14 0x104eaac 4883c418 ADDQ $0x18, SP; 將 SP 增加三個(gè)字，收回add入口處分配的?？臻g。
main.go:14 0x104eab0 c3 RET
函數(shù)調(diào)用過程中，棧的變化情況如圖：
初始狀態(tài)：
call add執(zhí)行前棧狀態(tài)：
進(jìn)入add里之后棧狀態(tài)：
add里ret執(zhí)行前棧狀態(tài)：
main里ret執(zhí)行前棧狀態(tài)：
可以看到 Go 的調(diào)用過程和 C 類似，區(qū)別在于 Go 的參數(shù)完全通過棧傳遞，Go 的返回值也是通過棧傳遞。對(duì)于每種數(shù)據(jù)類型在作為參數(shù)傳遞時(shí)的表現(xiàn)，可以測(cè)試一下：
不同數(shù)據(jù)類型作為參數(shù)時(shí)的傳遞方式
Go 基礎(chǔ)數(shù)據(jù)類型的參數(shù)傳遞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傳遞時(shí)，分為pointer和length兩個(gè)參數(shù)傳遞。
int64傳遞時(shí)，復(fù)制了值進(jìn)行傳遞。
看debug.Stack()打印出的調(diào)用棧，int8和bool傳遞時(shí)，傳遞的是一個(gè)內(nèi)存地址，這似乎容易引起誤解，難道傳遞的是caller里變量的內(nèi)存地址？那不是會(huì)導(dǎo)致callee修改也導(dǎo)致caller里值也發(fā)生改變？當(dāng)然不是這樣！int和bool當(dāng)然都是值傳遞。當(dāng)caller傳遞給callee的時(shí)候，int和bool都會(huì)被在caller的棧里復(fù)制一份給callee使用。(在callee直接通過引用參數(shù)名修改參數(shù)值，這個(gè)參數(shù)的內(nèi)存位置實(shí)際上是在caller的棧上)。
ExampleMultiParams函數(shù)雖然有四個(gè)參數(shù)，但是調(diào)用棧打印出來只傳遞了一個(gè)值 0x7080900，這是為什么？原來這四個(gè)參數(shù)都是一個(gè)byte，合起來是一個(gè)雙字。查看匯編代碼可以發(fā)現(xiàn)編譯器做了優(yōu)化，直接組合成一個(gè)值，并在caller里用指令MOVL $0x7080900, 0(SP)寫入棧上。當(dāng)然，在caller里取值的時(shí)候，還是借助MOVB去一個(gè)字節(jié)一個(gè)字節(jié)取值的。當(dāng)然，如果是這四個(gè)參數(shù)是main里的四個(gè)局部變量，調(diào)用ExampleMultiParams的時(shí)候通過傳遞變量名的形式調(diào)用(ExampleMultiParams(b, x, y, z)而不是 ExampleMultiParams(true, 9, 8, 7)的形式)，體現(xiàn)在匯編代碼里又是另一種形式。
Go 組合數(shù)據(jù)類型的參數(shù)傳遞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()))
}
調(diào)用棧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
可以看到：對(duì)于數(shù)組、結(jié)構(gòu)體、指針，是復(fù)制一份拷貝傳遞給callee。
數(shù)組作為參數(shù)時(shí)，編譯后參數(shù)的數(shù)量是數(shù)組元素的數(shù)量。
結(jié)構(gòu)體作為參數(shù)時(shí)，編譯后參數(shù)的數(shù)量需要再次分析結(jié)構(gòu)體里元素的類型。如上述代碼里結(jié)構(gòu)體由一個(gè)int和一個(gè)string組成，傳遞參數(shù)時(shí)是int值、string的地址、string的長(zhǎng)度三個(gè)參數(shù)。
slice傳遞時(shí)，會(huì)將slice底層的pointer、len、cap作為三個(gè)參數(shù)分開傳遞。(即編譯后，參數(shù)數(shù)量由源代碼里的一個(gè)參數(shù)變?yōu)榱巳齻€(gè)參數(shù))。所以slice其實(shí)也是值傳遞。
map、chan傳遞時(shí)，是將map、chan的地址指針作為參數(shù)傳遞。
方法：pointer receiver 與 value receiver
在 Java 中，當(dāng)我們調(diào)用一個(gè)對(duì)象的方法的時(shí)候，當(dāng)然是可以修改對(duì)象的成員變量的。但是在 Go 中，結(jié)果取決于定義方法時(shí)方法的接收者是值還是指針(value receiver 和 pointer receiver)。Go 的方法接收者有兩種，一種是值接收者(value receiver)，一種是指針接收者(pointer receiver)。值接收者，是接收者的類型是一個(gè)值，是一個(gè)副本，方法內(nèi)部無法對(duì)其真正的接收者做更改。指針接收者，接收者的類型是一個(gè)指針，是接收者的引用，對(duì)這個(gè)引用的修改會(huì)影響真正的接收者。
看如下代碼：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}
在定義方法的時(shí)候，receiver 是在方法名的前面，而不是在參數(shù)列表里，那在方法執(zhí)行的時(shí)候，方法內(nèi)的指令怎么找到receiver的呢？
我們精簡(jiǎn)一下代碼(注釋掉 print 相關(guān)語句)，然后把反編譯：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里面，傳遞參數(shù)對(duì)應(yīng)的指令是main.go:42 0xcd4 48c704240a000000 MOVQ $0xa, 0(SP); 將值 10 作為第一個(gè)參數(shù)
main.go:42 0xcdc 48c744240805000000 MOVQ $0x5, 0x8(SP); 將值 5 作為第二個(gè)參數(shù)
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; 取第一個(gè)參數(shù)到寄存器AX
main.go:14 0xbb5 4803442410 ADDQ 0x10(SP), AX; 取第二個(gè)參數(shù)加到寄存器AX
main.go:14 0xbba 4889442408 MOVQ AX, 0x8(SP); 將和寫入到了第一個(gè)參數(shù)在棧上的位置
main.go:16 0xbbf c3 RET
可以看到，方法 VIncr 的 receiver 是值，則caller在調(diào)用VIncr的時(shí)候，將這個(gè)值復(fù)制到棧上給VIncr的參數(shù)區(qū)里，在 VIncr 對(duì)receiver的修改，實(shí)際上是修改的這個(gè)參數(shù)區(qū)里的值，而不是 caller 棧里保存局部變量的區(qū)里的 receiver 的值(在語言使用者視角，就是 修改的是拷貝而不是原值)。
接著我們看main.go第48行 x.PIncr(5)，在main里面，調(diào)用的指令是：main.go:39 0xccb 48c74424300a000000 MOVQ $0xa, 0x30(SP)
...
main.go:48 0xcea 488d442430 LEAQ 0x30(SP), AX; 將SP+0x30這個(gè)內(nèi)存地址保存到AX; SP+0x30這個(gè)內(nèi)存地址里存的是 10(執(zhí)行 var x XAxis = 10 時(shí)定義的局部變量)
main.go:48 0xcef 48890424 MOVQ AX, 0(SP); 將AX的值作為第一個(gè)參數(shù)。
main.go:48 0xcf3 48c744240805000000 MOVQ $0x5, 0x8(SP); 將 5 作為第二個(gè)參數(shù)
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; 將第一個(gè)參數(shù)(即main的幀棧上局部變量 x 的內(nèi)存地址)讀取到AX
main.go:19 0xbd9 8400 TESTB AL, 0(AX)
main.go:19 0xbdb 488b4c2408 MOVQ 0x8(SP), CX; 將第一個(gè)參數(shù)(即main的幀棧上局部變量 x 的內(nèi)存地址)讀取到 CX
main.go:19 0xbe0 8401 TESTB AL, 0(CX)
main.go:19 0xbe2 488b00 MOVQ 0(AX), AX; 從 AX 里讀到內(nèi)存地址，從內(nèi)存地址里拿到值，再讀到AX(就是main的局部變量 x 的值)
main.go:19 0xbe5 4803442410 ADDQ 0x10(SP), AX; 將 第二個(gè)參數(shù) 5 加到 AX 里
main.go:19 0xbea 488901 MOVQ AX, 0(CX); 將計(jì)算結(jié)果寫入到 CX 里的內(nèi)存地址(即 main的幀棧上局部變量 x 的內(nèi)存地址)
main.go:21 0xbed c3 RET
可以看到，方法 PIncr 的 receiver 是指針(pointer)，則caller在調(diào)用PIncr的時(shí)候，將這個(gè)pointer復(fù)制到棧上給PIncr的參數(shù)區(qū)里，在 PIncr 對(duì)receiver的修改，實(shí)際上是修改pointer指向的內(nèi)存區(qū)域，也就是main的局部變量 x。(在語言使用者視角，就是 修改的是原值)。
打印調(diào)用棧，相比匯編更方便的看實(shí)際傳遞的參數(shù)：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
當(dāng)方法的receiver是value的時(shí)候，調(diào)用方法時(shí)是把value拷貝一份作為第一個(gè)參數(shù)傳遞給callee的，這樣caller里對(duì)receiver的修改實(shí)際上是修改的拷貝，不影響原值。當(dāng)方法的receiver是pointer的時(shí)候，調(diào)用方法時(shí)是把pointer拷貝一份作為第一個(gè)參數(shù)傳遞給caller的，這樣callee可以通過這個(gè)pointer修改原值。
一點(diǎn)補(bǔ)充如果在方法里修改receiver的值要對(duì)caller生效，使用 pointer receiver
出于性能優(yōu)化，如果receiver是結(jié)構(gòu)體或者數(shù)組這樣占用較多內(nèi)存的數(shù)據(jù)類型，優(yōu)先使用pointer receiver
注意：值接收器是并發(fā)安全的，而指針接收器不是并發(fā)安全的。
調(diào)用規(guī)則：類型 T 的可調(diào)用方法集包含接受者為T 或 T 的所有方法集
類型 T 的可調(diào)用方法集包含接受者為 T 的所有方法
類型 T 的可調(diào)用方法集不包含接受者為 *T 的方法
方法的接收者與函數(shù)/方法的參數(shù)的比較：函數(shù)/方法的實(shí)參類型和形參類型必須一致，(在語法上)不能一個(gè)是pointer而另一個(gè)是value。
方法的接收者比較智能，如果是 pointer receiver，在值上也可以調(diào)用這個(gè)方法(編譯器會(huì)自動(dòng)插入從值取到指針的指令)。如果是 value receiver，那么當(dāng)在pointer上調(diào)用這個(gè)方法時(shí)，編譯器會(huì)自動(dòng)將pointer轉(zhuǎn)換為pointer所對(duì)應(yīng)的值。
匿名函數(shù)和閉包
匿名函數(shù)
匿名函數(shù)由一個(gè)不帶函數(shù)名的函數(shù)聲明和函數(shù)體組成，匿名函數(shù)可以賦值給變量，作為結(jié)構(gòu)體字段，或者在channel中傳遞。在底層實(shí)現(xiàn)中，實(shí)際上傳遞的是匿名函數(shù)的入口地址。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)
閉包
當(dāng)函數(shù)引用外部作用域的變量時(shí)，我們稱之為閉包。在底層實(shí)現(xiàn)上，閉包由函數(shù)地址和引用到的變量的地址組成，并存儲(chǔ)在一個(gè)結(jié)構(gòu)體里，在閉包被傳遞時(shí)，實(shí)際是該結(jié)構(gòu)體的地址被傳遞。因?yàn)闂系闹翟谠搸暮瘮?shù)退出后就失效了，因此閉包引用的外部作用域的變量會(huì)被分配到堆上。在以下的實(shí)現(xiàn)中，test()函數(shù)返回一個(gè)閉包賦值給f，實(shí)際是main里收到閉包結(jié)構(gòu)體(堆上)的地址，并保存在DX寄存器上，地址對(duì)應(yīng)的內(nèi)存值是閉包函數(shù)地址(函數(shù)地址取到寄存器之后，就可以通過 call 調(diào)用)，地址偏移8個(gè)字節(jié)(+8bytes)是變量x的的地址，在main里調(diào)用閉包函數(shù)f時(shí)，f內(nèi)部依然是通過讀取DX的值來得到變量x的地址。即main調(diào)用f雖然沒有傳遞參數(shù)也沒有返回值，但是他們卻共享了一個(gè)寄存器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
遞歸函數(shù)
從本質(zhì)上講遞歸函數(shù)與普通函數(shù)并無特殊之處，只是不斷調(diào)用自身，棧不斷增加而已。在 C 里面棧大小是固定的，因此需要關(guān)心棧溢出(Stack overflow)的問題。不過 Go 里面棧根據(jù)需要自動(dòng)擴(kuò)容，不需要擔(dān)心這個(gè)問題。
關(guān)于 defer 語句
defer與return
可以先看一下下面三個(gè)函數(shù)，嘗試推理函數(shù)的返回值：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 后的函數(shù)調(diào)用 在 return 語句之前執(zhí)行"這句話并不容易理解正確。實(shí)際上 return xxx 語句不是原子的，而是先將xxx寫入到 caller 為返回值分配的?？臻g，接著執(zhí)行 RET 指令這兩步操作。defer函數(shù)就是插入在 RET 指令前執(zhí)行。goroutine的控制結(jié)構(gòu)里有一張記錄defer表達(dá)式的表，編譯器在defer出現(xiàn)的地方插入了指令 call runtime.deferproc，它將defer的表達(dá)式記錄在表中。然后在函數(shù)返回之前依次從defer表中將表達(dá)式出棧執(zhí)行，這時(shí)插入的指令是call runtime.deferreturn。
defer 與閉包
defer 語句調(diào)用的函數(shù)的參數(shù)是在defer注冊(cè)時(shí)求值或復(fù)制的。因此局部變量作為參數(shù)傳遞給defer的函數(shù)語句后，后面對(duì)局部變量的修改將不再影響defer函數(shù)內(nèi)對(duì)該變量值的使用。但是defer函數(shù)里使用非參數(shù)傳入的外部函數(shù)的變量，將使用到該變量在外部函數(shù)生命周期內(nèi)最終的值。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
備注：內(nèi)存中棧從高地址空間向低地址空間增長(zhǎng)，棧頂比棧底的內(nèi)存地址小，分配?？臻g對(duì)應(yīng)的是 sp 值的減小。
寫值是從低地址往高地址寫，比如 SP 指向 0xff00，往棧里寫入一個(gè)字(8 字節(jié))，占用的是 0xff00 到 0xff07 這 8 個(gè)字節(jié)。
intel存儲(chǔ)字節(jié)的順序?yàn)樾《藘?yōu)先：即低有效字節(jié)存儲(chǔ)在內(nèi)存低地址中。
在IA-32和X86-64中，字長(zhǎng)定義為16位，dword(雙倍字)是 32 位，qword(四倍字)是64位。
生成匯編文件的方法使用 go tool compile -N -l -S go_file.go 生成
使用 go tool compile -N -l go_file.go編譯成二進(jìn)制文件，接著執(zhí)行 go tool objdump bin_name.o反匯編出代碼，可以通過 -s 指定函數(shù)名從而只反匯編特定函數(shù)：go tool objdump -s YOUR_FUNC_NAME bin_name.o
使用 go build -gcflags -S生成
注意：go tool compile 和 go build -gcflags -S 生成的是過程中的匯編，go tool objdump生成的是最終的機(jī)器碼的匯編。
總結(jié)
Go 語言完全使用棧來傳遞參數(shù)和返回值并由調(diào)用者負(fù)責(zé)清棧，通過棧傳遞返回值使得Go函數(shù)能支持多返回值，調(diào)用者清棧則可以實(shí)現(xiàn)可變參數(shù)的函數(shù)。Go 使用值傳遞的模式傳遞參數(shù)，因此傳遞數(shù)組和結(jié)構(gòu)體時(shí)，應(yīng)該盡量使用指針作為參數(shù)來避免大量數(shù)據(jù)拷貝從而提升性能。
Go 方法調(diào)用的時(shí)候是將接收者作為參數(shù)傳遞給了callee，接收者分值接收者和指針接收者。
當(dāng)傳遞匿名函數(shù)的時(shí)候，傳遞的實(shí)際上是函數(shù)的入口指針。當(dāng)使用閉包的時(shí)候，Go 通過逃逸分析機(jī)制將變量分配到堆內(nèi)存，變量地址和函數(shù)入口地址組成一個(gè)存在堆上的結(jié)構(gòu)體，傳遞閉包的時(shí)候，傳遞的就是這個(gè)結(jié)構(gòu)體的地址。
Go 的數(shù)據(jù)類型分為值類型和引用類型，但 Go 的參數(shù)傳遞是值傳遞。當(dāng)傳遞的是值類型的時(shí)候，是完全的拷貝，callee里對(duì)參數(shù)的修改不影響原值；當(dāng)傳遞的是引用類型的時(shí)候，callee里的修改會(huì)影響原值。
帶返回值的return語句對(duì)應(yīng)的是多條機(jī)器指令，首先是將返回值寫入到caller在棧上為返回值分配的空間，然后執(zhí)行ret指令。有defer語句的時(shí)候，defer語句里的函數(shù)就是插入到 ret 指令之前執(zhí)行。
參考和深入閱讀：
本文從這些文章中引用了代碼樣例和語句
查看原文
總結(jié)
以上是生活随笔為你收集整理的bmf mysql_bmf 的动态 - SegmentFault 思否的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 9 个基于JavaScript 和 CS
- 下一篇： 大数据Clickhouse(CK)