1632 lines
39 KiB
D
1632 lines
39 KiB
D
/**
|
|
* D header file for POSIX.
|
|
*
|
|
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
|
* License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
|
|
* Authors: Sean Kelly
|
|
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
|
*/
|
|
|
|
/* Copyright Sean Kelly 2005 - 2009.
|
|
* Distributed under the Boost Software License, Version 1.0.
|
|
* (See accompanying file LICENSE or copy at
|
|
* http://www.boost.org/LICENSE_1_0.txt)
|
|
*/
|
|
module core.sys.posix.ucontext;
|
|
|
|
import core.sys.posix.config;
|
|
public import core.sys.posix.signal; // for sigset_t, stack_t
|
|
import core.stdc.stdint : uintptr_t;
|
|
|
|
version (Posix):
|
|
extern (C):
|
|
nothrow:
|
|
@nogc:
|
|
@system:
|
|
|
|
version (OSX)
|
|
version = Darwin;
|
|
else version (iOS)
|
|
version = Darwin;
|
|
else version (TVOS)
|
|
version = Darwin;
|
|
else version (WatchOS)
|
|
version = Darwin;
|
|
|
|
version (ARM) version = ARM_Any;
|
|
version (AArch64) version = ARM_Any;
|
|
version (MIPS32) version = MIPS_Any;
|
|
version (MIPS64) version = MIPS_Any;
|
|
version (PPC) version = PPC_Any;
|
|
version (PPC64) version = PPC_Any;
|
|
version (RISCV32) version = RISCV_Any;
|
|
version (RISCV64) version = RISCV_Any;
|
|
version (S390) version = IBMZ_Any;
|
|
version (SPARC) version = SPARC_Any;
|
|
version (SPARC64) version = SPARC_Any;
|
|
version (SystemZ) version = IBMZ_Any;
|
|
version (X86) version = X86_Any;
|
|
version (X86_64) version = X86_Any;
|
|
|
|
//
|
|
// XOpen (XSI)
|
|
//
|
|
/*
|
|
mcontext_t
|
|
|
|
struct ucontext_t
|
|
{
|
|
ucontext_t* uc_link;
|
|
sigset_t uc_sigmask;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
}
|
|
*/
|
|
|
|
version (linux)
|
|
{
|
|
version (X86_64)
|
|
{
|
|
enum
|
|
{
|
|
REG_R8 = 0,
|
|
REG_R9,
|
|
REG_R10,
|
|
REG_R11,
|
|
REG_R12,
|
|
REG_R13,
|
|
REG_R14,
|
|
REG_R15,
|
|
REG_RDI,
|
|
REG_RSI,
|
|
REG_RBP,
|
|
REG_RBX,
|
|
REG_RDX,
|
|
REG_RAX,
|
|
REG_RCX,
|
|
REG_RSP,
|
|
REG_RIP,
|
|
REG_EFL,
|
|
REG_CSGSFS, /* Actually short cs, gs, fs, __pad0. */
|
|
REG_ERR,
|
|
REG_TRAPNO,
|
|
REG_OLDMASK,
|
|
REG_CR2
|
|
}
|
|
|
|
private
|
|
{
|
|
struct _libc_fpxreg
|
|
{
|
|
ushort[4] significand;
|
|
ushort exponent;
|
|
ushort[3] padding;
|
|
}
|
|
|
|
struct _libc_xmmreg
|
|
{
|
|
uint[4] element;
|
|
}
|
|
|
|
struct _libc_fpstate
|
|
{
|
|
ushort cwd;
|
|
ushort swd;
|
|
ushort ftw;
|
|
ushort fop;
|
|
ulong rip;
|
|
ulong rdp;
|
|
uint mxcsr;
|
|
uint mxcr_mask;
|
|
_libc_fpxreg[8] _st;
|
|
_libc_xmmreg[16] _xmm;
|
|
uint[24] padding;
|
|
}
|
|
|
|
enum NGREG = 23;
|
|
|
|
alias long greg_t;
|
|
alias greg_t[NGREG] gregset_t;
|
|
alias _libc_fpstate* fpregset_t;
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
gregset_t gregs;
|
|
fpregset_t fpregs;
|
|
ulong[8] __reserved1;
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
sigset_t uc_sigmask;
|
|
_libc_fpstate __fpregs_mem;
|
|
version (CRuntime_Glibc)
|
|
ulong[4] __ssp;
|
|
}
|
|
}
|
|
else version (X86)
|
|
{
|
|
enum
|
|
{
|
|
REG_GS = 0,
|
|
REG_FS,
|
|
REG_ES,
|
|
REG_DS,
|
|
REG_EDI,
|
|
REG_ESI,
|
|
REG_EBP,
|
|
REG_ESP,
|
|
REG_EBX,
|
|
REG_EDX,
|
|
REG_ECX,
|
|
REG_EAX,
|
|
REG_TRAPNO,
|
|
REG_ERR,
|
|
REG_EIP,
|
|
REG_CS,
|
|
REG_EFL,
|
|
REG_UESP,
|
|
REG_SS
|
|
}
|
|
|
|
private
|
|
{
|
|
struct _libc_fpreg
|
|
{
|
|
ushort[4] significand;
|
|
ushort exponent;
|
|
}
|
|
|
|
struct _libc_fpstate
|
|
{
|
|
c_ulong cw;
|
|
c_ulong sw;
|
|
c_ulong tag;
|
|
c_ulong ipoff;
|
|
c_ulong cssel;
|
|
c_ulong dataoff;
|
|
c_ulong datasel;
|
|
_libc_fpreg[8] _st;
|
|
c_ulong status;
|
|
}
|
|
|
|
enum NGREG = 19;
|
|
|
|
alias int greg_t;
|
|
alias greg_t[NGREG] gregset_t;
|
|
alias _libc_fpstate* fpregset_t;
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
gregset_t gregs;
|
|
fpregset_t fpregs;
|
|
c_ulong oldmask;
|
|
c_ulong cr2;
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
sigset_t uc_sigmask;
|
|
_libc_fpstate __fpregs_mem;
|
|
version (CRuntime_Glibc)
|
|
c_ulong[4] __ssp;
|
|
}
|
|
}
|
|
else version (HPPA)
|
|
{
|
|
private
|
|
{
|
|
enum NGREG = 80;
|
|
enum NFPREG = 32;
|
|
|
|
alias c_ulong greg_t;
|
|
|
|
struct gregset_t
|
|
{
|
|
greg_t[32] g_regs;
|
|
greg_t[8] sr_regs;
|
|
greg_t[24] cr_regs;
|
|
greg_t[16] g_pad;
|
|
}
|
|
|
|
struct fpregset_t
|
|
{
|
|
double[32] fpregs;
|
|
}
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
greg_t sc_flags;
|
|
greg_t[32] sc_gr;
|
|
fpregset_t sc_fr;
|
|
greg_t[2] sc_iasq;
|
|
greg_t[2] sc_iaoq;
|
|
greg_t sc_sar;
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
sigset_t uc_sigmask;
|
|
}
|
|
}
|
|
else version (MIPS32)
|
|
{
|
|
private
|
|
{
|
|
enum NGREG = 32;
|
|
enum NFPREG = 32;
|
|
|
|
alias ulong greg_t;
|
|
alias greg_t[NGREG] gregset_t;
|
|
|
|
struct fpregset_t
|
|
{
|
|
union fp_r_t
|
|
{
|
|
double[NFPREG] fp_dregs;
|
|
static struct fp_fregs_t
|
|
{
|
|
float _fp_fregs;
|
|
uint _fp_pad;
|
|
} fp_fregs_t[NFPREG] fp_fregs;
|
|
} fp_r_t fp_r;
|
|
}
|
|
}
|
|
|
|
version (MIPS_O32)
|
|
{
|
|
struct mcontext_t
|
|
{
|
|
uint regmask;
|
|
uint status;
|
|
greg_t pc;
|
|
gregset_t gregs;
|
|
fpregset_t fpregs;
|
|
uint fp_owned;
|
|
uint fpc_csr;
|
|
uint fpc_eir;
|
|
uint used_math;
|
|
uint dsp;
|
|
greg_t mdhi;
|
|
greg_t mdlo;
|
|
c_ulong hi1;
|
|
c_ulong lo1;
|
|
c_ulong hi2;
|
|
c_ulong lo2;
|
|
c_ulong hi3;
|
|
c_ulong lo3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
struct mcontext_t
|
|
{
|
|
gregset_t gregs;
|
|
fpregset_t fpregs;
|
|
greg_t mdhi;
|
|
greg_t hi1;
|
|
greg_t hi2;
|
|
greg_t hi3;
|
|
greg_t mdlo;
|
|
greg_t lo1;
|
|
greg_t lo2;
|
|
greg_t lo3;
|
|
greg_t pc;
|
|
uint fpc_csr;
|
|
uint used_math;
|
|
uint dsp;
|
|
uint reserved;
|
|
}
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
sigset_t uc_sigmask;
|
|
}
|
|
}
|
|
else version (MIPS64)
|
|
{
|
|
private
|
|
{
|
|
enum NGREG = 32;
|
|
enum NFPREG = 32;
|
|
|
|
alias ulong greg_t;
|
|
alias greg_t[NGREG] gregset_t;
|
|
|
|
struct fpregset_t
|
|
{
|
|
union fp_r_t
|
|
{
|
|
double[NFPREG] fp_dregs;
|
|
static struct fp_fregs_t
|
|
{
|
|
float _fp_fregs;
|
|
uint _fp_pad;
|
|
} fp_fregs_t[NFPREG] fp_fregs;
|
|
} fp_r_t fp_r;
|
|
}
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
gregset_t gregs;
|
|
fpregset_t fpregs;
|
|
greg_t mdhi;
|
|
greg_t hi1;
|
|
greg_t hi2;
|
|
greg_t hi3;
|
|
greg_t mdlo;
|
|
greg_t lo1;
|
|
greg_t lo2;
|
|
greg_t lo3;
|
|
greg_t pc;
|
|
uint fpc_csr;
|
|
uint used_math;
|
|
uint dsp;
|
|
uint reserved;
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
sigset_t uc_sigmask;
|
|
}
|
|
}
|
|
else version (PPC)
|
|
{
|
|
private
|
|
{
|
|
enum NGREG = 48;
|
|
|
|
alias c_ulong greg_t;
|
|
alias greg_t[NGREG] gregset_t;
|
|
|
|
struct fpregset_t
|
|
{
|
|
double[32] fpregs;
|
|
double fpscr;
|
|
uint[2] _pad;
|
|
}
|
|
|
|
struct vrregset_t
|
|
{
|
|
uint[32][4] vrregs;
|
|
uint vrsave;
|
|
uint[2] __pad;
|
|
uint vscr;
|
|
}
|
|
|
|
struct pt_regs
|
|
{
|
|
c_ulong[32] gpr;
|
|
c_ulong nip;
|
|
c_ulong msr;
|
|
c_ulong orig_gpr3;
|
|
c_ulong ctr;
|
|
c_ulong link;
|
|
c_ulong xer;
|
|
c_ulong ccr;
|
|
c_ulong mq;
|
|
c_ulong trap;
|
|
c_ulong dar;
|
|
c_ulong dsisr;
|
|
c_ulong result;
|
|
}
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
gregset_t gregs;
|
|
fpregset_t fpregs;
|
|
align(16) vrregset_t vrregs;
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
int[7] uc_pad;
|
|
union uc_mcontext
|
|
{
|
|
pt_regs* regs;
|
|
mcontext_t* uc_regs;
|
|
}
|
|
sigset_t uc_sigmask;
|
|
char[mcontext_t.sizeof + 12] uc_reg_space = 0;
|
|
}
|
|
}
|
|
else version (PPC64)
|
|
{
|
|
private
|
|
{
|
|
enum NGREG = 48;
|
|
enum NFPREG = 33;
|
|
enum NVRREG = 34;
|
|
|
|
alias c_ulong greg_t;
|
|
alias greg_t[NGREG] gregset_t;
|
|
alias double[NFPREG] fpregset_t;
|
|
|
|
struct vscr_t
|
|
{
|
|
uint[3] __pad;
|
|
uint vscr_word;
|
|
}
|
|
|
|
struct vrregset_t
|
|
{
|
|
uint[32][4] vrregs;
|
|
vscr_t vscr;
|
|
uint vrsave;
|
|
uint[3] __pad;
|
|
}
|
|
|
|
struct pt_regs
|
|
{
|
|
c_ulong[32] gpr;
|
|
c_ulong nip;
|
|
c_ulong msr;
|
|
c_ulong orig_gpr3;
|
|
c_ulong ctr;
|
|
c_ulong link;
|
|
c_ulong xer;
|
|
c_ulong ccr;
|
|
c_ulong softe;
|
|
c_ulong trap;
|
|
c_ulong dar;
|
|
c_ulong dsisr;
|
|
c_ulong result;
|
|
}
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
c_ulong[4] __unused;
|
|
int signal;
|
|
int __pad0;
|
|
c_ulong handler;
|
|
c_ulong oldmask;
|
|
pt_regs* regs;
|
|
gregset_t gp_regs;
|
|
fpregset_t fp_regs;
|
|
vrregset_t *v_regs;
|
|
c_long[NVRREG+NVRREG+1] vmx_reserve;
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
sigset_t uc_sigmask;
|
|
mcontext_t uc_mcontext;
|
|
}
|
|
}
|
|
else version (ARM)
|
|
{
|
|
enum
|
|
{
|
|
R0 = 0,
|
|
R1 = 1,
|
|
R2 = 2,
|
|
R3 = 3,
|
|
R4 = 4,
|
|
R5 = 5,
|
|
R6 = 6,
|
|
R7 = 7,
|
|
R8 = 8,
|
|
R9 = 9,
|
|
R10 = 10,
|
|
R11 = 11,
|
|
R12 = 12,
|
|
R13 = 13,
|
|
R14 = 14,
|
|
R15 = 15
|
|
}
|
|
|
|
struct sigcontext
|
|
{
|
|
c_ulong trap_no;
|
|
c_ulong error_code;
|
|
c_ulong oldmask;
|
|
c_ulong arm_r0;
|
|
c_ulong arm_r1;
|
|
c_ulong arm_r2;
|
|
c_ulong arm_r3;
|
|
c_ulong arm_r4;
|
|
c_ulong arm_r5;
|
|
c_ulong arm_r6;
|
|
c_ulong arm_r7;
|
|
c_ulong arm_r8;
|
|
c_ulong arm_r9;
|
|
c_ulong arm_r10;
|
|
c_ulong arm_fp;
|
|
c_ulong arm_ip;
|
|
c_ulong arm_sp;
|
|
c_ulong arm_lr;
|
|
c_ulong arm_pc;
|
|
c_ulong arm_cpsr;
|
|
c_ulong fault_address;
|
|
}
|
|
|
|
//alias elf_fpregset_t fpregset_t;
|
|
alias sigcontext mcontext_t;
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
sigset_t uc_sigmask;
|
|
align(8) c_ulong[128] uc_regspace;
|
|
}
|
|
}
|
|
else version (AArch64)
|
|
{
|
|
alias int greg_t;
|
|
|
|
struct sigcontext {
|
|
ulong fault_address;
|
|
/* AArch64 registers */
|
|
ulong[31] regs;
|
|
ulong sp;
|
|
ulong pc;
|
|
ulong pstate;
|
|
/* 4K reserved for FP/SIMD state and future expansion */
|
|
align(16) ubyte[4096] __reserved;
|
|
}
|
|
|
|
alias sigcontext mcontext_t;
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
sigset_t uc_sigmask;
|
|
mcontext_t uc_mcontext;
|
|
}
|
|
}
|
|
else version (RISCV_Any)
|
|
{
|
|
private
|
|
{
|
|
alias c_ulong[32] __riscv_mc_gp_state;
|
|
|
|
struct __riscv_mc_f_ext_state
|
|
{
|
|
uint[32] __f;
|
|
uint __fcsr;
|
|
}
|
|
|
|
struct __riscv_mc_d_ext_state
|
|
{
|
|
ulong[32] __f;
|
|
uint __fcsr;
|
|
}
|
|
|
|
struct __riscv_mc_q_ext_state
|
|
{
|
|
align(16) ulong[64] __f;
|
|
uint __fcsr;
|
|
uint[3] __reserved;
|
|
}
|
|
|
|
union __riscv_mc_fp_state
|
|
{
|
|
__riscv_mc_f_ext_state __f;
|
|
__riscv_mc_d_ext_state __d;
|
|
__riscv_mc_q_ext_state __q;
|
|
}
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
__riscv_mc_gp_state __gregs;
|
|
__riscv_mc_fp_state __fpregs;
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
c_ulong __uc_flags;
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
sigset_t uc_sigmask;
|
|
char[1024 / 8 - sigset_t.sizeof] __reserved = 0;
|
|
mcontext_t uc_mcontext;
|
|
}
|
|
}
|
|
else version (SPARC_Any)
|
|
{
|
|
enum MC_NGREG = 19;
|
|
alias mc_greg_t = c_ulong;
|
|
alias mc_gregset_t = mc_greg_t[MC_NGREG];
|
|
|
|
struct mc_fq
|
|
{
|
|
c_ulong* mcfq_addr;
|
|
uint mcfq_insn;
|
|
}
|
|
|
|
struct mc_fpu_t
|
|
{
|
|
union mcfpu_fregs_t
|
|
{
|
|
uint[32] sregs;
|
|
c_ulong[32] dregs;
|
|
real[16] qregs;
|
|
}
|
|
mcfpu_fregs_t mcfpu_fregs;
|
|
c_ulong mcfpu_fsr;
|
|
c_ulong mcfpu_fprs;
|
|
c_ulong mcfpu_gsr;
|
|
mc_fq* mcfpu_fq;
|
|
ubyte mcfpu_qcnt;
|
|
ubyte mcfpu_qentsz;
|
|
ubyte mcfpu_enab;
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
mc_gregset_t mc_gregs;
|
|
mc_greg_t mc_fp;
|
|
mc_greg_t mc_i7;
|
|
mc_fpu_t mc_fpregs;
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
ucontext_t* uc_link;
|
|
c_ulong uc_flags;
|
|
c_ulong __uc_sigmask;
|
|
mcontext_t uc_mcontext;
|
|
stack_t uc_stack;
|
|
sigset_t uc_sigmask;
|
|
}
|
|
|
|
/* Location of the users' stored registers relative to R0.
|
|
* Usage is as an index into a gregset_t array. */
|
|
enum
|
|
{
|
|
REG_PSR = 0,
|
|
REG_PC = 1,
|
|
REG_nPC = 2,
|
|
REG_Y = 3,
|
|
REG_G1 = 4,
|
|
REG_G2 = 5,
|
|
REG_G3 = 6,
|
|
REG_G4 = 7,
|
|
REG_G5 = 8,
|
|
REG_G6 = 9,
|
|
REG_G7 = 10,
|
|
REG_O0 = 11,
|
|
REG_O1 = 12,
|
|
REG_O2 = 13,
|
|
REG_O3 = 14,
|
|
REG_O4 = 15,
|
|
REG_O5 = 16,
|
|
REG_O6 = 17,
|
|
REG_O7 = 18,
|
|
REG_ASI = 19,
|
|
REG_FPRS = 20,
|
|
}
|
|
|
|
enum NGREG = 21;
|
|
alias greg_t = c_ulong;
|
|
alias gregset_t = greg_t[NGREG];
|
|
}
|
|
else version (IBMZ_Any)
|
|
{
|
|
public import core.sys.posix.signal : sigset_t;
|
|
|
|
enum NGREG = 27;
|
|
|
|
alias greg_t = c_ulong;
|
|
alias gregset_t = align(8) greg_t[NGREG];
|
|
|
|
align(8) struct __psw_t
|
|
{
|
|
c_ulong mask;
|
|
c_ulong addr;
|
|
}
|
|
|
|
union fpreg_t
|
|
{
|
|
double d;
|
|
float f;
|
|
}
|
|
|
|
struct fpregset_t
|
|
{
|
|
uint fpc;
|
|
fpreg_t[16] fprs;
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
__psw_t psw;
|
|
c_ulong[16] gregs;
|
|
uint[16] aregs;
|
|
fpregset_t fpregs;
|
|
}
|
|
|
|
struct ucontext
|
|
{
|
|
c_ulong uc_flags;
|
|
ucontext* uc_link;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
sigset_t uc_sigmask;
|
|
}
|
|
|
|
alias ucontext_t = ucontext;
|
|
}
|
|
else
|
|
static assert(0, "unimplemented");
|
|
}
|
|
else version (Darwin)
|
|
{
|
|
private
|
|
{
|
|
version (X86_64)
|
|
{
|
|
struct __darwin_mcontext
|
|
{
|
|
ulong[89] __opaque;
|
|
}
|
|
static assert(__darwin_mcontext.sizeof == 712);
|
|
}
|
|
else version (X86)
|
|
{
|
|
struct __darwin_mcontext
|
|
{
|
|
uint[150] __opaque;
|
|
}
|
|
static assert(__darwin_mcontext.sizeof == 600);
|
|
}
|
|
else version (AArch64)
|
|
{
|
|
struct __darwin_mcontext
|
|
{
|
|
align(16) ulong[102] __opaque;
|
|
}
|
|
static assert(__darwin_mcontext.sizeof == 816);
|
|
}
|
|
else version (ARM)
|
|
{
|
|
struct __darwin_mcontext
|
|
{
|
|
uint[85] __opaque;
|
|
}
|
|
static assert(__darwin_mcontext.sizeof == 340);
|
|
}
|
|
else version (PPC_Any)
|
|
{
|
|
struct __darwin_mcontext
|
|
{
|
|
version (PPC64)
|
|
ulong[129] __opaque;
|
|
else
|
|
uint[258] __opaque;
|
|
}
|
|
static assert(__darwin_mcontext.sizeof == 1032);
|
|
}
|
|
else
|
|
static assert(false, "mcontext_t unimplemented for this platform.");
|
|
}
|
|
|
|
alias mcontext_t = __darwin_mcontext*;
|
|
|
|
struct ucontext
|
|
{
|
|
int uc_onstack;
|
|
sigset_t uc_sigmask;
|
|
stack_t uc_stack;
|
|
ucontext* uc_link;
|
|
size_t uc_mcsize;
|
|
__darwin_mcontext* uc_mcontext;
|
|
__darwin_mcontext __mcontext_data;
|
|
}
|
|
|
|
alias ucontext_t = ucontext;
|
|
}
|
|
else version (FreeBSD)
|
|
{
|
|
// <machine/ucontext.h>
|
|
version (X86_64)
|
|
{
|
|
alias long __register_t;
|
|
alias uint __uint32_t;
|
|
alias ushort __uint16_t;
|
|
|
|
struct mcontext_t {
|
|
__register_t mc_onstack;
|
|
__register_t mc_rdi;
|
|
__register_t mc_rsi;
|
|
__register_t mc_rdx;
|
|
__register_t mc_rcx;
|
|
__register_t mc_r8;
|
|
__register_t mc_r9;
|
|
__register_t mc_rax;
|
|
__register_t mc_rbx;
|
|
__register_t mc_rbp;
|
|
__register_t mc_r10;
|
|
__register_t mc_r11;
|
|
__register_t mc_r12;
|
|
__register_t mc_r13;
|
|
__register_t mc_r14;
|
|
__register_t mc_r15;
|
|
__uint32_t mc_trapno;
|
|
__uint16_t mc_fs;
|
|
__uint16_t mc_gs;
|
|
__register_t mc_addr;
|
|
__uint32_t mc_flags;
|
|
__uint16_t mc_es;
|
|
__uint16_t mc_ds;
|
|
__register_t mc_err;
|
|
__register_t mc_rip;
|
|
__register_t mc_cs;
|
|
__register_t mc_rflags;
|
|
__register_t mc_rsp;
|
|
__register_t mc_ss;
|
|
|
|
long mc_len; /* sizeof(mcontext_t) */
|
|
|
|
long mc_fpformat;
|
|
long mc_ownedfp;
|
|
|
|
align(16)
|
|
long[64] mc_fpstate;
|
|
|
|
__register_t mc_fsbase;
|
|
__register_t mc_gsbase;
|
|
|
|
long[6] mc_spare;
|
|
}
|
|
}
|
|
else version (X86)
|
|
{
|
|
alias int __register_t;
|
|
|
|
struct mcontext_t
|
|
{
|
|
__register_t mc_onstack;
|
|
__register_t mc_gs;
|
|
__register_t mc_fs;
|
|
__register_t mc_es;
|
|
__register_t mc_ds;
|
|
__register_t mc_edi;
|
|
__register_t mc_esi;
|
|
__register_t mc_ebp;
|
|
__register_t mc_isp;
|
|
__register_t mc_ebx;
|
|
__register_t mc_edx;
|
|
__register_t mc_ecx;
|
|
__register_t mc_eax;
|
|
__register_t mc_trapno;
|
|
__register_t mc_err;
|
|
__register_t mc_eip;
|
|
__register_t mc_cs;
|
|
__register_t mc_eflags;
|
|
__register_t mc_esp;
|
|
__register_t mc_ss;
|
|
|
|
int mc_len;
|
|
int mc_fpformat;
|
|
int mc_ownedfp;
|
|
int[1] mc_spare1;
|
|
|
|
align(16)
|
|
int[128] mc_fpstate;
|
|
|
|
__register_t mc_fsbase;
|
|
__register_t mc_gsbase;
|
|
|
|
int[6] mc_spare2;
|
|
}
|
|
}
|
|
else version (AArch64)
|
|
{
|
|
alias __register_t = long;
|
|
|
|
struct gpregs
|
|
{
|
|
__register_t[30] gp_x;
|
|
__register_t gp_lr;
|
|
__register_t gp_sp;
|
|
__register_t gp_elr;
|
|
uint gp_spsr;
|
|
int gp_pad;
|
|
}
|
|
|
|
struct fpregs
|
|
{
|
|
ulong[2][32] fp_q; // __uint128_t
|
|
uint fp_sr;
|
|
uint fp_cr;
|
|
int fp_flags;
|
|
int fp_pad;
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
gpregs mc_gpregs;
|
|
fpregs mc_fpregs;
|
|
int mc_flags;
|
|
int mc_pad;
|
|
ulong[8] mc_spare;
|
|
}
|
|
}
|
|
else version (PPC_Any)
|
|
{
|
|
alias size_t __register_t;
|
|
alias uint __uint32_t;
|
|
alias ulong __uint64_t;
|
|
|
|
struct mcontext_t {
|
|
int mc_vers;
|
|
int mc_flags;
|
|
enum _MC_FP_VALID = 0x01;
|
|
enum _MC_AV_VALID = 0x02;
|
|
int mc_onstack;
|
|
int mc_len;
|
|
__uint64_t[32 * 2] mc_avec;
|
|
__uint32_t[2] mc_av;
|
|
__register_t[42] mc_frame;
|
|
__uint64_t[33] mc_fpreg;
|
|
__uint64_t[32] mc_vsxfpreg;
|
|
}
|
|
}
|
|
|
|
// <ucontext.h>
|
|
enum UCF_SWAPPED = 0x00000001;
|
|
|
|
struct ucontext_t
|
|
{
|
|
sigset_t uc_sigmask;
|
|
mcontext_t uc_mcontext;
|
|
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
int uc_flags;
|
|
int[4] __spare__;
|
|
}
|
|
}
|
|
else version (NetBSD)
|
|
{
|
|
version (X86_64)
|
|
{
|
|
private
|
|
{
|
|
enum _NGREG = 26;
|
|
alias __greg_t = c_ulong;
|
|
alias __gregset_t = __greg_t[_NGREG];
|
|
alias __fpregset_t = align(8) ubyte[512];
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
__gregset_t __gregs;
|
|
__greg_t _mc_tlsbase;
|
|
__fpregset_t __fpregs;
|
|
}
|
|
}
|
|
else version (X86)
|
|
{
|
|
private
|
|
{
|
|
enum _NGREG = 19;
|
|
alias __greg_t = int;
|
|
alias __gregset_t = __greg_t[_NGREG];
|
|
struct __fpregset_t
|
|
{
|
|
union fp_reg_set_t
|
|
{
|
|
struct fpchip_state_t
|
|
{
|
|
int[27] __fp_state;
|
|
}
|
|
struct fp_xmm_state_t
|
|
{
|
|
ubyte[512] __fp_xmm;
|
|
}
|
|
fpchip_state_t __fpchip_state;
|
|
fp_xmm_state_t __fp_xmm_state;
|
|
int[128] __fp_fpregs;
|
|
}
|
|
fp_reg_set_t __fp_reg_set;
|
|
int[33] __fp_pad;
|
|
}
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
__gregset_t __gregs;
|
|
__fpregset_t __fpregs;
|
|
__greg_t _mc_tlsbase;
|
|
}
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
uint uc_flags; /* properties */
|
|
ucontext_t * uc_link; /* context to resume */
|
|
sigset_t uc_sigmask; /* signals blocked in this context */
|
|
stack_t uc_stack; /* the stack used by this context */
|
|
mcontext_t uc_mcontext; /* machine state */
|
|
/+ todo #if defined(_UC_MACHINE_PAD)
|
|
long __uc_pad[_UC_MACHINE_PAD];
|
|
#endif
|
|
+/
|
|
}
|
|
}
|
|
else version (OpenBSD)
|
|
{
|
|
version (Alpha)
|
|
{
|
|
struct sigcontext
|
|
{
|
|
c_long sc_cookie;
|
|
c_long sc_mask;
|
|
c_long sc_pc;
|
|
c_long sc_ps;
|
|
c_ulong[32] sc_regs;
|
|
c_long sc_ownedfp;
|
|
c_ulong[32] sc_fpregs;
|
|
c_ulong sc_fpcr;
|
|
c_ulong sc_fp_control;
|
|
c_long[2] sc_reserved;
|
|
c_long[8] sc_xxx;
|
|
}
|
|
}
|
|
else version (X86_64)
|
|
{
|
|
struct sigcontext
|
|
{
|
|
c_long sc_rdi;
|
|
c_long sc_rsi;
|
|
c_long sc_rdx;
|
|
c_long sc_rcx;
|
|
c_long sc_r8;
|
|
c_long sc_r9;
|
|
c_long sc_r10;
|
|
c_long sc_r11;
|
|
c_long sc_r12;
|
|
c_long sc_r13;
|
|
c_long sc_r14;
|
|
c_long sc_r15;
|
|
c_long sc_rbp;
|
|
c_long sc_rbx;
|
|
c_long sc_rax;
|
|
c_long sc_gs;
|
|
c_long sc_fs;
|
|
c_long sc_es;
|
|
c_long sc_ds;
|
|
c_long sc_trapno;
|
|
c_long sc_err;
|
|
c_long sc_rip;
|
|
c_long sc_cs;
|
|
c_long sc_rflags;
|
|
c_long sc_rsp;
|
|
c_long sc_ss;
|
|
void* sc_fpstate; // struct fxsave64*
|
|
int __sc_unused;
|
|
int sc_mask;
|
|
c_long sc_cookie;
|
|
}
|
|
}
|
|
else version (AArch64)
|
|
{
|
|
struct sigcontext
|
|
{
|
|
int __sc_unused;
|
|
int sc_mask;
|
|
c_ulong sc_sp;
|
|
c_ulong sc_lr;
|
|
c_ulong sc_elr;
|
|
c_ulong sc_spsr;
|
|
c_ulong[30] sc_x;
|
|
c_long sc_cookie;
|
|
}
|
|
}
|
|
else version (ARM)
|
|
{
|
|
struct sigcontext
|
|
{
|
|
c_long sc_cookie;
|
|
int sc_mask;
|
|
uint sc_spsr;
|
|
uint sc_r0;
|
|
uint sc_r1;
|
|
uint sc_r2;
|
|
uint sc_r3;
|
|
uint sc_r4;
|
|
uint sc_r5;
|
|
uint sc_r6;
|
|
uint sc_r7;
|
|
uint sc_r8;
|
|
uint sc_r9;
|
|
uint sc_r10;
|
|
uint sc_r11;
|
|
uint sc_r12;
|
|
uint sc_usr_sp;
|
|
uint sc_usr_lr;
|
|
uint sc_svc_lr;
|
|
uint sc_pc;
|
|
uint sc_fpused;
|
|
uint sc_fpscr;
|
|
ulong[32] sc_fpreg;
|
|
}
|
|
}
|
|
else version (HPPA)
|
|
{
|
|
struct sigcontext
|
|
{
|
|
c_ulong __sc_unused;
|
|
c_long sc_mask;
|
|
c_ulong sc_ps;
|
|
c_ulong sc_fp;
|
|
c_ulong sc_pcoqh;
|
|
c_ulong sc_pcoqt;
|
|
c_ulong[2] sc_resv;
|
|
c_ulong[32] sc_regs;
|
|
c_ulong[64] sc_fpregs;
|
|
c_long sc_cookie;
|
|
}
|
|
}
|
|
else version (X86)
|
|
{
|
|
struct sigcontext
|
|
{
|
|
int sc_gs;
|
|
int sc_fs;
|
|
int sc_es;
|
|
int sc_ds;
|
|
int sc_edi;
|
|
int sc_esi;
|
|
int sc_ebp;
|
|
int sc_ebx;
|
|
int sc_edx;
|
|
int sc_ecx;
|
|
int sc_eax;
|
|
int sc_eip;
|
|
int sc_cs;
|
|
int sc_eflags;
|
|
int sc_esp;
|
|
int sc_ss;
|
|
c_long sc_cookie;
|
|
int sc_mask;
|
|
int sc_trapno;
|
|
int sc_err;
|
|
void* sc_fpstate; // union savefpu*
|
|
}
|
|
}
|
|
else version (PPC)
|
|
{
|
|
private struct trapframe
|
|
{
|
|
c_long[32] fixreg;
|
|
c_long lr;
|
|
c_long cr;
|
|
c_long xer;
|
|
c_long ctr;
|
|
int srr0;
|
|
int srr1;
|
|
int dar;
|
|
int dsisr;
|
|
c_long exc;
|
|
}
|
|
|
|
struct sigcontext
|
|
{
|
|
c_long sc_cookie;
|
|
int sc_mask;
|
|
trapframe sc_frame;
|
|
}
|
|
}
|
|
else version (SPARC64)
|
|
{
|
|
struct sigcontext
|
|
{
|
|
c_long sc_cookie;
|
|
c_long sc_sp;
|
|
c_long sc_pc;
|
|
c_long sc_npc;
|
|
c_long sc_tstate;
|
|
c_long sc_g1;
|
|
c_long sc_o0;
|
|
int sc_mask;
|
|
}
|
|
}
|
|
else
|
|
static assert(false, "Architecture not supported.");
|
|
|
|
alias ucontext_t = sigcontext;
|
|
}
|
|
else version (DragonFlyBSD)
|
|
{
|
|
// <machine/ucontext.h>
|
|
version (X86_64)
|
|
{
|
|
alias long __register_t;
|
|
alias uint __uint32_t;
|
|
alias ushort __uint16_t;
|
|
|
|
struct mcontext_t {
|
|
__register_t mc_onstack;
|
|
__register_t mc_rdi;
|
|
__register_t mc_rsi;
|
|
__register_t mc_rdx;
|
|
__register_t mc_rcx;
|
|
__register_t mc_r8;
|
|
__register_t mc_r9;
|
|
__register_t mc_rax;
|
|
__register_t mc_rbx;
|
|
__register_t mc_rbp;
|
|
__register_t mc_r10;
|
|
__register_t mc_r11;
|
|
__register_t mc_r12;
|
|
__register_t mc_r13;
|
|
__register_t mc_r14;
|
|
__register_t mc_r15;
|
|
__register_t mc_xflags;
|
|
__register_t mc_trapno;
|
|
__register_t mc_addr;
|
|
__register_t mc_flags;
|
|
__register_t mc_err;
|
|
__register_t mc_rip;
|
|
__register_t mc_cs;
|
|
__register_t mc_rflags;
|
|
__register_t mc_rsp;
|
|
__register_t mc_ss;
|
|
|
|
uint mc_len;
|
|
uint mc_fpformat;
|
|
uint mc_ownedfp;
|
|
uint mc_reserved;
|
|
uint[8] mc_unused;
|
|
int[256] mc_fpregs;
|
|
} // __attribute__((aligned(64)));
|
|
}
|
|
else
|
|
{
|
|
static assert(0, "Only X86_64 support on DragonFlyBSD");
|
|
}
|
|
|
|
// <ucontext.h>
|
|
enum UCF_SWAPPED = 0x00000001;
|
|
|
|
struct ucontext_t
|
|
{
|
|
sigset_t uc_sigmask;
|
|
mcontext_t uc_mcontext;
|
|
|
|
ucontext_t* uc_link;
|
|
stack_t uc_stack;
|
|
void function(ucontext_t *, void *) uc_cofunc;
|
|
void* uc_arg;
|
|
int[4] __spare__;
|
|
}
|
|
}
|
|
else version (Solaris)
|
|
{
|
|
import core.stdc.stdint;
|
|
|
|
alias uint[4] upad128_t;
|
|
|
|
version (SPARC64)
|
|
{
|
|
enum _NGREG = 21;
|
|
alias long greg_t;
|
|
}
|
|
else version (SPARC)
|
|
{
|
|
enum _NGREG = 19;
|
|
alias int greg_t;
|
|
}
|
|
else version (X86_64)
|
|
{
|
|
enum _NGREG = 28;
|
|
alias long greg_t;
|
|
}
|
|
else version (X86)
|
|
{
|
|
enum _NGREG = 19;
|
|
alias int greg_t;
|
|
}
|
|
else
|
|
static assert(0, "unimplemented");
|
|
|
|
alias greg_t[_NGREG] gregset_t;
|
|
|
|
version (SPARC64)
|
|
{
|
|
private
|
|
{
|
|
struct _fpq
|
|
{
|
|
uint *fpq_addr;
|
|
uint fpq_instr;
|
|
}
|
|
|
|
struct fq
|
|
{
|
|
union
|
|
{
|
|
double whole;
|
|
_fpq fpq;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct fpregset_t
|
|
{
|
|
union
|
|
{
|
|
uint[32] fpu_regs;
|
|
double[32] fpu_dregs;
|
|
real[16] fpu_qregs;
|
|
}
|
|
fq *fpu_q;
|
|
ulong fpu_fsr;
|
|
ubyte fpu_qcnt;
|
|
ubyte fpu_q_entrysize;
|
|
ubyte fpu_en;
|
|
}
|
|
}
|
|
else version (SPARC)
|
|
{
|
|
private
|
|
{
|
|
struct _fpq
|
|
{
|
|
uint *fpq_addr;
|
|
uint fpq_instr;
|
|
}
|
|
|
|
struct fq
|
|
{
|
|
union
|
|
{
|
|
double whole;
|
|
_fpq fpq;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct fpregset_t
|
|
{
|
|
union
|
|
{
|
|
uint[32] fpu_regs;
|
|
double[16] fpu_dregs;
|
|
}
|
|
fq *fpu_q;
|
|
uint fpu_fsr;
|
|
ubyte fpu_qcnt;
|
|
ubyte fpu_q_entrysize;
|
|
ubyte fpu_en;
|
|
}
|
|
}
|
|
else version (X86_64)
|
|
{
|
|
private
|
|
{
|
|
union _u_st
|
|
{
|
|
ushort[5] fpr_16;
|
|
upad128_t __fpr_pad;
|
|
}
|
|
}
|
|
|
|
struct fpregset_t
|
|
{
|
|
union fp_reg_set
|
|
{
|
|
struct fpchip_state
|
|
{
|
|
ushort cw;
|
|
ushort sw;
|
|
ubyte fctw;
|
|
ubyte __fx_rsvd;
|
|
ushort fop;
|
|
ulong rip;
|
|
ulong rdp;
|
|
uint mxcsr;
|
|
uint mxcsr_mask;
|
|
_u_st[8] st;
|
|
upad128_t[16] xmm;
|
|
upad128_t[6] __fx_ign2;
|
|
uint status;
|
|
uint xstatus;
|
|
}
|
|
uint[130] f_fpregs;
|
|
}
|
|
}
|
|
}
|
|
else version (X86)
|
|
{
|
|
struct fpregset_t
|
|
{
|
|
union u_fp_reg_set
|
|
{
|
|
struct s_fpchip_state
|
|
{
|
|
uint[27] state;
|
|
uint status;
|
|
uint mxcsr;
|
|
uint xstatus;
|
|
uint[2] __pad;
|
|
upad128_t[8] xmm;
|
|
}
|
|
s_fpchip_state fpchip_state;
|
|
|
|
struct s_fp_emul_space
|
|
{
|
|
ubyte[246] fp_emul;
|
|
ubyte[2] fp_epad;
|
|
}
|
|
s_fp_emul_space fp_emul_space;
|
|
uint[95] f_fpregs;
|
|
}
|
|
u_fp_reg_set fp_reg_set;
|
|
}
|
|
}
|
|
else
|
|
static assert(0, "unimplemented");
|
|
|
|
version (SPARC_Any)
|
|
{
|
|
private
|
|
{
|
|
struct rwindow
|
|
{
|
|
greg_t[8] rw_local;
|
|
greg_t[8] rw_in;
|
|
}
|
|
|
|
struct gwindows_t
|
|
{
|
|
int wbcnt;
|
|
greg_t[31] *spbuf;
|
|
rwindow[31] wbuf;
|
|
}
|
|
|
|
struct xrs_t
|
|
{
|
|
uint xrs_id;
|
|
caddr_t xrs_ptr;
|
|
}
|
|
|
|
struct cxrs_t
|
|
{
|
|
uint cxrs_id;
|
|
caddr_t cxrs_ptr;
|
|
}
|
|
|
|
alias int64_t[16] asrset_t;
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
gregset_t gregs;
|
|
gwindows_t *gwins;
|
|
fpregset_t fpregs;
|
|
xrs_t xrs;
|
|
version (SPARC64)
|
|
{
|
|
asrset_t asrs;
|
|
cxrs_t cxrs;
|
|
c_long[2] filler;
|
|
}
|
|
else version (SPARC)
|
|
{
|
|
cxrs_t cxrs;
|
|
c_long[17] filler;
|
|
}
|
|
}
|
|
}
|
|
else version (X86_Any)
|
|
{
|
|
private
|
|
{
|
|
struct xrs_t
|
|
{
|
|
uint xrs_id;
|
|
caddr_t xrs_ptr;
|
|
}
|
|
}
|
|
|
|
struct mcontext_t
|
|
{
|
|
gregset_t gregs;
|
|
fpregset_t fpregs;
|
|
}
|
|
}
|
|
|
|
struct ucontext_t
|
|
{
|
|
version (SPARC_Any)
|
|
uint uc_flags;
|
|
else version (X86_Any)
|
|
c_ulong uc_flags;
|
|
ucontext_t *uc_link;
|
|
sigset_t uc_sigmask;
|
|
stack_t uc_stack;
|
|
mcontext_t uc_mcontext;
|
|
version (SPARC64)
|
|
c_long[4] uc_filler;
|
|
else version (SPARC)
|
|
c_long[23] uc_filler;
|
|
else version (X86_Any)
|
|
{
|
|
xrs_t uc_xrs;
|
|
c_long[3] uc_filler;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Obsolescent (OB)
|
|
//
|
|
/*
|
|
int getcontext(ucontext_t*);
|
|
void makecontext(ucontext_t*, void function(), int, ...);
|
|
int setcontext(const scope ucontext_t*);
|
|
int swapcontext(ucontext_t*, const scope ucontext_t*);
|
|
*/
|
|
|
|
static if ( is( ucontext_t ) )
|
|
{
|
|
int getcontext(ucontext_t*);
|
|
|
|
version (Solaris)
|
|
{
|
|
version (SPARC_Any)
|
|
{
|
|
void __makecontext_v2(ucontext_t*, void function(), int, ...);
|
|
alias makecontext = __makecontext_v2;
|
|
}
|
|
else
|
|
void makecontext(ucontext_t*, void function(), int, ...);
|
|
}
|
|
else
|
|
void makecontext(ucontext_t*, void function(), int, ...);
|
|
|
|
int setcontext(const scope ucontext_t*);
|
|
int swapcontext(ucontext_t*, const scope ucontext_t*);
|
|
}
|
|
|
|
version (Solaris)
|
|
{
|
|
int walkcontext(const scope ucontext_t*, int function(uintptr_t, int, void*), void*);
|
|
int addrtosymstr(uintptr_t, char*, int);
|
|
int printstack(int);
|
|
}
|
|
|