} else {
		// Not safe to push the call. Just clobber the frame.
		c.set_rip(uint64(abi.FuncPCABI0(sigpanic0)))
	}
}

func (c *sigctxt) pushCall(targetPC, resumePC uintptr) {
	// Make it look like we called target at resumePC.
	sp := uintptr(c.rsp())
	sp -= goarch.PtrSize
	*(*uintptr)(unsafe.Pointer(sp)) = resumePC
	c.set_rsp(uint64(sp))
	c.set_rip(uint64(targetPC))

	if h.regArgs != nil {
		storeRegArgs(ctxt.regs(), h.regArgs)
	}
	// Push return PC.
	rsp -= goarch.PtrSize
	ctxt.set_rsp(rsp)
	// The signal PC is the next PC of the trap instruction.
	*(*uint64)(unsafe.Pointer(uintptr(rsp))) = ctxt.rip()
	// Set PC to call and context register.
	ctxt.set_rip(uint64(h.fv.fn))
	sigctxtSetContextRegister(ctxt, uint64(uintptr(unsafe.Pointer(h.fv))))
}

// case 1

func (c *sigctxt) sigcode() uint64 { return uint64(c.info._code) }
func (c *sigctxt) sigaddr() uint64 {
	return *(*uint64)(unsafe.Pointer(&c.info._reason[0]))
}

func (c *sigctxt) set_rip(x uint64)     { c.regs().__gregs[_REG_RIP] = x }
func (c *sigctxt) set_rsp(x uint64)     { c.regs().__gregs[_REG_RSP] = x }
func (c *sigctxt) set_sigcode(x uint64) { c.info._code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint64) {

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

	} else {
		// Not safe to push the call. Just clobber the frame.
		c.set_eip(uint32(abi.FuncPCABIInternal(sigpanic)))
	}
}

func (c *sigctxt) pushCall(targetPC, resumePC uintptr) {
	// Make it look like we called target at resumePC.
	sp := uintptr(c.esp())
	sp -= goarch.PtrSize
	*(*uintptr)(unsafe.Pointer(sp)) = resumePC
	c.set_esp(uint32(sp))
	c.set_eip(uint32(targetPC))

func (c *context) lr() uintptr      { return 0 }
func (c *context) set_lr(x uintptr) {}

func (c *context) set_ip(x uintptr) { c.eip = uint32(x) }
func (c *context) set_sp(x uintptr) { c.esp = uint32(x) }

// 386 does not have frame pointer register.
func (c *context) set_fp(x uintptr) {}

func prepareContextForSigResume(c *context) {
	c.edx = c.esp
	c.ecx = c.eip
}

func dumpregs(r *context) {

	sp := c.sp() - sys.MinFrameSize
	c.set_sp(sp)
	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.link()

	pc := gp.sigpc

	if shouldPushSigpanic(gp, pc, uintptr(c.link())) {
		// Make it look the like faulting PC called sigpanic.
		c.set_link(uint64(pc))
	}

	// In case we are panicking from external C code
	c.set_r0(0)
	c.set_r30(uint64(uintptr(unsafe.Pointer(gp))))
	c.set_r12(uint64(abi.FuncPCABIInternal(sigpanic)))

func (c *context) sp() uintptr { return uintptr(c.xsp) }
func (c *context) lr() uintptr { return uintptr(c.x[30]) }

func (c *context) set_ip(x uintptr) { c.pc = uint64(x) }
func (c *context) set_sp(x uintptr) { c.xsp = uint64(x) }
func (c *context) set_lr(x uintptr) { c.x[30] = uint64(x) }
func (c *context) set_fp(x uintptr) { c.x[29] = uint64(x) }

func prepareContextForSigResume(c *context) {
	c.x[0] = c.xsp
	c.x[1] = c.pc
}

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

func (c *sigctxt) set_r31(x uint64)  { c.regs().sc_regs[31] = x }
func (c *sigctxt) set_r22(x uint64)  { c.regs().sc_regs[22] = x }
func (c *sigctxt) set_pc(x uint64)   { c.regs().sc_pc = x }
func (c *sigctxt) set_sp(x uint64)   { c.regs().sc_regs[3] = x }
func (c *sigctxt) set_link(x uint64) { c.regs().sc_regs[1] = x }

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

func (c *sigctxt) set_r28(x uint64)  { c.regs().sc_regs[28] = x }
func (c *sigctxt) set_r30(x uint64)  { c.regs().sc_regs[30] = x }
func (c *sigctxt) set_pc(x uint64)   { c.regs().sc_pc = x }
func (c *sigctxt) set_sp(x uint64)   { c.regs().sc_regs[29] = x }
func (c *sigctxt) set_link(x uint64) { c.regs().sc_regs[31] = x }