// (LO) instruction sequences used to implement absolute relocations
	// on PPC64 prior to ISA 3.1 (P10). For consistency, maintain this
	// restriction for ISA 3.1 unless it becomes problematic.
	t := ldr.SymAddr(rs) + r.Add()
	if t < 0 || t >= 1<<31 {
		ldr.Errorf(s, "relocation for %s is too big (>=2G): 0x%x", ldr.SymName(s), ldr.SymValue(rs))
	}

			continue
		}
		if v.Type.IsTuple() && v.Type.FieldType(1).IsMemory() {
			// We could handle this situation however it is likely
			// to be very rare.
			return false
		}
		if v.Op.SymEffect()&SymAddr != 0 {
			// This case prevents an operation that calculates the
			// address of a local variable from being forced to schedule
			// before its corresponding VarDef.
			// See issue 28445.
			//   v1 = LOAD ...

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) pc() uint64 { return c.regs().mc_gpregs.gp_elr }

func (c *sigctxt) fault() uintptr { return uintptr(c.info.si_addr) }

func (c *sigctxt) sigcode() uint64 { return uint64(c.info.si_code) }
func (c *sigctxt) sigaddr() uint64 { return c.info.si_addr }

func (c *sigctxt) set_pc(x uint64)  { c.regs().mc_gpregs.gp_elr = x }
func (c *sigctxt) set_sp(x uint64)  { c.regs().mc_gpregs.gp_sp = x }

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) pc() uint64 { return c.regs().mc_gpregs.gp_sepc }

func (c *sigctxt) sigcode() uint64 { return uint64(c.info.si_code) }
func (c *sigctxt) sigaddr() uint64 { return c.info.si_addr }

func (c *sigctxt) set_pc(x uint64) { c.regs().mc_gpregs.gp_sepc = x }
func (c *sigctxt) set_ra(x uint64) { c.regs().mc_gpregs.gp_ra = x }
func (c *sigctxt) set_sp(x uint64) { c.regs().mc_gpregs.gp_sp = x }

// TODO(aix): find trap equivalent
func (c *sigctxt) trap() uint32 { return 0x0 }

func (c *sigctxt) sigcode() uint32 { return uint32(c.info.si_code) }
func (c *sigctxt) sigaddr() uint64 { return uint64(c.info.si_addr) }
func (c *sigctxt) fault() uintptr  { return uintptr(c.sigaddr()) }

func (c *sigctxt) set_r0(x uint64)   { c.regs().gpr[0] = x }
func (c *sigctxt) set_r12(x uint64)  { c.regs().gpr[12] = x }

func (c *sigctxt) sigcode() uint64 { return uint64(c.info.si_code) }
func (c *sigctxt) sigaddr() uint64 { return c.info.si_addr }

func (c *sigctxt) set_rip(x uint64)     { c.regs().rip = x }
func (c *sigctxt) set_rsp(x uint64)     { c.regs().rsp = x }
func (c *sigctxt) set_sigcode(x uint64) { c.info.si_code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint64) { c.info.si_addr = x }

//go:nosplit
func (c *sigctxt) fixsigcode(sig uint32) {
	switch sig {

func (c *sigctxt) xer() uint64  { return c.regs().xer }
func (c *sigctxt) ccr() uint64  { return c.regs().ccr }

func (c *sigctxt) sigcode() uint32 { return uint32(c.info.si_code) }
func (c *sigctxt) sigaddr() uint64 { return c.info.si_addr }
func (c *sigctxt) fault() uintptr  { return uintptr(c.regs().dar) }

func (c *sigctxt) set_r0(x uint64)   { c.regs().gpr[0] = x }
func (c *sigctxt) set_r12(x uint64)  { c.regs().gpr[12] = x }

	sa_flags    uint64
	sa_restorer uintptr
	sa_mask     uint64
}

type siginfoFields struct {
	si_signo int32
	si_errno int32
	si_code  int32
	// below here is a union; si_addr is the only field we use
	si_addr uint64
}

type siginfo struct {
	siginfoFields

	// Pad struct to the max size in the kernel.
	_ [_si_max_size - unsafe.Sizeof(siginfoFields{})]byte
}

	n = len(tcpRes) - 2
	tcpRes[0] = byte(n >> 8)
	tcpRes[1] = byte(n)
	a.rbuf.Write(tcpRes[2:])

	return len(packet), nil
}

type someaddr struct{}

func (someaddr) Network() string { return "unused" }
func (someaddr) String() string  { return "unused-someaddr" }

func mapRCode(err error) dnsmessage.RCode {
	switch err {
	case nil:
		return dnsmessage.RCodeSuccess
	case ErrNotExist:

		t.Run("", func(t *testing.T) {
			sameAddr, err := sameLocalAddrs(testCase.addr1, testCase.addr2)
			if testCase.expectedErr != nil && err == nil {
				t.Errorf("should fail but succeeded")
			}
			if testCase.expectedErr == nil && err != nil {
				t.Errorf("should succeed but failed with %v", err)
			}
			if err == nil {
				if sameAddr != testCase.sameAddr {