gp_gp      uint64
	gp_tp      uint64
	gp_t       [7]uint64
	gp_s       [12]uint64
	gp_a       [8]uint64
	gp_sepc    uint64
	gp_sstatus uint64
}

type fpregs struct {
	fp_x     [64]uint64 // actually __uint64_t fp_x[32][2]
	fp_fcsr  uint64
	fp_flags int32
	pad      int32
}

type mcontext struct {
	mc_gpregs gpregs
	mc_fpregs fpregs
	mc_flags  int32
	mc_pad    int32

	si_uid    uint32
	si_status int32
	si_addr   uint64
	si_value  [8]byte
	_reason   [40]byte
}

type gpregs struct {
	gp_x    [30]uint64
	gp_lr   uint64
	gp_sp   uint64
	gp_elr  uint64
	gp_spsr uint32
	gp_pad  int32
}

type fpregs struct {
	fp_q     [64]uint64 // actually [32]uint128
	fp_sr    uint32
	fp_cr    uint32
	fp_flags int32
	fp_pad   int32
}

		// So, we mark the object is MIPS I style paired float/double register scheme,
		// aka MIPS_FPABI_ANY. If we mark the object as FPXX, the kernel may use FR=1 mode,
		// then we meet some problem.
		// Note: MIPS_FPABI_ANY is bad naming: in fact it is MIPS I style FPR usage.
		//       It is not for 'ANY'.
		// TODO: switch to FPXX after be sure that no odd-number-fpr is used.
		ctxt.Out.Write8(MIPS_FPABI_ANY) // fpAbi
	}

	for _, s := range x.f.Sections {
		if s.Name == ".go.buildinfo" {
			return s.Addr, s.Size
		}
	}
	for _, p := range x.f.Progs {
		if p.Type == elf.PT_LOAD && p.Flags&(elf.PF_X|elf.PF_W) == elf.PF_W {
			return p.Vaddr, p.Memsz
		}
	}
	return 0, 0
}

// peExe is the PE (Windows Portable Executable) implementation of the exe interface.
type peExe struct {
	f *pe.File
}

	for _, s := range f.Sections {
		if s.Name == ".text" {
			// Find the LOAD segment containing the .text section.
			for _, p := range f.Progs {
				if p.Type == elf.PT_LOAD && p.Flags&elf.PF_X != 0 && s.Addr >= p.Vaddr && s.Addr < p.Vaddr+p.Memsz {
					return &p.ProgHeader
				}
			}
		}
	}
	return nil
}

// ProgramHeadersForMapping returns the program segment headers that overlap

	}

	base, err := elfexec.GetBase(&ef.FileHeader, ph, f.m.kernelOffset, f.m.start, f.m.limit, f.m.offset)
	if err != nil {
		return err
	}
	f.base = base
	f.isData = ph != nil && ph.Flags&elf.PF_X == 0
	return nil
}

func (f *file) Name() string {
	return f.name
}

func (f *file) ObjAddr(addr uint64) (uint64, error) {
	f.baseOnce.Do(func() { f.baseErr = f.computeBase(addr) })

// Prog.Flag
type ProgFlag uint32

const (
	PF_X        ProgFlag = 0x1        /* Executable. */
	PF_W        ProgFlag = 0x2        /* Writable. */
	PF_R        ProgFlag = 0x4        /* Readable. */
	PF_MASKOS   ProgFlag = 0x0ff00000 /* Operating system-specific. */
	PF_MASKPROC ProgFlag = 0xf0000000 /* Processor-specific. */
)

var pfStrings = []intName{
	{0x1, "PF_X"},
	{0x2, "PF_W"},
	{0x4, "PF_R"},
}

	op_UNPKA   uint32 = 0xEA00 // FORMAT_SS1        UNPACK ASCII
	op_UNPKU   uint32 = 0xE200 // FORMAT_SS1        UNPACK UNICODE
	op_UPT     uint32 = 0x0102 // FORMAT_E          UPDATE TREE
	op_X       uint32 = 0x5700 // FORMAT_RX1        EXCLUSIVE OR (32)
	op_XC      uint32 = 0xD700 // FORMAT_SS1        EXCLUSIVE OR (character)
	op_XG      uint32 = 0xE382 // FORMAT_RXY1       EXCLUSIVE OR (64)

			}

			// Function is being used in an expression, to e.g. pass around a C function pointer.
			// Create a new Name for this Ref which causes the variable to be declared in Go land.
			fpName := "fp_" + r.Name.Go
			name := f.Name[fpName]
			if name == nil {
				name = &Name{
					Go:   fpName,
					C:    r.Name.C,
					Kind: "fpvar",

		{"NType", Type, 0},
		{"NewFile", Func, 0},
		{"OSABI", Type, 0},
		{"Open", Func, 0},
		{"PF_MASKOS", Const, 0},
		{"PF_MASKPROC", Const, 0},
		{"PF_R", Const, 0},
		{"PF_W", Const, 0},
		{"PF_X", Const, 0},
		{"PT_AARCH64_ARCHEXT", Const, 16},
		{"PT_AARCH64_UNWIND", Const, 16},
		{"PT_ARM_ARCHEXT", Const, 16},
		{"PT_ARM_EXIDX", Const, 16},
		{"PT_DYNAMIC", Const, 0},