some_type = firstmoduledata.typelinks.parsed_types[0x1747fe0]

#moduledata.py
    def parse_typelink(self):
        self.rtypes = {}
        for addr in self.typelinks.parsed_types.keys():
            rtype = self.typelinks.parsed_types[addr]
            kind = rtype.get_kind()
            if kind not in self.rtypes.keys():
                self.rtypes[kind] = {}
            self.rtypes[kind][rtype.name_str] = rtype

firstmoduledata.typelinks.parse_type(addr)

def show_struct(self):
    struct_info = "type %s struct{" % self.name_str
    for field in self.fields:
        field_info = "\n\t%s %s offset %d" % (field.field_name.get_name(),field.type.name_str,field.offset)
        struct_info += field_info
    struct_info += "\n}"
    print(struct_info)

#typelink.py#StructType
    def generate_struct(self):
        field_infos = []
        for field in self.fields:
            name = field.field_name.get_name()
            name = name.replace('#','').replace('.','_').replace('*',"_ptr_")
            offset = field.offset
            nbytes = field.type.size
            if field.type.name_str == '#string':
                field_info_addr = {"name":name+"_addr","offset":offset,"nbytes":8}
                field_info_len = {"name":name+"_len","offset":offset+8,"nbytes":8}
                field_infos.append(field_info_addr)
                field_infos.append(field_info_len)
            else:
                field_info = {"name":name,"offset":offset,"nbytes":nbytes}
                field_infos.append(field_info)
        fields_num = len(field_infos)
        struct_name = self.name_str.replace('#','').replace('.','_').replace('*',"_ptr_")
        idx = ida_struct.add_struc(idaapi.BADADDR,struct_name,False)
        struc = ida_struct.get_struc(idx)
        for i in range(fields_num):
            if i < fields_num-1:
                if field_infos[i]['nbytes'] != field_infos[i+1]['offset']-field_infos[i]['offset']:
                    print("%s type size(0x%x) is not equal its size(0x%x) in struct,offset is 0x%x" % (field_infos[i]['name'],field_infos[i]['nbytes'],field_infos[i+1]['offset']-field_infos[i]['offset'],field_infos[i]['offset']))
                    field_infos[i]['nbytes'] = field_infos[i+1]['offset']-field_infos[i]['offset']
            ida_struct.add_struc_member(struc,field_infos[i]['name'],field_infos[i]['offset'],ida_bytes.FF_DATA,None,field_infos[i]['nbytes'])

//runtime\malloc.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.
}

//runtime\runtime2.go
type iface struct {
    tab  *itab
    data unsafe.Pointer
}

//runtime\malloc.go T2I应该是Type to Interface
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
}

package main

import (
    "fmt"
)

type Person struct {
    name string
    age  int
}

type iPerson interface {
    compare(Person) bool
}

func (p *Person) init(name string, age int) error {
    fmt.Println("Person init")
    p.name = name
    p.age = age
    return nil
}

func (p *Person) compare(b Person) bool {
    if p.age > b.age {
        return true
    } else {
        return false
    }
}

func main() {
    var p Person
    var iperson iPerson
    p.init("aaa", 18)
    iperson = p
    iperson.compare(p)
}

Person does not implement iPerson (compare method has pointer receiver)
cannot use p (variable of type Person) as iPerson value in assignment: missing method compare (compare has pointer receiver)compilerInvalidIfaceAssign

func (p Person) compare(b Person) bool {
    if p.age > b.age {
        return true
    } else {
        return false
    }
}

#生成IDA结构体
person.generate_struct()

var_68= qword ptr -68h
var_60= qword ptr -60h
var_58= qword ptr -58h
var_50= qword ptr -50h
var_38= qword ptr -38h
var_30= xmmword ptr -30h
var_20= qword ptr -20h
var_18= qword ptr -18h
var_10= qword ptr -10h
var_8= qword ptr -8

sub     rsp, 68h
mov     [rsp+68h+var_8], rbp
lea     rbp, [rsp+68h+var_8]
;var_38就是main函数中的变量p，p是Person结构体，占内存空间0x18，下面就是清空了0x18字节的内存。
mov     [rsp+68h+var_38], 0
xorps   xmm0, xmm0
movups  [rsp+68h+var_30], xmm0
;上述代码相当于var p Person,首地址是var_38
lea     rax, [rsp+68h+var_38]   ;rax = &p,因为init函数的接收者类型是*Person
mov     [rsp+68h+var_68], rax
lea     rax, aAaa       ; "aaa"
mov     [rsp+68h+var_60], rax
mov     [rsp+68h+var_58], 3
mov     [rsp+68h+var_50], 12h
;上述类似于从右往左传入参数，只是这里是先空留出的栈空间再赋值的，而不是通过push操作完成。
call    main___ptr_Person__init 
;等同于main___ptr_Person__init(rax,"aaa",3,0x12)
;接收者作为第一个参数，"aaa"和3是golang内的string类型表示，字符串+长度，0x12即18
;因此go代码就是p.init("aaa", 18)
mov     rax, [rsp+68h+var_38]
mov     rcx, qword ptr [rsp+68h+var_30]
mov     rdx, qword ptr [rsp+68h+var_30+8]
mov     [rsp+68h+var_20], rax
mov     [rsp+68h+var_18], rcx
mov     [rsp+68h+var_10], rdx
;将var_38的Person数据存储到var_20处
lea     rax, go_itab_main_Person_main_iPerson ;itab结构体
mov     [rsp+68h+var_68], rax
lea     rax, [rsp+68h+var_20];Person结构体
mov     [rsp+68h+var_60], rax
call    runtime_convT2I
;等同于runtime_convT2I(*itab,*Person),该函数见上文
;将var_20出的Person转换为接口iPerson
;拷贝var_38的值到var_20，以及执行runtime_convT2I等于golang代码:iperson = p
mov     rax, [rsp+68h+var_58]
mov     rcx, [rsp+68h+var_50]
;var_58和var_50是返回值，即iperson，结构体是iface，var_58指向itab,var_50指向mallocgc申请的内存空间中
mov     rdx, [rsp+68h+var_38]
mov     rbx, qword ptr [rsp+68h+var_30]
mov     rsi, qword ptr [rsp+68h+var_30+8]
mov     rax, [rax+18h]
;根据iface.itab的偏移量来获取*Person对接口中某个函数的具体实现，可以看下文截图，这里rax指向了(*Person).compare
mov     [rsp+68h+var_68], rcx
;rcx指向的是iface.data，是一个unsafe.Pointer,即指向的Person结构体数据，是接口iperson的
mov     [rsp+68h+var_60], rdx
mov     [rsp+68h+var_58], rbx
mov     [rsp+68h+var_50], rsi
;rdx、rbx、rsi即指向的p的Person结构体数据
call    rax
;执行compare函数
mov     rbp, [rsp+68h+var_8]
add     rsp, 68h
retn

//src\runtime\runtime2.go
type eface struct {
    _type *_type
    data  unsafe.Pointer
}

package main

import "fmt"

func test_interface(arg interface{}) {
    switch v := arg.(type) {
    case int:
        fmt.Printf("arg is int:%d\n", arg)
    case string:
        fmt.Printf("arg is string:%s\n", arg)
    default:
        fmt.Println(v)
    }
    if data, ok := arg.(string); ok {
        fmt.Println("convert to string:" + data)
    }
}

func main() {
    a := 1
    test_interface(a)
    test_interface("aaa")
    var p [3]int = [3]int{1, 2, 3}
    test_interface(p)
}

//src\runtime\iface.go
func convT64(val uint64) (x unsafe.Pointer) {
    if val < uint64(len(staticuint64s)) {
        x = unsafe.Pointer(&staticuint64s[val])
    } else {
        x = mallocgc(8, uint64Type, false)
        *(*uint64)(x) = val
    }
    return
}

func convT2Enoptr(t *_type, elem unsafe.Pointer) (e eface) {
    if raceenabled {
        raceReadObjectPC(t, elem, getcallerpc(), funcPC(convT2Enoptr))
    }
    if msanenabled {
        msanread(elem, t.size)
    }
    x := mallocgc(t.size, t, false)
    memmove(x, elem, t.size)
    e._type = t
    e.data = x
    return
}

//go 1.18.1
//src\runtime\symtab.go
type moduledata struct {
    pcHeader     *pcHeader
    funcnametab  []byte
    cutab        []uint32
    filetab      []byte
    pctab        []byte
    pclntable    []byte
    ftab         []functab
    findfunctab  uintptr
    minpc, maxpc uintptr

    text, etext           uintptr
    noptrdata, enoptrdata uintptr
    data, edata           uintptr
    bss, ebss             uintptr
    noptrbss, enoptrbss   uintptr
    end, gcdata, gcbss    uintptr
    types, etypes         uintptr
    rodata                uintptr
    gofunc                uintptr // go.func.*

    textsectmap []textsect
    typelinks   []int32 // offsets from types
    itablinks   []*itab

    ptab []ptabEntry

    pluginpath string
    pkghashes  []modulehash

    modulename   string
    modulehashes []modulehash

    hasmain uint8 // 1 if module contains the main function, 0 otherwise

    gcdatamask, gcbssmask bitvector

    typemap map[typeOff]*_type // offset to *_rtype in previous module

    bad bool // module failed to load and should be ignored

    next *moduledata
}

//go 1.18.1
//src\runtime\symtab.go
type pcHeader struct {
    magic          uint32  // 0xFFFFFFF0
    pad1, pad2     uint8   // 0,0
    minLC          uint8   // min instruction size
    ptrSize        uint8   // size of a ptr in bytes
    nfunc          int     // number of functions in the module
    nfiles         uint    // number of entries in the file tab
    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
    cuOffset       uintptr // offset to the cutab variable from pcHeader
    filetabOffset  uintptr // offset to the filetab variable from pcHeader
    pctabOffset    uintptr // offset to the pctab variable from pcHeader
    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
}

//go 1.18.1
//src\runtime\symtab.go
type functab struct {
    entryoff uint32 // relative to runtime.text
    funcoff  uint32
}

//go 1.18.1
//src\runtime\runtime2.go
type _func struct {
    entryoff uint32 // start pc, as offset from moduledata.text/pcHeader.textStart
    nameoff  int32  // function name

    args        int32  // in/out args size
    deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any.

    pcsp      uint32
    pcfile    uint32
    pcln      uint32
    npcdata   uint32
    cuOffset  uint32 // runtime.cutab offset of this function's CU
    funcID    funcID // set for certain special runtime functions
    flag      funcFlag
    _         [1]byte // pad
    nfuncdata uint8   // must be last, must end on a uint32-aligned boundary
}

//go 1.18.1
//src\runtime\symtab.go
type funcFlag uint8

const (
    // TOPFRAME indicates a function that appears at the top of its stack.
    // The traceback routine stop at such a function and consider that a
    // successful, complete traversal of the stack.
    // Examples of TOPFRAME functions include goexit, which appears
    // at the top of a user goroutine stack, and mstart, which appears
    // at the top of a system goroutine stack.
    funcFlag_TOPFRAME funcFlag = 1 << iota

    // SPWRITE indicates a function that writes an arbitrary value to SP
    // (any write other than adding or subtracting a constant amount).
    // The traceback routines cannot encode such changes into the
    // pcsp tables, so the function traceback cannot safely unwind past
    // SPWRITE functions. Stopping at an SPWRITE function is considered
    // to be an incomplete unwinding of the stack. In certain contexts
    // (in particular garbage collector stack scans) that is a fatal error.
    funcFlag_SPWRITE

    // ASM indicates that a function was implemented in assembly.
    funcFlag_ASM
)

//go 1.18.1
//src\reflect\type.go
// name is an encoded type name with optional extra data.
//
// The first byte is a bit field containing:
//
//  1<<0 the name is exported
//  1<<1 tag data follows the name
//  1<<2 pkgPath nameOff follows the name and tag
//
// Following that, there is a varint-encoded length of the name,
// followed by the name itself.
//
// If tag data is present, it also has a varint-encoded length
// followed by the tag itself.
//
// If the import path follows, then 4 bytes at the end of
// the data form a nameOff. The import path is only set for concrete
// methods that are defined in a different package than their type.
//
// If a name starts with "*", then the exported bit represents
// whether the pointed to type is exported.
//
// Note: this encoding must match here and in:
//   cmd/compile/internal/reflectdata/reflect.go
//   runtime/type.go
//   internal/reflectlite/type.go
//   cmd/link/internal/ld/decodesym.go

type name struct {
    bytes *byte
}