[[416772]]

本文轉(zhuǎn)載自微信公眾號「腦子進煎魚了」，作者陳煎魚。轉(zhuǎn)載本文請聯(lián)系腦子進煎魚了公眾號。

大家好，我是煎魚。

最近看到了一個很有意思的話題，我們平時常常會用 Go 的內(nèi)置函數(shù) len 去獲取各種 map、slice 的長度，那他是怎么實現(xiàn)的呢?

正當我想去看看 len 的具體實現(xiàn)時，一展身手，卻發(fā)現(xiàn)竟然是個空方法：

func len(v Type) int 

看注解也沒有 link 到其他 runtime 函數(shù)，那么 len 函數(shù)是如何被調(diào)用的呢?

先前也做了一些筆記，在此分享給大家，共同進步。

謎底

今天就由煎魚帶大家一同解開這個謎底。既然是謎底，那就一開始就揭開。

其實 Go 語言中并沒有 len 函數(shù)的具體實現(xiàn)代碼，他其實是 Go 編譯器的 "魔法" ，不是實際的函數(shù)調(diào)用。

接下來將展開這部分，我們可以更深入地了解 Go 編譯器的內(nèi)部工作原理。

編譯器

在 Go 編譯器編譯時會解析命令行參數(shù)中指定的標志和 Go 源文件，對解析后的 Go 包進行類型檢查，將函數(shù)編譯為機器代碼。代碼，最后將編譯后的包定義寫到磁盤上。

內(nèi)部定義基本類型、內(nèi)置函數(shù)和操作函數(shù)的階段是在 types/universe.go 當中。同時會進行內(nèi)置函數(shù)和具體的操作符匹配，可以明確知道內(nèi)置函數(shù) len 對應(yīng)的是 OLEN：

var builtinFuncs = [...]struct { 
 name string 
 op   Op 
}{ 
 {"append", OAPPEND}, 
 {"cap", OCAP}, 
 {"close", OCLOSE}, 
 {"complex", OCOMPLEX}, 
 {"copy", OCOPY}, 
 {"delete", ODELETE}, 
 {"imag", OIMAG}, 
 {"len", OLEN}, 
 ... 
} 

在編譯時，上分為五個階段進行類型檢查：

• 第一階段：常量、類型、以及函數(shù)的名稱和類型。
• 第二階段：變量賦值、接口賦值、別名聲明。
• 第三階段：類型檢查函數(shù)體。
• 第四階段：檢查外部聲明。
• 第五階段：檢查類型的地圖鍵，未使用的導(dǎo)入。

如果最后一個類型檢查階段遇到 len 函數(shù)，就會轉(zhuǎn)換為 UnaryExpr 類型，一個 UnaryExpr 節(jié)點代表一個單數(shù)表達式，也最終就是不會成為函數(shù)調(diào)用：

func typecheck1(n ir.Node, top int) ir.Node { 
 if n, ok := n.(*ir.Name); ok { 
  typecheckdef(n) 
 } 
 
 switch n.Op() { 
 ... 
 case ir.OCAP, ir.OLEN: 
  n := n.(*ir.UnaryExpr) 
  return tcLenCap(n) 
 } 
} 

在調(diào)用 *ir.UnaryExpr 轉(zhuǎn)換完畢后，會調(diào)用 tcLenCap，也就是 typecheck，使用 okforlen 數(shù)組來驗證參數(shù)的合法性或發(fā)出相關(guān)錯誤信息：

func tcLenCap(n *ir.UnaryExpr) ir.Node { 
 n.X = Expr(n.X) 
 n.X = DefaultLit(n.X, nil) 
 n.X = implicitstar(n.X) 
 ... 
 var ok bool 
 if n.Op() == ir.OLEN { 
  ok = okforlen[t.Kind()] 
 } else { 
  ok = okforcap[t.Kind()] 
 } 
   
 ... 
 n.SetType(types.Types[types.TINT]) 
 return n 
} 

經(jīng)歷過上面的步驟后在對所有內(nèi)容進行類型檢查后，所有函數(shù)都將排隊等待編譯：

base.Timer.Start("be", "compilefuncs") 
fcount := int64(0) 
for i := 0; i < len(typecheck.Target.Decls); i++ { 
 if fn, ok := typecheck.Target.Decls[i].(*ir.Func); ok { 
  enqueueFunc(fn) 
  fcount++ 
 } 
} 
base.Timer.AddEvent(fcount, "funcs") 
 
compileFunctions() 

在經(jīng)過在 buildssa 和 genssa 之后，再深入幾層，就會將 AST 樹中的 len 表達式轉(zhuǎn)換為 SSA。接著我們就可以看到 Go 語言中的每種類型的長度是怎么獲取的。

這塊的處理對應(yīng) internal/ssagen/ssa.go 的 expr 方法，如下：

case ir.OLEN, ir.OCAP: 
 n := n.(*ir.UnaryExpr) 
 switch { 
 case n.X.Type().IsSlice(): 
  op := ssa.OpSliceLen 
  if n.Op() == ir.OCAP { 
   op = ssa.OpSliceCap 
  } 
  return s.newValue1(op, types.Types[types.TINT], s.expr(n.X)) 
 case n.X.Type().IsString(): // string; not reachable for OCAP 
  return s.newValue1(ssa.OpStringLen, types.Types[types.TINT], s.expr(n.X)) 
 case n.X.Type().IsMap(), n.X.Type().IsChan(): 
  return s.referenceTypeBuiltin(n, s.expr(n.X)) 
 default: // array 
  return s.constInt(types.Types[types.TINT], n.X.Type().NumElem()) 
 } 

若是數(shù)組(array)類型，則會調(diào)用 NumElem 方法來獲取長度值：

type Array struct { 
 Elem  *Type  
 Bound int64  
} 
 
func (t *Type) NumElem() int64 { 
 t.wantEtype(TARRAY) 
 return t.Extra.(*Array).Bound 
} 

若是字典(map)類型或通道(channel)，將會調(diào)用 referenceTypeBuiltin 方法：

func (s *state) referenceTypeBuiltin(n *ir.UnaryExpr, x *ssa.Value) *ssa.Value { 
 lenType := n.Type() 
 nilValue := s.constNil(types.Types[types.TUINTPTR]) 
 cmp := s.newValue2(ssa.OpEqPtr, types.Types[types.TBOOL], x, nilValue) 
 b := s.endBlock() 
 b.Kind = ssa.BlockIf 
 b.SetControl(cmp) 
 b.Likely = ssa.BranchUnlikely 
 
 bThen := s.f.NewBlock(ssa.BlockPlain) 
 bElse := s.f.NewBlock(ssa.BlockPlain) 
 bAfter := s.f.NewBlock(ssa.BlockPlain) 
 ... 
 switch n.Op() { 
 case ir.OLEN: 
  s.vars[n] = s.load(lenType, x) 
 ... 
 return s.variable(n, lenType) 
} 

該函數(shù)的作用是是獲取 map 或chan 的內(nèi)存地址，并以零偏移量引用其結(jié)構(gòu)布局，就像 unsafe.Pointer(uintptr(unsafe.Pointer(s)) 一樣，返回第一個字面字段的值。

那為什么要獲取結(jié)構(gòu)體的第一個字段的值呢，應(yīng)該是和 map 和 chan 的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)有關(guān)：

type hmap struct { 
 count     int  
  ... 
} 
 
type hchan struct { 
 qcount   uint     
 ... 
} 

是因為 map 和 chan 的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)的第一個字段就表示長度，自然也就通過計算偏移值來獲取了。

其他的數(shù)據(jù)類型，大家可以繼續(xù)深入代碼，再細看就好了。主要還是枚舉多同類的數(shù)據(jù)類型，接著調(diào)用相應(yīng)的方法。

總結(jié)

每次我們看到內(nèi)置函數(shù)時，總會下意識的以為是在 runtime 內(nèi)實現(xiàn)的?？床坏?runtime 內(nèi)的實現(xiàn)方法，又會以為是通過注解 link 的方式來解決的。

但需要注意，其實還有像 len 內(nèi)置函數(shù)這種直接編譯器轉(zhuǎn)換的，這也是一種不錯的優(yōu)化方式。