We have already looked at the source code of iface
and eface
, and we know that iface
the most important ones are itab
and _type
.
In order to study clearly how the interface is constructed, next I will pick up the weapon of assembly and restore the truth behind it.
Let’s look at a sample code:
package main
import "fmt"
type Person interface {
growUp()
}
type Student struct {
age int
}
func (p Student) growUp() {
p.age += 1
return
}
func main() {
var qcrao = Person(Student{age: 18})
fmt.Println(qcrao)
}
Excuting an order:
go tool compile -S main.go
The assembly code of the main function is as follows:
0x0000 00000 (./src/main.go:30) TEXT "".main(SB), $80-0
0x0000 00000 (./src/main.go:30) MOVQ (TLS), CX
0x0009 00009 (./src/main.go:30) CMPQ SP, 16(CX)
0x000d 00013 (./src/main.go:30) JLS 157
0x0013 00019 (./src/main.go:30) SUBQ $80, SP
0x0017 00023 (./src/main.go:30) MOVQ BP, 72(SP)
0x001c 00028 (./src/main.go:30) LEAQ 72(SP), BP
0x0021 00033 (./src/main.go:30) FUNCDATA$0, gclocals·69c1753bd5f81501d95132d08af04464(SB)
0x0021 00033 (./src/main.go:30) FUNCDATA$1, gclocals·e226d4ae4a7cad8835311c6a4683c14f(SB)
0x0021 00033 (./src/main.go:31) MOVQ $18, ""..autotmp_1+48(SP)
0x002a 00042 (./src/main.go:31) LEAQ go.itab."".Student,"".Person(SB), AX
0x0031 00049 (./src/main.go:31) MOVQ AX, (SP)
0x0035 00053 (./src/main.go:31) LEAQ ""..autotmp_1+48(SP), AX
0x003a 00058 (./src/main.go:31) MOVQ AX, 8(SP)
0x003f 00063 (./src/main.go:31) PCDATA $0, $0
0x003f 00063 (./src/main.go:31) CALL runtime.convT2I64(SB)
0x0044 00068 (./src/main.go:31) MOVQ 24(SP), AX
0x0049 00073 (./src/main.go:31) MOVQ 16(SP), CX
0x004e 00078 (./src/main.go:33) TESTQ CX, CX
0x0051 00081 (./src/main.go:33) JEQ 87
0x0053 00083 (./src/main.go:33) MOVQ 8(CX), CX
0x0057 00087 (./src/main.go:33) MOVQ $0, ""..autotmp_2+56(SP)
0x0060 00096 (./src/main.go:33) MOVQ $0, ""..autotmp_2+64(SP)
0x0069 00105 (./src/main.go:33) MOVQ CX, ""..autotmp_2+56(SP)
0x006e 00110 (./src/main.go:33) MOVQ AX, ""..autotmp_2+64(SP)
0x0073 00115 (./src/main.go:33) LEAQ ""..autotmp_2+56(SP), AX
0x0078 00120 (./src/main.go:33) MOVQ AX, (SP)
0x007c 00124 (./src/main.go:33) MOVQ $1, 8(SP)
0x0085 00133 (./src/main.go:33) MOVQ $1, 16(SP)
0x008e 00142 (./src/main.go:33) PCDATA $0, $1
0x008e 00142 (./src/main.go:33) CALL fmt.Println(SB)
0x0093 00147 (./src/main.go:34) MOVQ 72(SP), BP
0x0098 00152 (./src/main.go:34) ADDQ $80, SP
0x009c 00156 (./src/main.go:34) RET
0x009d 00157 (./src/main.go:34) NOP
0x009d 00157 (./src/main.go:30) PCDATA $0, $-1
0x009d 00157 (./src/main.go:30) CALL runtime.morestack_noctxt(SB)
0x00a2 00162 (./src/main.go:30) JMP 0
Let’s start from line 10. If you don’t understand the previous lines of assembly code, you can go back and read the previous two articles on the official account, which I will omit here.
number of assembly lines | operate |
---|---|
10-14 | runtime.convT2I64(SB) Parameters for the constructor call |
Let’s take a look at the parameter form of this function:
func convT2I64(tab *itab, elem unsafe.Pointer) (i iface) {
// ……
}
convT2I64
One will be constructed inteface
, which is our Person
interface.
The location of the first parameter is (SP)
assigned go.itab."".Student,"".Person(SB)
the address of .
From the generated assembly we find:
go.itab."".Student,"".Person SNOPTRDATA dupok size=40
0x0000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x0010 00 00 00 00 00 00 00 00 da 9f 20 d4
rel 0+8 t=1 type."".Person+0
rel 8+8 t=1 type."".Student+0
size=40
The size is 40 bytes, to recap:
type itab struct {
inter *interfacetype // 8字节
_type *_type // 8字节
link *itab // 8字节
hash uint32 // 4字节
bad bool // 1字节
inhash bool // 1字节
unused [2]byte // 2字节
fun [1]uintptr // variable sized // 8字节
}
Adding up the sizes of each field, itab
the size of the structure is 40 bytes. The string of numbers above is actually itab
the serialized content. Notice that most of the numbers are 0, and the 4 bytes starting from 24 bytes da 9f 20 d4
are actually the value itab
of hash
, which is used when judging whether two types are the same arrive.
The following two lines are link instructions. Simply put, they combine all source files and assign a global position value to each symbol. The meaning here is also relatively clear: the first 8 bytes ultimately store the type."".Person
address of , corresponding to the field itab
in inter
, indicating the interface type; the 8-16 bytes ultimately store type."".Student
the address of , corresponding to the field itab
in _type
, indicating the specific type.
The second parameter is relatively simple. It is 18
the address of the number, which is also Student
used when initializing the structure.
number of assembly lines | operate |
---|---|
15 | transferruntime.convT2I64(SB) |
Take a look at the code specifically:
func convT2I64(tab *itab, elem unsafe.Pointer) (i iface) {
t := tab._type
//...
var x unsafe.Pointer
if *(*uint64)(elem) == 0 {
x = unsafe.Pointer(&zeroVal[0])
} else {
x = mallocgc(8, t, false)
*(*uint64)(x) = *(*uint64)(elem)
}
i.tab = tab
i.data = x
return
}
This piece of code is relatively simple, assigning to tab
the field iface
of tab
; data
part of it is to apply for a piece of memory on the heap, and then copy the elem
pointed to. 18
This iface
is it.
number of assembly lines | operate |
---|---|
17 | assign i.tab toCX |
18 | assign i.data toAX |
19-21 | Check i.tab whether is nil. If not, move CX by 8 bytes, that is, assign the field itab of _type CX to CX. This is also the entity type of the interface and will eventually be used as fmt.Println a parameter of the function. |
Later, there is the calling fmt.Println
function and the previous parameter preparation work, so I won’t go into details.
In this way, we have interface
finished the construction process of a .
[Extension 1]
How to print out Hash
the value of the interface type?
Here is a reference to an article translated by Cao Dashen, which will be written in the reference materials. The specific steps are as follows:
type iface struct {
tab *itab
data unsafe.Pointer
}
type itab struct {
inter uintptr
_type uintptr
link uintptr
hash uint32
_ [4]byte
fun [1]uintptr
}
func main() {
var qcrao = Person(Student{age: 18})
iface := (*iface)(unsafe.Pointer(&qcrao))
fmt.Printf("iface.tab.hash = %#x\n", iface.tab.hash)
}
Define a 山寨版
and iface
, itab
saying it 山寨
is because itab
some key data structures in are not expanded specifically. For example _type
, you can find out by comparing the authentic definitions, but 山寨版
it can still work, because _type
is just a pointer.
In main
the function, first construct an interface object qcrao
, then force type conversion, and finally read hash
the value, which is very good! You can also try it yourself.
operation result:
iface.tab.hash = 0xd4209fda
It is worth mentioning that qcrao
when constructing the interface, even if I age
write it as other values, the obtained hash
value will still remain unchanged. This should be expected. hash
The value is only related to its fields and methods.