Go編譯原理之函數內聯怎么實現

這篇文章主要介紹“Go編譯原理之函數內聯怎么實現”，在日常操作中，相信很多人在Go編譯原理之函數內聯怎么實現問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Go編譯原理之函數內聯怎么實現”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

函數內聯概述

我們知道每一個高級編程語言的函數調用，成本都是在與需要為它分配棧內存來存儲參數、返回值、局部變量等等，Go的函數調用的成本在于參數與返回值棧復制、較小的棧寄存器開銷以及函數序言部分的檢查棧擴容（Go語言中的棧是可以動態擴容的，因為Go在分配棧內存不是逐漸增加的，而是一次性分配，這樣是為了避免訪問越界，它會一次性分配，當檢查到分配的棧內存不夠用時，它會擴容一個足夠大的棧空間，并將原來棧中的內容拷貝過來）

下邊寫一段代碼，通過Go的基準測試來測一下函數內聯帶來的效率提升

import "testing"
//go:noinline //禁用內聯。如果要開啟內聯，將該行注釋去掉即可
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}
var Result int
func BenchmarkMax(b *testing.B)  {
	var r int
	for i:=0; i< b.N; i++ {
		r = max(-1, i)
	}
	Result = r
}

在編譯的過程中，Go的編譯器其實會計算函數內聯花費的成本，所以只有簡單的函數，才會觸發函數內聯。在后邊函數內聯的源碼實現中，我們可以看到下邊這些情況不會被內聯：

• 遞歸函數

• 函數前有如下注釋的：go:noinline、go:norace、go:nocheckptr、go:uintptrescapes等

• 沒有函數體

• 函數聲明的抽象語法樹中節點數大于5000（我的Go版本是1.16.6）（也就是函數內部語句太多的情況，也不會被內聯）

• 函數中包含閉包（OCLOSURE）、range（ORANGE）、select（OSELECT）、go（OGO）、defer（ODEFER）、type（ODCLTYPE）、返回值是函數（ORETJMP）的，都不會內聯

我們也可以構建或編譯的時候，通過參數去控制它是否可以內聯。如果希望程序中所有的函數都不執行內聯操作

go build -gcflags="-l" xxx.go
go tool compile -l xxx.go

同樣我們在編譯時，也可以查看哪些函數內聯了，哪些函數沒內聯，以及原因是什么

go tool compile -m=2 xxx.go

看一個例子

package main
func test1(a, b int) int {
	return a+b
}
func step(n int) int {
	if n < 2 {
		return n
	}
	return step(n-1) + step(n-2)
}
func main()  {
	test1(1, 2)
	step(5)
}

可以看到test1這個函數是可以內聯的，因為它的函數體很簡單。step這個函數因為是遞歸函數，所以它不會進行內聯

函數內聯底層實現

這里邊其實每一個函數調用鏈都很深，我這里不會一行一行的解釋代碼的含義，僅僅會將一些核心的方法拿出來介紹一下，感興趣的小伙伴可以自己去調試一下(前邊有發相關文章)（Go源碼調試方法）

還是前邊提到多次的Go編譯入口文件，你可以在入口文件中找到這段代碼

Go編譯入口文件：src/cmd/compile/main.go -> gc.Main(archInit)
// Phase 5: Inlining
if Debug.l != 0 {
		// 查找可以內聯的函數
		visitBottomUp(xtop, func(list []*Node, recursive bool) {
			numfns := numNonClosures(list)
			for _, n := range list {
				if !recursive || numfns > 1 {
					caninl(n)
				} else {
					......
				}
				inlcalls(n)
			}
		})
	}
	for _, n := range xtop {
		if n.Op == ODCLFUNC {
			devirtualize(n)
		}
	}

下邊就看一下每個方法都在做哪些事情

visitBottomUp

該方法有兩個參數：

• xtop：前邊已經見過它了，它存放的是每個聲明語句的抽象語法樹的根節點數組

• 第二個參數是一個函數（該函數也有兩個參數，一個是滿足是函數類型聲明的抽象語法樹根節點數組，一個是bool值，true表示是遞歸函數，false表示不是遞歸函數）

進入到visitBottomUp方法中，你會發現它主要是遍歷xtop，并對每個抽象語法樹的根節點調用了visit這個方法（僅針對是函數類型聲明的抽象語法樹）

func visitBottomUp(list []*Node, analyze func(list []*Node, recursive bool)) {
	var v bottomUpVisitor
	v.analyze = analyze
	v.nodeID = make(map[*Node]uint32)
	for _, n := range list {
		if n.Op == ODCLFUNC && !n.Func.IsHiddenClosure() { //是函數，并且不是閉包函數
			v.visit(n)
		}
	}
}

而visit方法的核心是調用了inspectList方法，通過inspectList對抽象語法樹按照深度優先搜索進行遍歷，并將每一個節點作為inspectList方法的第二個參數（是一個函數）的參數，比如驗證這個函數里邊是否有遞歸調用等（具體就是下邊的switch case）

func (v *bottomUpVisitor) visit(n *Node) uint32 {
	if id := v.nodeID[n]; id > 0 {
		// already visited
		return id
	}
	......
	v.stack = append(v.stack, n)
	inspectList(n.Nbody, func(n *Node) bool {
		switch n.Op {
		case ONAME:
			if n.Class() == PFUNC {
				......
			}
		case ODOTMETH:
			fn := asNode(n.Type.Nname())
			......
			}
		case OCALLPART:
			fn := asNode(callpartMethod(n).Type.Nname())
			......
		case OCLOSURE:
			if m := v.visit(n.Func.Closure); m < min {
				min = m
			}
		}
		return true
	})
		v.analyze(block, recursive)
	}
	return min
}

后邊通過調用visitBottomUp的第二個參數傳遞的方法，對抽象語法樹進行內聯的判斷及內聯操作，具體就是caninl和inlcalls這兩個方法

caninl

該方法的作用就是驗證是函數類型聲明的抽象語法樹是否可以內聯

這個方法的實現很簡單，首先是通過很多的if語句驗證函數前邊是否有像go:noinline等這種標記

func caninl(fn *Node) {
	if fn.Op != ODCLFUNC {
		Fatalf("caninl %v", fn)
	}
	if fn.Func.Nname == nil {
		Fatalf("caninl no nname %+v", fn)
	}
	var reason string // reason, if any, that the function was not inlined
	......
	// If marked "go:noinline", don't inline
	if fn.Func.Pragma&Noinline != 0 {
		reason = "marked go:noinline"
		return
	}
	// If marked "go:norace" and -race compilation, don't inline.
	if flag_race && fn.Func.Pragma&Norace != 0 {
		reason = "marked go:norace with -race compilation"
		return
	}
	......
	// If fn has no body (is defined outside of Go), cannot inline it.
	if fn.Nbody.Len() == 0 {
		reason = "no function body"
		return
	}
	visitor := hairyVisitor{
		budget:        inlineMaxBudget,
		extraCallCost: cc,
		usedLocals:    make(map[*Node]bool),
	}
	if visitor.visitList(fn.Nbody) {
		reason = visitor.reason
		return
	}
	if visitor.budget < 0 {
		reason = fmt.Sprintf("function too complex: cost %d exceeds budget %d", inlineMaxBudget-visitor.budget, inlineMaxBudget)
		return
	}
	n.Func.Inl = &Inline{
		Cost: inlineMaxBudget - visitor.budget,
		Dcl:  inlcopylist(pruneUnusedAutos(n.Name.Defn.Func.Dcl, &visitor)),
		Body: inlcopylist(fn.Nbody.Slice()),
	}
	......
}

這里邊還有一個主要的方法就是visitList，它是用來驗證函數里邊是否有我們上邊提到的go、select、range等等這些語句。對于滿足內聯條件的，它會將改寫該函數聲明抽閑語法樹的內聯字段(Inl)

inlcalls

該方法中就是具體的內聯操作，比如將函數的參數和返回值轉換為調用者中的聲明語句等。里邊的調用和實現都比較復雜，這里不粘代碼了，大家可自行去看。函數內聯的核心方法都在如下文件中

src/cmd/compile/internal/gc/inl.go

到此，關于“Go編譯原理之函數內聯怎么實現”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！