(MOVBload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read8(sym, int64(off)))])
(MOVHload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
(MOVWload [off] {sym} (SB) _) && symIsRO(sym) => (MOVVconst [int64(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))])

	_O_CLOEXEC   = 0x80000
	_SA_RESTORER = 0
)

type ptregs struct {
	gpr       [32]uint64
	nip       uint64
	msr       uint64
	orig_gpr3 uint64
	ctr       uint64
	link      uint64
	xer       uint64
	ccr       uint64
	softe     uint64
	trap      uint64
	dar       uint64
	dsisr     uint64
	result    uint64
}

type vreg struct {
	u [4]uint32
}

type stackt struct {

	si_code   int32
	si_pid    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

	tf_stack uintptr
}

type sigcontext struct {
	sc_cookie uint64
	sc_mask   int32
	sc_reg    [32]uint64
	sc_lr     uint64
	sc_cr     uint64
	sc_xer    uint64
	sc_ctr    uint64
	sc_pc     uint64
	sc_ps     uint64
	sc_vrsave uint64
	pad_cgo_0 [8]byte
	sc_vsx    [64][16]uint8
	sc_fpscr  uint64
	sc_vscr   uint64
}

type siginfo struct {
	si_signo  int32
	si_code   int32

// A Uint64 is an atomic uint64. The zero value is zero.
type Uint64 struct {
	_ noCopy
	_ align64
	v uint64
}

// Load atomically loads and returns the value stored in x.
func (x *Uint64) Load() uint64 { return LoadUint64(&x.v) }

// Store atomically stores val into x.
func (x *Uint64) Store(val uint64) { StoreUint64(&x.v, val) }

// Consider using the more ergonomic and less error-prone [Int64.And] instead.
func AndInt64(addr *int64, mask int64) (old int64)

// AndUint64 atomically performs a bitwise AND operation on *addr using the bitmask provided as mask
// and returns the old.
// Consider using the more ergonomic and less error-prone [Uint64.And] instead.
func AndUint64(addr *uint64, mask uint64) (old uint64)

	ts.tv_sec = ns / 1e9
	ts.tv_nsec = ns % 1e9
}

type exceptionstate64 struct {
	far uint64 // virtual fault addr
	esr uint32 // exception syndrome
	exc uint32 // number of arm exception taken
}

type regs64 struct {
	x     [29]uint64 // registers x0 to x28
	fp    uint64     // frame register, x29
	lr    uint64     // link register, x30
	sp    uint64     // stack pointer, x31

	ss_size  uintptr
	ss_flags int32
}

type sigcontext struct {
	sc_regs      [32]uint64
	sc_fpregs    [32]uint64
	sc_mdhi      uint64
	sc_hi1       uint64
	sc_hi2       uint64
	sc_hi3       uint64
	sc_mdlo      uint64
	sc_lo1       uint64
	sc_lo2       uint64
	sc_lo3       uint64
	sc_pc        uint64
	sc_fpc_csr   uint32
	sc_used_math uint32
	sc_dsp       uint32
	sc_reserved  uint32
}

	}

	if cuEntry, cuEntryOK := cu.Val(AttrEntrypc).(uint64); cuEntryOK {
		return cu, cuEntry, nil
	} else if cuLow, cuLowOK := cu.Val(AttrLowpc).(uint64); cuLowOK {
		return cu, cuLow, nil
	}

	return cu, 0, nil
}

func (d *Data) dwarf2Ranges(u *unit, base uint64, ranges int64, ret [][2]uint64) ([][2]uint64, error) {
	if ranges < 0 || ranges > int64(len(d.ranges)) {

	Metric       uint32
	Rdomain      uint32
	Baudrate     uint64
	Ipackets     uint64
	Ierrors      uint64
	Opackets     uint64
	Oerrors      uint64
	Collisions   uint64
	Ibytes       uint64
	Obytes       uint64
	Imcasts      uint64
	Omcasts      uint64
	Iqdrops      uint64
	Oqdrops      uint64
	Noproto      uint64
	Capabilities uint32
	_            [4]byte
	Lastchange   Timeval
}