type.go

// Copyright (C) 2019-2026 GoRE Authors.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package gore

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"reflect"
)

const (
	intSize32            = 4
	intSize64            = intSize32 * 2
	kindMask             = (1 << 5) - 1
	tflagExtraStar uint8 = 1 << 1
	tflagUncommon  uint8 = 1 << 0
)

const go127TypeLayoutVersion = "go1.27rc1"

func usesGo127TypeLayout(goVersion string) bool {
	return GoVersionCompare(goVersion, go127TypeLayoutVersion) >= 0
}

type _typeField uint8

const (
	_typeFieldSize = iota
	_typeFieldKind
	_typeFieldStr
	_typeFieldFlag
	_typeFieldEnd
)

// ChanDir is a channel direction.
type ChanDir int

const (
	// ChanRecv is a receive only chan (<-chan)
	ChanRecv ChanDir = 1 << iota
	// ChanSend is a send only chan (chan<-)
	ChanSend
	// ChanBoth is a send and receive chan (chan)
	ChanBoth = ChanRecv | ChanSend
)

func getTypes(fileInfo *FileInfo, f fileHandler, md moduledata) (map[uint64]*GoType, error) {
	if GoVersionCompare(fileInfo.goversion.Name, "go1.7beta1") < 0 {
		return getLegacyTypes(fileInfo, f, md)
	}

	types, err := md.Types().Data()
	if err != nil {
		return nil, fmt.Errorf("failed to get types data section: %w", err)
	}

	// New parser
	typesAddr := md.Types().Address
	resolver := newPointerResolver(f)
	parser := newTypeParser(types, typesAddr, fileInfo, f, resolver)
	if usesGo127TypeLayout(fileInfo.goversion.Name) {
		if md.TypeDescLen == 0 {
			return nil, errors.New("Go 1.27 moduledata has no type descriptor region")
		}
		if _, err := parseTypeDescriptors(parser, md.TypeDescLen); err != nil {
			return nil, fmt.Errorf("failed to parse type descriptors: %w", err)
		}
		if _, err := md.go127ITabLinks(parser); err != nil {
			return nil, fmt.Errorf("failed to parse interface tables: %w", err)
		}
		return parser.parsedTypes(), nil
	}

	typeLink, err := md.TypeLinkData()
	if err != nil {
		return nil, fmt.Errorf("failed to get type link data: %w", err)
	}
	for _, off := range typeLink {
		_, err := parser.parseType(uint64(off) + typesAddr)
		if err != nil {
			continue
		}
	}
	return parser.parsedTypes(), nil
}

func parseTypeDescriptors(parser *typeParser, descriptorLen uint64) ([]int32, error) {
	wordSize := uint64(parser.wordsize)
	offsets := make([]int32, 0, descriptorLen/(2*wordSize))
	for offset := wordSize; offset < descriptorLen; {
		offset = (offset + wordSize - 1) &^ (wordSize - 1)
		if offset >= descriptorLen {
			break
		}

		address := parser.base + offset
		typ, err := parser.parseType(address)
		if err != nil {
			return nil, fmt.Errorf("type descriptor at offset %#x: %w", offset, err)
		}
		if typ.Kind == reflect.Invalid {
			return nil, fmt.Errorf("invalid type kind at offset %#x", offset)
		}
		if typ.descriptorSize == 0 || typ.descriptorSize > descriptorLen-offset {
			return nil, fmt.Errorf("invalid type descriptor size %#x at offset %#x (descriptor region %#x)", typ.descriptorSize, offset, descriptorLen)
		}
		if offset > 1<<31-1 {
			return nil, fmt.Errorf("type descriptor offset %#x exceeds int32", offset)
		}
		offsets = append(offsets, int32(offset))
		offset += typ.descriptorSize
	}
	return offsets, nil
}

func getLegacyTypes(fileInfo *FileInfo, f fileHandler, md moduledata) (map[uint64]*GoType, error) {
	typelinkAddr, typelinkData, err := f.getSectionDataFromAddress(md.TypelinkAddr)
	if err != nil {
		return nil, fmt.Errorf("no typelink section found: %w", err)
	}
	r := bytes.NewReader(typelinkData)
	_, err = r.Seek(int64(md.TypelinkAddr)-int64(typelinkAddr), io.SeekStart)
	if err != nil {
		return nil, err
	}

	goTypes := make(map[uint64]*GoType)
	for i := uint64(0); i < md.TypelinkLen; i++ {
		// Type offsets are always *_type
		address, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil, err
		}
		baseAddr, baseData, err := f.getSectionDataFromAddress(address)
		if err != nil {
			continue
		}
		typ := typeParse(goTypes, fileInfo, address-baseAddr, baseData, baseAddr)
		if typ == nil {
			continue
		}
	}
	return goTypes, nil
}

// GoType is a representation of all types in Go.
type GoType struct {
	// Kind indicates the specific kind of type the GoType
	Kind reflect.Kind
	// Name is the name of the type.
	Name string
	// Addr is the virtual address to where the type struct is defined.
	Addr uint64
	// PtrResolvAddr is the address to where the resolved structure is located
	// if the GoType is of pointer kind.
	PtrResolvAddr uint64
	// PackagePath is the name of the package import path for the GoType.
	PackagePath string
	// Fields is a slice of the struct fields if the GoType is of kind struct.
	Fields []*GoType
	// FieldName is the name of the field if the GoType is a struct field.
	FieldName string
	// FieldTag holds the extracted tag for the field.
	FieldTag string
	// FieldAnon is true if the field does not have a name and is an embedded type.
	FieldAnon bool
	// Element is the element type for arrays, slices channels or the resolved type for
	// a pointer type. For example int if the slice is a []int.
	Element *GoType
	// Length is the array or slice length.
	Length int
	// ChanDir is the channel direction
	ChanDir ChanDir
	// Key is the key type for a map.
	Key *GoType
	// FuncArgs holds the argument types for the function if the type is a function kind.
	FuncArgs []*GoType
	// FuncReturnVals holds the return types for the function if the type is a function kind.
	FuncReturnVals []*GoType
	// IsVariadic is true if the last argument type is variadic. For example "func(s string, n ...int)"
	IsVariadic bool
	// Methods holds information of the types methods.
	Methods        []*TypeMethod
	flag           uint8
	descriptorSize uint64
}

// String implements the fmt.Stringer interface.
func (t *GoType) String() string {
	switch t.Kind {
	case reflect.Slice:
		return fmt.Sprintf("[]%s", t.Element)
	case reflect.Array:
		return fmt.Sprintf("[%d]%s", t.Length, t.Element)
	case reflect.Map:
		return fmt.Sprintf("map[%s]%s", t.Key, t.Element)
	case reflect.Struct:
		// Handle empty struct type
		if t.Name == "" {
			return "struct{}"
		}
		return t.Name
	case reflect.Ptr:
		return fmt.Sprintf("*%s", t.Element)
	case reflect.Chan:
		if t.ChanDir == ChanRecv {
			return fmt.Sprintf("<-chan %s", t.Element)
		}
		if t.ChanDir == ChanSend {
			return fmt.Sprintf("chan<- %s", t.Element)
		}
		return fmt.Sprintf("chan %s", t.Element)
	case reflect.Func:
		buf := "func("
		for i, a := range t.FuncArgs {
			if i != 0 {
				buf += ", "
			}
			if a.Kind == reflect.Func && a.Name == t.Name {
				buf += a.Name
			} else {
				buf += a.String()
			}
		}
		if len(t.FuncReturnVals) > 1 {
			buf += ") ("
		} else if len(t.FuncReturnVals) == 1 {
			buf += ") "
		} else {
			buf += ")"
		}
		for i, r := range t.FuncReturnVals {
			if i != 0 {
				buf += ", "
			}
			if r.Kind == reflect.Func && r.Name == t.Name {
				buf += r.Name
			} else {
				buf += r.String()
			}
		}
		if len(t.FuncReturnVals) > 1 {
			buf += ")"
		}
		return buf
	case reflect.Interface:
		// Handle empty interface
		if t.Name == "" {
			return "interface{}"
		}
		return t.Name
	case reflect.Invalid:
		return t.Name
	default:
		return t.Kind.String()
	}
}

// StructDef reconstructs the type definition code for the struct.
// If the type is not a struct, an empty string is returned.
func StructDef(typ *GoType) string {
	if typ.Kind != reflect.Struct {
		return ""
	}
	buf := fmt.Sprintf("type %s struct{", typ.Name)
	for _, f := range typ.Fields {
		if f.FieldAnon {
			buf += fmt.Sprintf("\n\t%s", f)
		} else {
			buf += fmt.Sprintf("\n\t%s %s", f.FieldName, f)
		}
		if f.FieldTag != "" {
			buf += "\t`" + f.FieldTag + "`"
		}
	}
	if len(typ.Fields) > 0 {
		buf += "\n"
	}
	return buf + "}"
}

// InterfaceDef reconstructs the type definition code for the interface.
// If the type is not an interface, an empty string is returned.
func InterfaceDef(typ *GoType) string {
	if typ.Kind != reflect.Interface {
		return ""
	}
	// Handle interface with no methods defined.
	if len(typ.Methods) == 0 {
		return "type " + typ.Name + " interface{}"
	}
	// Remove package from name.
	buf := fmt.Sprintf("type %s interface {", typ.Name)
	for _, m := range typ.Methods {
		buf += fmt.Sprintf("\n\t%s%s", m.Name, m.Type.String()[4:])
	}
	return buf + "\n}"
}

// MethodDef constructs a string summary of all methods for the type.
// If type information exists for the methods, it is used to determine function parameters.
// If the type does not have any methods, an empty string is returned.
func MethodDef(typ *GoType) string {
	if len(typ.Methods) == 0 {
		return ""
	}
	var buf string
	for i, m := range typ.Methods {
		if i > 0 {
			buf += "\n"
		}
		if m.Type != nil {
			buf += fmt.Sprintf("func (%s) %s%s", typ.Name, m.Name, m.Type.String()[4:])
		} else {
			buf += fmt.Sprintf("func (%s) %s()", typ.Name, m.Name)
		}
	}
	return buf
}

// TypeMethod is description of a method owned by the GoType.
type TypeMethod struct {
	// Name is the string name for the method.
	Name string
	// Type is the specific function type for the method.
	// This can be nil. If it is nil, the method is not part of an
	// implementation of a interface or it is not exported.
	Type *GoType
	// IfaceCallOffset is the offset from the beginning of the .text section
	// where the function code starts. According to code comments in the
	// standard library, it is used for interface calls.
	// Can be 0 if the code is not called in the binary and was optimized out
	// by the compiler or linker.
	IfaceCallOffset uint64
	// FuncCallOffset is the offset from the beginning of the .text section
	// where the function code starts. According to code comments in the
	// standard library, it is used for normal method calls.
	// Can be 0 if the code is not called in the binary and was optimized out
	// by the compiler or linker.
	FuncCallOffset uint64
}

/*
Size: 32 or 48
type _type struct {
	size       uintptr 4 or 8
	ptrdata    uintptr 4 or 8
	hash       uint32 4
	tflag      tflag 1
	align      uint8 1
	fieldalign uint8 1
	kind       uint8 1
	alg        *typeAlg 4 or 8
	gcdata    *byte 4 or 8
	str       nameOff 4
	ptrToThis typeOff 4
}
*/

func typeParse(types map[uint64]*GoType, fileInfo *FileInfo, offset uint64, sectionData []byte, sectionBaseAddr uint64) *GoType {
	typ, ok := types[offset+sectionBaseAddr]
	if ok {
		return typ
	}
	typ = new(GoType)
	// XXX: This is to catch bad parsing. The current parser does not handle
	// uncommon functions correctly. This ensures an out of bounds read does
	// not occur.
	if offset > uint64(len(sectionData)) {
		return nil
	}
	r := bytes.NewReader(sectionData[offset:])

	// Parse size
	off := typeOffset(fileInfo, _typeFieldSize)
	r.Seek(off, io.SeekStart)
	_, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
	if err != nil {
		return nil
	}

	// Parse kind
	off = typeOffset(fileInfo, _typeFieldKind)
	// Defined as uint8
	var k uint8
	r.Seek(off, io.SeekStart)
	binary.Read(r, fileInfo.ByteOrder, &k)
	typ.Kind = reflect.Kind(k & kindMask)

	// Parse flag
	off = typeOffset(fileInfo, _typeFieldFlag)
	// Defined as uint8
	var f uint8
	r.Seek(off, io.SeekStart)
	binary.Read(r, fileInfo.ByteOrder, &f)
	typ.flag = f

	// Parse nameOff
	off = typeOffset(fileInfo, _typeFieldStr)
	r.Seek(off, io.SeekStart)
	ptrN, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
	if err != nil {
		return nil
	}
	if ptrN != 0 {
		typ.Name = parseString(fileInfo, ptrN, sectionBaseAddr, sectionData)
	}

	typ.Addr = offset + sectionBaseAddr
	types[typ.Addr] = typ

	// Legacy types has a field with a pointer to the uncommonType.
	// The flags location is unused, hence 0, so the parsing of the uncommonType
	// is skipped below. So instead, if the binary uses legacy types parse it now.
	// Pointer is right after the string pointer.
	off = typeOffset(fileInfo, _typeFieldStr) + int64(fileInfo.WordSize)
	r.Seek(off, io.SeekStart)
	ptr, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
	if err != nil {
		return nil
	}
	if ptr != 0 {
		// Since we don't know if the struct is located before or after this type,
		// create a new reader.
		ur := bytes.NewReader(sectionData)
		ur.Seek(int64(ptr-sectionBaseAddr), io.SeekStart)
		parseUncommonType(typ, ur, fileInfo, sectionData, sectionBaseAddr, types)
	}

	// Parse extra fields
	off = typeOffset(fileInfo, _typeFieldEnd)
	r.Seek(off, io.SeekStart)
	switch typ.Kind {

	case reflect.Ptr:
		ptr, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		typ.PtrResolvAddr = ptr
		if ptr != 0 {
			c := typeParse(types, fileInfo, ptr-sectionBaseAddr, sectionData, sectionBaseAddr)
			typ.Element = c
		}

	case reflect.Struct:

		// Parse struct fields
		fieldptr, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		numfield, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		// Eat cap
		_, err = readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}

		// Parse methods
		if typ.flag&tflagUncommon != 0 {
			parseUncommonType(typ, r, fileInfo, sectionData, sectionBaseAddr, types)
		}

		// Parse fields
		typ.Fields = make([]*GoType, numfield)
		secR := bytes.NewReader(sectionData)
		for i := 0; i < int(numfield); i++ {
			var fieldName string
			var tag string
			o := int64(fieldptr + uint64(i*5*fileInfo.WordSize) - sectionBaseAddr)
			secR.Seek(o, io.SeekStart)
			nptr, err := readUIntTo64(secR, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
			if err != nil {
				return nil
			}
			ppp, err := readUIntTo64(secR, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
			if err != nil {
				return nil
			}
			if ppp != 0 {
				pps := parseString(fileInfo, ppp, sectionBaseAddr, sectionData)
				if pps != "" {
					typ.PackagePath = pps
				}
			}
			tptr, err := readUIntTo64(secR, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
			if err != nil {
				return nil
			}
			tagptr, err := readUIntTo64(secR, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
			if err != nil {
				return nil
			}
			if tagptr != 0 {
				tag = parseString(fileInfo, tagptr, sectionBaseAddr, sectionData)
			}
			uptr, err := readUIntTo64(secR, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
			if err != nil {
				return nil
			}
			gt := typeParse(types, fileInfo, tptr-sectionBaseAddr, sectionData, sectionBaseAddr)
			// Make a copy
			field := *gt

			fieldName = parseString(fileInfo, nptr, sectionBaseAddr, sectionData)
			field.FieldName = fieldName
			if tag != "" {
				field.FieldTag = tag
			}
			// Older versions has no field name for anonymous fields. New versions
			// uses a bit flag on the offset.
			field.FieldAnon = fieldName == "" || uptr&1 != 0
			typ.Fields[i] = &field
		}
	case reflect.Array:

		elementAddr, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		if elementAddr != 0 {
			e := typeParse(types, fileInfo, elementAddr-sectionBaseAddr, sectionData, sectionBaseAddr)
			typ.Element = e
		}

		// Read and skip slice type
		_, err = readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}

		// Read length
		l, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		typ.Length = int(l)

	case reflect.Slice:

		elementAddr, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		if elementAddr != 0 {
			e := typeParse(types, fileInfo, elementAddr-sectionBaseAddr, sectionData, sectionBaseAddr)
			typ.Element = e
		}

	case reflect.Chan:

		elementAddr, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		if elementAddr != 0 {
			e := typeParse(types, fileInfo, elementAddr-sectionBaseAddr, sectionData, sectionBaseAddr)
			typ.Element = e
		}

		// Direction
		d, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		typ.ChanDir = ChanDir(int(d))

	case reflect.Map:

		keyAddr, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		if keyAddr != 0 {
			k := typeParse(types, fileInfo, keyAddr-sectionBaseAddr, sectionData, sectionBaseAddr)
			typ.Key = k
		}

		elementAddr, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		if elementAddr != 0 {
			e := typeParse(types, fileInfo, elementAddr-sectionBaseAddr, sectionData, sectionBaseAddr)
			typ.Element = e
		}

	case reflect.Func:

		// bool plus padding.
		dotdotdot, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		typ.IsVariadic = dotdotdot > uint64(0)
		// One for args and one for returns
		rtypes := make([]uint64, 2)
		typelens := make([]uint64, 2)
		for i := 0; i < 2; i++ {
			p, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
			if err != nil {
				continue
			}
			rtypes[i] = p
			l, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
			if err != nil {
				continue
			}
			typelens[i] = l

			// Eat cap
			_, err = readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
			if err != nil {
				println("Error when reading padding:", err)
				return nil
			}
		}
		// Full section reader
		sr := bytes.NewReader(sectionData)
		// Parse the arg types and result types.
		for i := 0; i < 2; i++ {
			if rtypes[i] == 0 {
				continue
			}
			_, err = sr.Seek(int64(rtypes[i]-sectionBaseAddr), io.SeekStart)
			if err != nil {
				continue
			}
			for j := 0; j < int(typelens[i]); j++ {
				p, err := readUIntTo64(sr, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
				if err != nil {
					continue
				}
				if p == 0 {
					continue
				}
				t := typeParse(types, fileInfo, p-sectionBaseAddr, sectionData, sectionBaseAddr)
				if i == 0 {
					typ.FuncArgs = append(typ.FuncArgs, t)
				} else {
					typ.FuncReturnVals = append(typ.FuncReturnVals, t)
				}
			}
		}

	case reflect.Interface:

		ptrMethods, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		numMethods, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		// Eat cap
		_, err = readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}

		// Parse imethods
		secR := bytes.NewReader(sectionData)
		imethSize := uint64(2 * intSize32)
		int32ptr := true
		if GoVersionCompare(fileInfo.goversion.Name, "go1.7beta1") < 0 {
			imethSize = uint64(3 * fileInfo.WordSize)
			int32ptr = fileInfo.WordSize == intSize32
		}
		for i := 0; i < int(numMethods); i++ {
			meth := new(TypeMethod)
			// All fields has the size of int32
			secR.Seek(int64(ptrMethods+uint64(i)*imethSize-sectionBaseAddr), io.SeekStart)
			nameOff, err := readUIntTo64(secR, fileInfo.ByteOrder, int32ptr)
			if err != nil {
				continue
			}
			if nameOff != 0 {
				meth.Name = parseString(fileInfo, nameOff, sectionBaseAddr, sectionData)
			}

			pkgPathPtr, err := readUIntTo64(secR, fileInfo.ByteOrder, int32ptr)
			if err != nil {
				continue
			}
			if pkgPathPtr != 0 {
				pkgPathStr := parseString(fileInfo, pkgPathPtr, sectionBaseAddr, sectionData)
				if pkgPathStr != "" {
					typ.PackagePath = pkgPathStr
				}
			}

			typeOff, err := readUIntTo64(secR, fileInfo.ByteOrder, int32ptr)
			if err != nil {
				continue
			}
			if typeOff != 0 {
				typeOff = typeOff - sectionBaseAddr
				meth.Type = typeParse(types, fileInfo, typeOff, sectionData, sectionBaseAddr)
			}
			typ.Methods = append(typ.Methods, meth)
		}
	}
	return typ
}

func parseString(fileInfo *FileInfo, off, base uint64, baseData []byte) string {
	if off == 0 {
		return ""
	}
	r := bytes.NewReader(baseData)
	r.Seek(int64(off-base), io.SeekStart)
	h, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
	if err != nil {
		return ""
	}
	l, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
	if err != nil {
		return ""
	}
	if h == 0 || l == 0 {
		return ""
	}
	str := string(baseData[h-base : h-base+l])
	return str
}

func parseUncommonType(typ *GoType, r *bytes.Reader, fileInfo *FileInfo, sectionData []byte, sectionBaseAddr uint64, types map[uint64]*GoType) {
	pname, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
	if err != nil {
		return
	}
	if pname != 0 {
		n := parseString(fileInfo, pname, sectionBaseAddr, sectionData)
		if typ.Name == "" && n != "" {
			typ.Name = n
		}
	}
	ppkg, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
	if err != nil {
		return
	}
	if ppkg != 0 {
		p := parseString(fileInfo, ppkg, sectionBaseAddr, sectionData)
		if typ.PackagePath == "" && p != "" {
			typ.PackagePath = p
		}
	}
	typ.Methods = parseMethods(r, fileInfo, sectionData, sectionBaseAddr, types)
}

// The methods must start at the readers current location.
func parseMethods(r *bytes.Reader, fileInfo *FileInfo, sectionData []byte, sectionBaseAddr uint64, types map[uint64]*GoType) []*TypeMethod {
	pdata, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
	if err != nil {
		return nil
	}
	numMeth, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
	if err != nil {
		return nil
	}
	methods := make([]*TypeMethod, numMeth)
	r.Seek(int64(pdata-sectionBaseAddr), io.SeekStart)
	for i := 0; i < int(numMeth); i++ {
		m := &TypeMethod{}
		p, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		m.Name = parseString(fileInfo, p, sectionBaseAddr, sectionData)

		// Eat package path
		_, err = readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}

		// mtyp
		mtype, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		if mtype != 0 {
			m.Type = typeParse(types, fileInfo, mtype-sectionBaseAddr, sectionData, sectionBaseAddr)
		}

		// typ
		p, err = readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		if p != 0 {
			// Parse it so we capture it in the global type list.
			typeParse(types, fileInfo, p-sectionBaseAddr, sectionData, sectionBaseAddr)
		}

		// ifn
		ifn, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		m.IfaceCallOffset = ifn

		// tfn
		tfn, err := readUIntTo64(r, fileInfo.ByteOrder, fileInfo.WordSize == intSize32)
		if err != nil {
			return nil
		}
		m.FuncCallOffset = tfn
		methods[i] = m
	}
	return methods
}

func typeOffset(fileInfo *FileInfo, field _typeField) int64 {
	intSize := int64(intSize64)
	if fileInfo.WordSize == intSize32 {
		intSize = intSize32
	}

	switch field {
	case _typeFieldSize:
		return 0

	case _typeFieldKind:
		return 2*intSize + 4 + 3

	case _typeFieldStr:
		return 4*intSize + 4 + 4

	case _typeFieldFlag:
		return 2*intSize + 4

	case _typeFieldEnd:
		if GoVersionCompare(fileInfo.goversion.Name, "go1.6beta1") < 0 {
			return 8*intSize + 8
		}
		if GoVersionCompare(fileInfo.goversion.Name, "go1.7beta1") < 0 {
			return 7*intSize + 8
		}
		return 4*intSize + 16

	default:
		return -1
	}
}