[[416772]]

本文轉載自微信公眾號「腦子進煎魚了」，作者陳煎魚。轉載本文請聯系腦子進煎魚了公眾號。

大家好，我是煎魚。

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

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

func len(v Type) int 

看注解也沒有 link 到其他 runtime 函數，那么 len 函數是如何被調用的呢?

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

謎底

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

其實 Go 語言中并沒有 len 函數的具體實現代碼，他其實是 Go 編譯器的 "魔法" ，不是實際的函數調用。

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

編譯器

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

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

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

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

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

如果最后一個類型檢查階段遇到 len 函數，就會轉換為 UnaryExpr 類型，一個 UnaryExpr 節點代表一個單數表達式，也最終就是不會成為函數調用：

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) 
 } 
} 

在調用 *ir.UnaryExpr 轉換完畢后，會調用 tcLenCap，也就是 typecheck，使用 okforlen 數組來驗證參數的合法性或發出相關錯誤信息：

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 
} 

經歷過上面的步驟后在對所有內容進行類型檢查后，所有函數都將排隊等待編譯：

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() 

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

這塊的處理對應 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()) 
 } 

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

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

若是字典(map)類型或通道(channel)，將會調用 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) 
} 

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

那為什么要獲取結構體的第一個字段的值呢，應該是和 map 和 chan 的基礎數據結構有關：

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

是因為 map 和 chan 的基礎數據結構的第一個字段就表示長度，自然也就通過計算偏移值來獲取了。

其他的數據類型，大家可以繼續深入代碼，再細看就好了。主要還是枚舉多同類的數據類型，接著調用相應的方法。

總結

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

但需要注意，其實還有像 len 內置函數這種直接編譯器轉換的，這也是一種不錯的優化方式。