//go 1.16.8
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



    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
}

#moduledata.py
self.pcHeader = pcHeader.pcHeader(self.pcHeader_addr,self.start_addr)
self.typelinks = typelink.TypeLinks(start_addr+ptrSize*40,self)
self.itablinks = itablink.ItabLinks(start_addr+ptrSize*43,self)

//go 1.16.8
type pcHeader struct {
    magic          uint32  // 0xFFFFFFFA
    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.
    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 varible from pcHeader
    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
}

git diff remotes/origin/release-branch.go1.15 master -- src/debug/gosym/pclntab.go

moduledata.funcnametab.addr = pcHeader.start_addr + pcHeader.funcnameOffset
moduledata.cutab.addr = pcHeader.start_addr + pcHeader.cuOffset
moduledata.filetab.addr = pcHeader.start_addr + pcHeader.filetabOffset
moduledata.pctab.addr = pcHeader.start_addr + pcHeader.pctabOffset
moduledata.pclntable.addr = pcHeader.start_addr + pcHeader.pclnOffset
moduledata.ftab.addr = pcHeader.start_addr + pcHeader.pclnOffset

//src\runtime\symtab.go
type functab struct {
    entry   uintptr
    funcoff uintptr
}

type funcInfo struct {
    *_func
    datap *moduledata
}

//src\runtime\runtime2.go
type _func struct {
    entry   uintptr // start pc
    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
    _         [2]byte // pad
    nfuncdata uint8   // must be last
}

#func.py
self.funcname = idc.get_strlit_contents(pcheader.funcname_addr+self.nameoff)

//src\runtime\symtab.go
func cfuncname(f funcInfo) *byte {
    if !f.valid() || f.nameoff == 0 {
        return nil
    }
    return &f.datap.funcnametab[f.nameoff]
}

func funcname(f funcInfo) string {
    return gostringnocopy(cfuncname(f))
}

//src\runtime\string.go
func gostringnocopy(str *byte) string {
    ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
    s := *(*string)(unsafe.Pointer(&ss))
    return s
}


//src\runtime\symtab.go
//另一个单独指定nameoff读取funcname的方法
func cfuncnameFromNameoff(f funcInfo, nameoff int32) *byte {
    if !f.valid() {
        return nil
    }
    return &f.datap.funcnametab[nameoff]
}

#common.py
def read_pcvalue(addr):
    val = read_varint(addr)
    val = zig_zag_decode(val)
    val += -1
    return val

def read_varint(addr):
    val = 0
    shitf = 0
    while True:
        tmp = ida_bytes.get_byte(addr)
        addr += 1
        val |= (tmp&0x7f) << (shitf & 31)
        if tmp & 0x80 ==0:
            break
        shitf += 7
    return val

def int32(val:int):
    return int.from_bytes((val&0xffffffff).to_bytes(4,'little'),'little',signed=True)

def uint32(val:int):
    return int.from_bytes((val&0xffffffff).to_bytes(4,'little'),'little',signed=False)

def zig_zag_decode(val):
    return int32(-(val&1) ^ (val>>1))

def zig_zag_encode(val):
    return (val<<1) ^ (val>>31)

//src\runtime\symtab.go
func pcvalue(f funcInfo, off uint32, targetpc uintptr, cache *pcvalueCache, strict bool) (int32, uintptr) {
    if off == 0 {
        return -1, 0
    }

    // Check the cache. This speeds up walks of deep stacks, which
    // tend to have the same recursive functions over and over.
    //
    // This cache is small enough that full associativity is
    // cheaper than doing the hashing for a less associative
    // cache.
    if cache != nil {
        x := pcvalueCacheKey(targetpc)
        for i := range cache.entries[x] {
            // We check off first because we're more
            // likely to have multiple entries with
            // different offsets for the same targetpc
            // than the other way around, so we'll usually
            // fail in the first clause.
            ent := &cache.entries[x][i]
            if ent.off == off && ent.targetpc == targetpc {
                return ent.val, 0
            }
        }
    }

    if !f.valid() {
        if strict && panicking == 0 {
            print("runtime: no module data for ", hex(f.entry), "\n")
            throw("no module data")
        }
        return -1, 0
    }
    datap := f.datap
    p := datap.pctab[off:]
    pc := f.entry
    prevpc := pc
    val := int32(-1)
    for {
        var ok bool
        p, ok = step(p, &pc, &val, pc == f.entry)
        if !ok {
            break
        }
        if targetpc < pc {
            // Replace a random entry in the cache. Random
            // replacement prevents a performance cliff if
            // a recursive stack's cycle is slightly
            // larger than the cache.
            // Put the new element at the beginning,
            // since it is the most likely to be newly used.
            if cache != nil {
                x := pcvalueCacheKey(targetpc)
                e := &cache.entries[x]
                ci := fastrand() % uint32(len(cache.entries[x]))
                e[ci] = e[0]
                e[0] = pcvalueCacheEnt{
                    targetpc: targetpc,
                    off:      off,
                    val:      val,
                }
            }

            return val, prevpc
        }
        prevpc = pc
    }

    // If there was a table, it should have covered all program counters.
    // If not, something is wrong.
    if panicking != 0 || !strict {
        return -1, 0
    }

    print("runtime: invalid pc-encoded table f=", funcname(f), " pc=", hex(pc), " targetpc=", hex(targetpc), " tab=", p, "\n")

    p = datap.pctab[off:]
    pc = f.entry
    val = -1
    for {
        var ok bool
        p, ok = step(p, &pc, &val, pc == f.entry)
        if !ok {
            break
        }
        print("\tvalue=", val, " until pc=", hex(pc), "\n")
    }

    throw("invalid runtime symbol table")
    return -1, 0
}


func step(p []byte, pc *uintptr, val *int32, first bool) (newp []byte, ok bool) {
    // For both uvdelta and pcdelta, the common case (~70%)
    // is that they are a single byte. If so, avoid calling readvarint.
    uvdelta := uint32(p[0])
    if uvdelta == 0 && !first {
        return nil, false
    }
    n := uint32(1)
    if uvdelta&0x80 != 0 {
        n, uvdelta = readvarint(p)
    }
    *val += int32(-(uvdelta & 1) ^ (uvdelta >> 1)) //zigzag解码
    p = p[n:]

    pcdelta := uint32(p[0])
    n = 1
    if pcdelta&0x80 != 0 {
        n, pcdelta = readvarint(p)
    }
    p = p[n:]
    *pc += uintptr(pcdelta * sys.PCQuantum)
    return p, true
}

func readvarint(p []byte) (read uint32, val uint32) { //varint解码
    var v, shift, n uint32
    for {
        b := p[n]
        n++
        v |= uint32(b&0x7F) << (shift & 31)
        if b&0x80 == 0 {
            break
        }
        shift += 7
    }
    return n, v
}

#func.py
if self.pcfile !=0:
    ida_offset.op_plain_offset(addr+ptrSize+offset_size*4,0,pcheader.pctab)
    fileno = common.read_pcvalue(pcheader.pctab+self.pcfile)
    if fileno == -1:
        self.filename = "?"
    else:
        fileoff_addr = pcheader.cutab+(self.cuOffset+fileno)*4
        fileoff = common.get_dword(fileoff_addr)
        ida_offset.op_plain_offset(fileoff_addr,0,pcheader.filetab)
        if fileoff != 0xffffffff:
            self.filename = idc.get_strlit_contents(pcheader.filetab+fileoff).decode('utf-8')
        else:
            self.filename = "?"
else:
     self.filename = "?"
if self.pcln != 0:
    ida_offset.op_plain_offset(addr+ptrSize+offset_size*5,0,pcheader.pctab)
    self.line = common.read_pcvalue(pcheader.pctab+self.pcln)
else:
    self.line = -1

//src\runtime\symtab.go
func funcline(f funcInfo, targetpc uintptr) (file string, line int32) {
    return funcline1(f, targetpc, true)
}

func funcline1(f funcInfo, targetpc uintptr, strict bool) (file string, line int32) {
    datap := f.datap
    if !f.valid() {
        return "?", 0
    }
    fileno, _ := pcvalue(f, f.pcfile, targetpc, nil, strict)
    line, _ = pcvalue(f, f.pcln, targetpc, nil, strict)
    if fileno == -1 || line == -1 || int(fileno) >= len(datap.filetab) {
        // print("looking for ", hex(targetpc), " in ", funcname(f), " got file=", fileno, " line=", lineno, "\n")
        return "?", 0
    }
    file = funcfile(f, fileno)
    return
}

func funcfile(f funcInfo, fileno int32) string {
    datap := f.datap
    if !f.valid() {
        return "?"
    }
    // Make sure the cu index and file offset are valid
    if fileoff := datap.cutab[f.cuOffset+uint32(fileno)]; fileoff != ^uint32(0) {
        return gostringnocopy(&datap.filetab[fileoff])
    }
    // pcln section is corrupt.
    return "?"
}

//src\reflect\type.go
// rtype must be kept in sync with ../runtime/type.go:/^type._type.
type rtype struct {
    size       uintptr
    ptrdata    uintptr // number of bytes in the type that can contain pointers
    hash       uint32  // hash of type; avoids computation in hash tables
    tflag      tflag   // extra type information flags
    align      uint8   // alignment of variable with this type
    fieldAlign uint8   // alignment of struct field with this type
    kind       uint8   // enumeration for C
    // function for comparing objects of this type
    // (ptr to object A, ptr to object B) -> ==?
    equal     func(unsafe.Pointer, unsafe.Pointer) bool
    gcdata    *byte   // garbage collection data
    str       nameOff // string form
    ptrToThis typeOff // type for pointer to this type, may be zero
}

//src\reflect\type.go
type nameOff int32
type typeOff int32

//src\reflect\type.go
const (
    kindDirectIface = 1 << 5
    kindGCProg      = 1 << 6 // Type.gc points to GC program
    kindMask        = (1 << 5) - 1
)

type Kind uint

const (
    Invalid Kind = iota
    Bool
    Int
    Int8
    Int16
    Int32
    Int64
    Uint
    Uint8
    Uint16
    Uint32
    Uint64
    Uintptr
    Float32
    Float64
    Complex64
    Complex128
    Array
    Chan
    Func
    Interface
    Map
    Ptr
    Slice
    String
    Struct
    UnsafePointer
)

#typelink.py
def get_kind(self):
    # src/reflect/type.go#kindMask
    TYPE_KINDS = ['Invalid Kind','Bool','Int','Int8','Int16','Int32','Int64','Uint','Uint8','Uint16','Uint32','Uint64','Uintptr','Float32','Float64','Complex64','Complex128','Array','Chan','Func','Interface','Map','Ptr','Slice','String','Struct','UnsafePointer']
    kindMask = (1 << 5) - 1
    return TYPE_KINDS[self.kind & kindMask]

//src\reflect\type.go
const (
    // tflagUncommon means that there is a pointer, *uncommonType,
    // just beyond the outer type structure.
    //
    // For example, if t.Kind() == Struct and t.tflag&tflagUncommon != 0,
    // then t has uncommonType data and it can be accessed as:
    //
    //  type tUncommon struct {
    //      structType
    //      u uncommonType
    //  }
    //  u := &(*tUncommon)(unsafe.Pointer(t)).u
    tflagUncommon tflag = 1 << 0

    // tflagExtraStar means the name in the str field has an
    // extraneous '*' prefix. This is because for most types T in
    // a program, the type *T also exists and reusing the str data
    // saves binary size.
    tflagExtraStar tflag = 1 << 1

    // tflagNamed means the type has a name.
    tflagNamed tflag = 1 << 2

    // tflagRegularMemory means that equal and hash functions can treat
    // this type as a single region of t.size bytes.
    tflagRegularMemory tflag = 1 << 3
)

#typelink.py
def parse_tflag(self):
    # src/reflect/type.go#tflag
    tflagUncommon        = 0x1
    tflagExtraStar    = 0x2
    tflagNamed         = 0x4
    tflagRegularMemory = 0x8
    self.tflag_comm = 'tflag:'
    if self.tflag & tflagUncommon != 0:
        self.uncommon = True
        self.tflag_comm += "Uncommon;"
    else:
        self.uncommon = False
        self.tflag_comm += "Common;"
    if self.tflag & tflagExtraStar !=0:
        self.tflag_comm += "Star Prefix;"
    if self.tflag & tflagNamed !=0:
        self.tflag_comm += "Named"
    if self.tflag & tflagRegularMemory !=0:
        self.tflag_comm += "equal and hash func can treat"

#判断*号的代码片段
if "Star Prefix" in self.tflag_comm and name_str[0] == '*':
    name_str = '#' + name_str[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
//
// The next two bytes are the data length:
//
//   l := uint16(data[1])<<8 | uint16(data[2])
//
// Bytes [3:3+l] are the string data.
//
// If tag data follows then bytes 3+l and 3+l+1 are the tag length,
// with the data following.
//
// 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.
type name struct {
    bytes *byte
}

#typelink.py
#解析flag
def parse_flag(self):
    EXPORTED = 0x1
    HAS_TAG = 0x2
    HAS_PKGPATH = 0x4
    self.flag_comm = "flag:"
    if self.flag & EXPORTED:
        self.is_exported = True
        self.flag_comm += "exported;"
    if self.has_tag & HAS_TAG:
        self.has_tag = True
        self.flag_comm += "has tag;"
    if self.flag & HAS_PKGPATH:
        self.has_pkgpath = True
        self.flag_comm += "has pkgpath"

# 计算长度
self.len = (ida_bytes.get_byte(name_addr+1)<<8)|ida_bytes.get_byte(name_addr+2)

#获取字符串
def get_name(self):
    name = ""
    if self.len > 0:
        try:
            name = self.name.decode('utf-8')
        except Exception as err:
            print(hex(self.rtype.start_addr),hex(self.start_addr))
            traceback.print_stack()
    return name

//src\reflect\type.go
type ptrType struct {
    rtype
    elem *rtype // pointer element (pointed at) type
}

//src\reflect\type.go
type structType struct {
    rtype
    pkgPath name
    fields  []structField // sorted by offset
}

type structField struct {
    name        name    // name is always non-empty
    typ         *rtype  // type of field
    offsetEmbed uintptr // byte offset of field<<1 | isEmbedded
}

self.offset = self.offsetEmbed >> 1
self.is_embeded = (self.offsetEmbed&1 != 0)

//src\reflect\type.go
type sliceType struct {
    rtype
    elem *rtype // slice element type
}

//src\reflect\type.go
type arrayType struct {
    rtype
    elem  *rtype // array element type
    slice *rtype // slice type
    len   uintptr
}

//src\reflect\type.go
// A *rtype for each in and out parameter is stored in an array that
// directly follows the funcType (and possibly its uncommonType). So
// a function type with one method, one input, and one output is:
//
//  struct {
//      funcType
//      uncommonType
//      [2]*rtype    // [0] is in, [1] is out
//  }
type funcType struct {
    rtype
    inCount  uint16
    outCount uint16 // top bit is set if last input parameter is ...
}

//src\reflect\type.go
type interfaceType struct {
    rtype
    pkgPath name      // import path
    methods []imethod // sorted by hash
}

type imethod struct {
    name nameOff // name of method
    typ  typeOff // .(*FuncType) underneath
}

//src\reflect\type.go
type mapType struct {
    rtype
    key    *rtype // map key type
    elem   *rtype // map element (value) type
    bucket *rtype // internal bucket structure
    // function for hashing keys (ptr to key, seed) -> hash
    hasher     func(unsafe.Pointer, uintptr) uintptr
    keysize    uint8  // size of key slot
    valuesize  uint8  // size of value slot
    bucketsize uint16 // size of bucket
    flags      uint32
}

//src\reflect\type.go
type chanType struct {
    rtype
    elem *rtype  // channel element type
    dir  uintptr // channel direction (ChanDir)
}

type ChanDir int

const (
    RecvDir ChanDir             = 1 << iota // <-chan
    SendDir                                 // chan<-
    BothDir = RecvDir | SendDir             // chan
)

func (t *rtype) ChanDir() ChanDir {
    if t.Kind() != Chan {
        panic("reflect: ChanDir of non-chan type " + t.String())
    }
    tt := (*chanType)(unsafe.Pointer(t))
    return ChanDir(tt.dir)
}
func (d ChanDir) String() string {
    switch d {
    case SendDir:
        return "chan<-"
    case RecvDir:
        return "<-chan"
    case BothDir:
        return "chan"
    }
    return "ChanDir" + strconv.Itoa(int(d))
}

#src\reflect\type.go
def get_direction(self):
    recvDir = 0x1
    sendDir = 0x2
    self.directions = []
    if self.dir & recvDir:
        self.directions.append('recv')
    if self.dir & sendDir:
        self.directions.append('send')
    return "channel direction:" + "&".join(self.directions)

//src\reflect\type.go
type uncommonType struct {
    pkgPath nameOff // import path; empty for built-in types like int, string
    mcount  uint16  // number of methods
    xcount  uint16  // number of exported methods
    moff    uint32  // offset from this uncommontype to [mcount]method
    _       uint32  // unused
}

type method struct {
    name nameOff // name of method
    mtyp typeOff // method type (without receiver)
    ifn  textOff // fn used in interface call (one-word receiver)
    tfn  textOff // fn used for normal method call
}

//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.
}

#itablink.py
self.interface = typelink.parsed_types[self.inter]
if not typelink.has_parsed(self.type_addr):
    typelink.parse_type(self.type_addr)
self.funcs = []
for i in range(self.interface.method_slice.len):
    func_addr = common.get_qword(self.start_addr+ptrSize*(3+i))
    if func_addr != 0:
        self.funcs.append(func_addr)
    else:
        break
ida_bytes.set_cmt(self.start_addr+ptrSize*2+4,"Unused;Func num:%d,Interface num:%d" % (len(self.funcs),self.interface.method_slice.len),False)