Go interface 原理剖析 -- 類型轉換

hi, 大家好，我是 haohongfan。

可能你看過的 interface 剖析的文章比較多了，這些文章基本都是從彙編角度分析類型轉換或者動態轉發。不過隨着 Go 版本升級，對應的 Go 彙編也發生了巨大的變化，如果單從彙編角度去分析 interface 變的非常有難度，本篇文章我會從內存分配 + 彙編角度切入 interface，去了解 interface 的原理。

限於篇幅 interface 有關動態轉發和反射的內容，請關注後續的文章。本篇文章主要是關於類型轉換。

eface

iface

eface

func main() {
   var ti interface{}
   var a int = 100
   ti = a
   fmt.Println(ti)
}

這段最常見的代碼，現在提出一些問題：

如何查看 ti 是 eface 還是 iface ?
值 100 保存在哪裏了？
如何看 ti 的真實的值的類型？

大部分源碼分析都是從彙編入手來看的，這裏也把對應的彙編貼出來

0x0040 00064 (main.go:44)	MOVQ	$100, (SP)
0x0048 00072 (main.go:44)	CALL	runtime.convT64(SB)
0x004d 00077 (main.go:44)	MOVQ	8(SP), AX
0x0052 00082 (main.go:44)	MOVQ	AX, ""..autotmp_3+64(SP)
0x0057 00087 (main.go:44)	LEAQ	type.int(SB), CX
0x005e 00094 (main.go:44)	MOVQ	CX, "".ti+72(SP)
0x0063 00099 (main.go:44)	MOVQ	AX, "".ti+80(SP)

這段彙編有下面這些特點：

CALL runtime.convT64(SB)：將 100 作爲 runtime.convT64 的參數，該函數申請了一段內存，將 100 放入了這段內存裏
將類型 type.int 放入到 SP+72 的位置
將包含 100 的那塊內存的指針，放入到 SP + 80 的位置

這段彙編從直觀上來說，interface 轉換成 eface 是看不出來的。這個如何觀察呢？這個就需要藉助 gdb 了。

再繼續深究下，如何利用內存分佈來驗證是 eface 呢？需要另外再添加點代碼。

type eface struct {
    _type *_type
    data  unsafe.Pointer
}

type _type struct {
    size       uintptr
    ptrdata    uintptr // size of memory prefix holding all pointers
    hash       uint32
    tflag      tflag
    align      uint8
    fieldAlign uint8
    kind       uint8
    equal      func(unsafe.Pointer, unsafe.Pointer) bool
    gcdata     *byte
    str        nameOff
    ptrToThis  typeOff
}

func main() {
    var ti interface{}
    var a int = 100
    ti = a

    fmt.Println("type:", *(*eface)(unsafe.Pointer(&ti))._type)
    fmt.Println("data:", *(*int)((*eface)(unsafe.Pointer(&ti)).data))
    fmt.Println((*eface)(unsafe.Pointer(&ti)))
}

output:

type: {8 0 4149441018 15 8 8 2 0x10032e0 0x10e6b60 959 27232}
data: 100
&{0x10ade20 0x1155bc0}

從這個結果上能夠看出來

eface.kind = 2, 對應着 runtime.kindInt
eface.data = 100

從內存上分配上看，我們基本看出來了 eface 的內存佈局及對應的最終的 eface 的類型轉換結果。

iface

package main

type Person interface {
   Say() string
}

type Man struct {
}

func (m *Man) Say() string {
   return "Man"
}

func main() {
    var p Person

    m := &Man{}
    p = m
    println(p.Say())
}

iface 我們也看下彙編：

0x0029 00041 (main.go:24)	LEAQ	runtime.zerobase(SB), AX
0x0030 00048 (main.go:24)	MOVQ	AX, ""..autotmp_6+48(SP)
0x0035 00053 (main.go:24)	MOVQ	AX, "".m+32(SP)
0x003a 00058 (main.go:25)	MOVQ	AX, ""..autotmp_3+64(SP)
0x003f 00063 (main.go:25)	LEAQ	go.itab.*"".Man,"".Person(SB), CX
0x0046 00070 (main.go:25)	MOVQ	CX, "".p+72(SP)
0x004b 00075 (main.go:25)	MOVQ	AX, "".p+80(SP)

這段彙編上，能夠看出來是有 itab 的，但是是否真的是轉成了 iface，彙編上仍然反應不出來。

同樣，我們繼續用 gdb 查看 Person interface 確實被轉換成了 iface。

關於 iface 內存佈局，我們仍然加點代碼來查看

type itab struct {
    inter *interfacetype
    _type *_type
    hash  uint32
    _     [4]byte
    fun   [1]uintptr
}

type iface struct {
    tab  *itab
    data unsafe.Pointer
}

type Person interface {
    Say() string
}

type Man struct {
    Name string
}

func (m *Man) Say() string {
    return "Man"
}

func main() {
    var p Person

    m := &Man{Name: "hhf"}
    p = m
    println(p.Say())

    fmt.Println("itab:", *(*iface)(unsafe.Pointer(&p)).tab)
    fmt.Println("data:", *(*Man)((*iface)(unsafe.Pointer(&p)).data))
}

output:

Man
itab: {0x10b3ba0 0x10b1900 1224794265 [0 0 0 0] [17445152]}
data: {hhf}

關於想繼續探究 eface, iface 的內存佈局的同學，可以基於上面的代碼，利用 unsafe 的相關函數去看對應的內存位置上的值。

類型斷言

type Person interface {
   Say() string
}

type Man struct {
   Name string
}

func (m *Man) Say() string {
   return "Man"
}

func main() {
   var p Person

    m := &Man{Name: "hhf"}
    p = m

    if m1, ok := p.(*Man); ok {
      fmt.Println(m1.Name)
    }
}

我們僅關注類型斷言那塊內容，貼出對應的彙編

0x0087 00135 (main.go:23)	MOVQ	"".p+104(SP), AX
0x008c 00140 (main.go:23)	MOVQ	"".p+112(SP), CX
0x0091 00145 (main.go:23)	LEAQ	go.itab.*"".Man,"".Person(SB), DX
0x0098 00152 (main.go:23)	CMPQ	DX, AX

能夠看出來的是：將 iface.itab 放入了 AX，將 go.itab.*"".Man,"".Person(SB) 放入了 DX，比較兩者是否相等，來判斷 Person 的真實類型是否是 Man。

另外一個類型斷言的方式就是 switch 了，其實兩者本質上沒啥區別。

坑

interface 最著名的坑的，應該就是下面這個了。

func main() {
    var a interface{} = nil
    var b *int = nil
    
    isNil(a)
    isNil(b)
}

func isNil(x interface{}) {
    if x == nil {
      fmt.Println("empty interface")
      return
    }
    fmt.Println("non-empty interface")
}

output:

empty interface
non-empty interface

爲什麼會這樣呢？這就涉及到 interface == nil 的判斷方式了。一般情況只有 eface 的 type 和 data 都爲 nil 時，interface == nil 纔是 true。

當我們把 b 複製給 interface 時，x._type.Kind = kindPtr。雖說 x.data = nil，但是不符合 interface == nil 的判斷條件了。

關於 interface 源碼閱讀的一點建議

關於 interface 源碼閱讀的一點建議，如果想利用匯編看源碼的話，儘量選擇 go1.14.x。

選擇 Go 彙編來看 interface，基本上也是爲了查看 interface 最終被轉換成 eface 還是 iface，調用了 runtime 的哪些函數，以及對應的函數棧分佈。如果 Go 版本選擇的太高的話，go 彙編變化太大了，可能彙編上就看不到對應的內容了。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/lMvU80jhkabMvqXeTFiDnw

eface

iface

類型斷言

坑

關於 interface 源碼閱讀的一點建議

猜你喜歡