go 接口学习笔记

Posted 2022-03-30 lubanseven

---

这里是对接口在汇编层面上转换和实现的小结，详细了解可参考 Go 语言接口的原理

1. 类型转换：结构体到接口

1.1 结构体方法实现接口

package main

type Duck interface 
        Quack()


type Cat struct 
        Name string


//go:noinline
func (c Cat) Quack() 
        println(c.Name + " handsome")


func main() 
        var c Duck = CatName: "lubanseven"
        c.Quack()

将汇编实现分为三块：

1. 结构体初始化;
2. 结构体到接口类型转换;
3. 调用结构体方法;

1.1.1 结构体初始化

XORPS   X0, X0						;; X0 = 0
MOVUPS  X0, ""..autotmp_1+48(SP)			;; StringHeader(SP+48).Data = 0
LEAQ    go.string."lubanseven"(SB), AX			;; AX = &"lubanseven"
MOVQ    AX, ""..autotmp_1+48(SP)			;; StringHeader(SP+48).Data = AX = &"lubanseven"
MOVQ    $10, ""..autotmp_1+56(SP)			;; StringHeader(SP+56).Len = 10

示意图如下：

1.1.2 结构体到接口类型转换

LEAQ    go.itab."".Cat,"".Duck(SB), AX		;; AX = itab = &(go.itab."".Cat,"".Duck)
MOVQ    AX, (SP)				;; SP = AX
LEAQ    ""..autotmp_1+48(SP), AX		;; AX = StringHeader(SP+48).Data
MOVQ    AX, 8(SP)				;; SP + 8 = AX
CALL    runtime.convT2I(SB)			;; runtime.convT2I(SP, SP+8)

查看 runtime.convT2I 函数的实现：

func convT2I(tab *itab, elem unsafe.Pointer) (i iface) 
	t := tab._type
	if raceenabled 
		raceReadObjectPC(t, elem, getcallerpc(), funcPC(convT2I))
	
	if msanenabled 
		msanread(elem, t.size)
	
	x := mallocgc(t.size, t, true)
	typedmemmove(t, x, elem)
	i.tab = tab
	i.data = x
	return

runtime.convT2I 函数会返回 runtime.iface 结构体，该结构体表示包含方法的接口。其中，函数内通过获取的类型分配内存空间，并将 elem 指针指向的内容拷贝到堆中。

返回的 runtime.iface 结构体将放在栈上的 SP+16 ~ SP+32 处，分别表示 iface.tab 和 iface.data。

示意图如下：

1.1.3 调用结构体方法

MOVQ    16(SP), AX
MOVQ    24(SP), CX
MOVQ    AX, "".c+32(SP)
MOVQ    CX, "".c+40(SP)
MOVQ    "".c+32(SP), AX

MOVQ    24(AX), AX					;; AX = *AX + 24 = iface.tab.fun[0] = Cat.Quack()
MOVQ    "".c+40(SP), CX					;; CX = iface.data
MOVQ    CX, (SP)					;; SP = CX
CALL    AX						;; CX.Quack()

其中，MOVQ 24(AX), AX 表示将 iface.tab 中指向方法 Quack() 的指针赋给 AX。由于 Duck 接口只有一个 Quack 方法，因此这里 24(AX) 索引到的即是第一个方法指针。

最后，CALL AX 传递 (SP) 的结构体值，实现 Quack() 方法的调用。

示意图如下：

1.2 结构体指针方法实现接口

package main

type Duck interface 
        Quack()


type Cat struct 
        Name string


//go:noinline
func (c *Cat) Quack() 
        println(c.Name + " handsome")


func main() 
        var c Duck = &CatName: "lubanseven"
        c.Quack()

同样的，将汇编实现分为三块：

1. 结构体初始化;
2. 结构体到接口类型转换;
3. 调用结构体方法;

1.2.1 结构体初始化

LEAQ    type."".Cat(SB), AX				;; AX = &type."".Cat
MOVQ    AX, (SP)					;; SP = AX = &type."".Cat

CALL    runtime.newobject(SB)				;; SP + 8 = &Cat
MOVQ    8(SP), DI					;; DI = SP + 8
MOVQ    DI, ""..autotmp_2+16(SP)			;; SP + 16 = DI

MOVQ    $10, 8(DI)					;; *DI + 8 = StringHeader(DI.Name).Len = 10
LEAQ    go.string."lubanseven"(SB), AX			;; AX = &"lubanseven"
MOVQ    AX, (DI)					;; *DI = StringHeader(DI.Name).Data = AX

需要说明的是，LEAQ type."".Cat(SB), AX 将指向类型 Cat 的指针赋给 AX。runtime.newobject(SB) 创建结构体 Cat 的实例。通过 DI 寄存器对结构体变量赋值，注意字符串 string 的结构体实现是 StringHeader...。

示意图如下：

1.2.2 结构体到接口类型转换

MOVQ    ""..autotmp_2+16(SP), AX

LEAQ    go.itab.*"".Cat,"".Duck(SB), CX

MOVQ    CX, "".c+32(SP)
MOVQ    AX, "".c+40(SP)

结构体到接口类型的转换即转换为接口结构体 runtime.iface。其中，SP+32 表示 iface.tab，SP+40 表示 iface.data。SP+32 ~ SP+48 共同组成了接口结构体 runtime.iface，实现结构体 Cat 到接口类型的转换。

示意图如下：

1.2.3 调用指针接收者方法

MOVQ    "".c+32(SP), AX
MOVQ    24(AX), AX

MOVQ    "".c+40(SP), CX
MOVQ    CX, (SP)
CALL    AX

此例和 1.1.3 节类似，这里不加以描述了。

2. 类型转换：接口到结构体

除了结构体到接口的类型转换，go 也有接口到结构体类型的转换。通过类型断言可以实现，但类型断言背后做了些什么呢？

这里分空接口和非空接口两种情况查看接口到结构体类型转换。

2.1 非空接口

接口到结构体转换示例代码：

func main() 
	var c Duck = &CatName: "lubanseven"
	switch c.(type) 
	case *Cat:
		cat := c.(*Cat)
		cat.Quack()
	

从汇编代码看 Cat 结构体和接口结构体 runtime.iface 的创建过程类似，这里忽略。直接看最关键的接口类型到结构体类型的转换过程：

00079       LEAQ    go.itab.*"".Cat,"".Duck(SB), CX		;; CX = &(go.itab.*"".Cat,"".Duck)
00086       MOVQ    CX, "".c+56(SP)				;; SP + 56 = CX
00101       MOVQ    "".c+56(SP), CX				;; CX = SP + 56

00125       MOVL    16(CX), AX					;; AX = *CX + 16 = runtime.iface.itab.hash

00132       CMPL    AX, $593696792				;; if runtime.iface.itab.hash == $593696792 
00137       JEQ     141
00139       JMP     236

00176       MOVQ    "".c+64(SP), AX 				;; 		AX = &CatName: "lubanseven"
00205       MOVQ    AX, (SP)					;; 		SP = AX
00209       CALL    "".(*Cat).Quack(SB)				;; 		SP.Quack()
00214       JMP     216

00236       JMP     228						;;  else 
00228       JMP     230						;; 
00230       JMP     216						;;
00216       MOVQ    104(SP), BP					;; 		BP = SP + 104 
00221       ADDQ    $112, SP					;; 		SP = SP + 112
00225       RET							;; 

可以看到，类型转换实际上是通过比较 runtime.iface.itab.hash 和结构体 hash 判断类型是否相等，如果相等调用结构体，实现方法调用。如果不相等，则回收函数栈空间。

2.2 空接口

对于空接口类型转换，编译器省略了将结构体转换为 runtime.eface 的过程，从汇编代码上并未看到转换过程。和非空接口逻辑类似，空接口转换也需判断 hash 值，不过空接口的 hash 从 runtime.eface._type 获取。

3. 总结：

本篇学习笔记大致介绍了接口和结构体类型的互相转换过程，通过汇编代码分析转换的底层逻辑实现知其然，知其所以然。

---

芝兰生于空谷，不以无人而不芳。