Golang Interface Source Code Brief Look

Posted by Henry Du on Sunday, February 7, 2021

Golang Interface Source Code Brief Look

Based on go v1.13, there are two struct definition for go interface: eface and iface.

type eface struct {
	_type *_type
	data  unsafe.Pointer

type iface struct {
	tab  *itab
	data unsafe.Pointer


The eface represents the interface which does not have any method: interface{}.

The eface has two fields: _type and data. data is actually a pointer to point to real data. _type is defined as follows:

type _type struct {
	size       uintptr
	ptrdata    uintptr
	hash       uint32
	tflag      tflag
	align      uint8
	fieldalign uint8
	kind       uint8
	alg        *typeAlg
	gcdata     *btye
	str        nameOff
	ptrToThis  typeOff

_type is the real type of the concrete data stored inside interface.


The iface has two fields: tab and data. data is the pointer to point to real data. itab is defined as follows:

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

type interfacetype struct {
	typ     _type
	pkgpath name
	mhdr    []imethod

The interfacetype describe the interface own type. The _type is the type of concrete data, the same as the _type in eface. fun is the pointer to point the set of methods. It is used for Dynamic Dispatch.


All parameters passed by Go func are values. When a parameter passes to reflect.TypeOf(), it will be converted to interface{} type. If the passed value is interface type, the concrete data type will be stored in eface _type field. Then, cast eface struct into emptyInterface to have typ and word.

func TypeOf(i interface{}) Type {
	eface := *(emptyInterface)(unsafe.Poiter(&i))
	return toType(eface.typ)

type emptyInterface struct {
	typ  *rtype
	word unsafe.Pointer


reflect.Value is a struct defined as follows:

// Value is the reflection interface to a Go value.
// Not all methods apply to all kinds of values. Restrictions,
// if any, are noted in the documentation for each method.
// Use the Kind method to find out the kind of value before
// calling kind-specific methods. Calling a method
// inappropriate to the kind of type causes a run time panic.
// The zero Value represents no value.
// Its IsValid method returns false, its Kind method returns Invalid,
// its String method returns "<invalid Value>", and all other methods panic.
// Most functions and methods never return an invalid value.
// If one does, its documentation states the conditions explicitly.
// A Value can be used concurrently by multiple goroutines provided that
// the underlying Go value can be used concurrently for the equivalent
// direct operations.
// To compare two Values, compare the results of the Interface method.
// Using == on two Values does not compare the underlying values
// they represent.
type Value struct {
	// typ holds the type of the value represented by a Value.
	typ *rtype

	// Pointer-valued data or, if flagIndir is set, pointer to data.
	// Valid when either flagIndir is set or typ.pointers() is true.
	ptr unsafe.Pointer

	// flag holds metadata about the value.
	// The lowest bits are flag bits:
	//	- flagStickyRO: obtained via unexported not embedded field, so read-only
	//	- flagEmbedRO: obtained via unexported embedded field, so read-only
	//	- flagIndir: val holds a pointer to the data
	//	- flagAddr: v.CanAddr is true (implies flagIndir)
	// Value cannot represent method values.
	// The next five bits give the Kind of the value.
	// This repeats typ.Kind() except for method values.
	// The remaining 23+ bits give a method number for method values.
	// If flag.kind() != Func, code can assume that flagMethod is unset.
	// If ifaceIndir(typ), code can assume that flagIndir is set.

	// A method value represents a curried method invocation
	// like r.Read for some receiver r. The typ+val+flag bits describe
	// the receiver r, but the flag's Kind bits say Func (methods are
	// functions), and the top bits of the flag give the method number
	// in r's type's method table.
func ValueOf(i interface{}) Value {
    if i == nil {
        return Value{}


    return unpackEface(i)

func unpackEface(i interface{}) Value {
    e := (*emptyInterface)(unsafe.Pointer(&i))
    t := e.typ
    if t == nil {
        return Value{}
    f := flag(t.Kind())
    if ifaceIndir(t) {
        f |= flagIndir
    return Value{t, e.word, f}