Researching the interface value in go - I found a great (maybe outdated) article by Russ Cox. According to it:

The itable begins with some metadata about the types involved and then becomes a list of function pointers.

The implementation for this itable should be the one from src/runtime/runtime2.go:

type itab struct {
    inter *interfacetype
    _type *_type
    hash  uint32 // copy of _type.hash. Used for type switches.
    _     [4]byte
    fun   [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
}

First confusing thing is - how is an array - variable sized? Second, assuming that we have a function pointer at index 0 for a method that satisfies the interface, where could we store a second/third/... function pointer?

CodePudding user response：

The compiled code and runtime access fun as if the field is declared fun [n]uintpr where n is the number of methods in the interface. The second method is stored at fun[1], the third at fun[2] and so on. The Go Language does not have a variable size array feature like this, but unsafe shenanigans can be used to simulate the feature.

Here's how itab is allocated:

m = (*itab)(persistentalloc(unsafe.Sizeof(itab{}) uintptr(len(inter.mhdr)-1)*goarch.PtrSize, 0, &memstats.other_sys))

The function persistentalloc allocates memory. The first argument to the function is the size to allocate. The expression inter.mhdr is the number of methods in the interface.

Here's code that creates a slice on the variable size array:

methods := (*[1 << 16]unsafe.Pointer)(unsafe.Pointer(&m.fun[0]))[:ni:ni]

The expression methods[i] refers to the same element as m.fun[i] in a hypothetical world where m.fun is a variable size array with length > i. Later code uses normal slice syntax with methods to access the variable size array m.fun.