edx               uint32
	ecx               uint32
	eax               uint32
	ebp               uint32
	eip               uint32
	segcs             uint32
	eflags            uint32
	esp               uint32
	segss             uint32
	extendedregisters [512]uint8
}

func (c *context) ip() uintptr { return uintptr(c.eip) }
func (c *context) sp() uintptr { return uintptr(c.esp) }

	print("ebp    ", hex(c.ebp()), "\n")
	print("esp    ", hex(c.esp()), "\n")
	print("eip    ", hex(c.eip()), "\n")
	print("eflags ", hex(c.eflags()), "\n")
	print("cs     ", hex(c.cs()), "\n")
	print("fs     ", hex(c.fs()), "\n")
	print("gs     ", hex(c.gs()), "\n")
}

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) sigpc() uintptr { return uintptr(c.eip()) }

func (c *sigctxt) sigsp() uintptr { return uintptr(c.esp()) }

func (c *sigctxt) ebp() uint32 { return c.regs().ebp }
func (c *sigctxt) esp() uint32 { return c.regs().esp }

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) eip() uint32 { return c.regs().eip }

func (c *sigctxt) eflags() uint32  { return c.regs().eflags }
func (c *sigctxt) cs() uint32      { return uint32(c.regs().cs) }
func (c *sigctxt) fs() uint32      { return uint32(c.regs().fs) }

        // prepare context to resume execution
        CONTEXT *c = ExceptionInfo->ContextRecord;
#ifdef _AMD64_
        c->Rip = *(DWORD64 *)c->Rsp;
        c->Rsp += 8;
#elif defined(_X86_)
        c->Eip = *(DWORD *)c->Esp;
        c->Esp += 4;
#else
        c->Pc = c->Lr;
#endif
#ifdef _ARM64_
        // TODO: remove when windows/arm64 supports SEH stack unwinding.
        return EXCEPTION_CONTINUE_EXECUTION;

	Ebx      int32
	Ecx      int32
	Edx      int32
	Esi      int32
	Edi      int32
	Ebp      int32
	Eax      int32
	Xds      int32
	Xes      int32
	Xfs      int32
	Xgs      int32
	Orig_eax int32
	Eip      int32
	Xcs      int32
	Eflags   int32
	Esp      int32
	Xss      int32
}

// PtraceGetRegs386 fetches the registers used by 386 binaries.
func PtraceGetRegs386(pid int, regsout *PtraceRegs386) error {

func (c *sigctxt) ebp() uint32 { return c.regs().mc_ebp }
func (c *sigctxt) esp() uint32 { return c.regs().mc_esp }

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) eip() uint32 { return c.regs().mc_eip }

func (c *sigctxt) eflags() uint32  { return c.regs().mc_eflags }
func (c *sigctxt) cs() uint32      { return c.regs().mc_cs }
func (c *sigctxt) fs() uint32      { return c.regs().mc_fs }

func (c *sigctxt) ebp() uint32 { return c.regs().sc_ebp }
func (c *sigctxt) esp() uint32 { return c.regs().sc_esp }

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) eip() uint32 { return c.regs().sc_eip }

func (c *sigctxt) eflags() uint32  { return c.regs().sc_eflags }
func (c *sigctxt) cs() uint32      { return c.regs().sc_cs }
func (c *sigctxt) fs() uint32      { return c.regs().sc_fs }

		if ipa, _ := netip.ParseAddr(host); ipa.IsValid() {
			// Use the 4-byte representation of the IP address when possible.
			ip := ipa.AsSlice()
			if ipa.Is4In6() {
				eip := ipa.As4()
				ip = eip[:]
			}
			ids = append(ids, Identity{Type: TypeIP, Value: ip})
		} else if strings.HasPrefix(host, spiffe.URIPrefix) {
			ids = append(ids, Identity{Type: TypeURI, Value: []byte(host)})
		} else {

func (c *sigctxt) ebp() uint32 { return c.regs().__gregs[_REG_EBP] }
func (c *sigctxt) esp() uint32 { return c.regs().__gregs[_REG_UESP] }

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) eip() uint32 { return c.regs().__gregs[_REG_EIP] }

func (c *sigctxt) eflags() uint32  { return c.regs().__gregs[_REG_EFL] }
func (c *sigctxt) cs() uint32      { return c.regs().__gregs[_REG_CS] }

	RSP:  "RSP",
	RBP:  "RBP",
	RSI:  "RSI",
	RDI:  "RDI",
	R8:   "R8",
	R9:   "R9",
	R10:  "R10",
	R11:  "R11",
	R12:  "R12",
	R13:  "R13",
	R14:  "R14",
	R15:  "R15",
	IP:   "IP",
	EIP:  "EIP",
	RIP:  "RIP",
	F0:   "F0",
	F1:   "F1",
	F2:   "F2",
	F3:   "F3",
	F4:   "F4",
	F5:   "F5",
	F6:   "F6",
	F7:   "F7",
	M0:   "M0",
	M1:   "M1",
	M2:   "M2",
	M3:   "M3",