| 1 |
s_no_extra_traits! { |
| 2 |
pub struct fpu_state { |
| 3 |
pub control: ::c_ushort, |
| 4 |
pub status: ::c_ushort, |
| 5 |
pub tag: ::c_ushort, |
| 6 |
pub opcode: ::c_ushort, |
| 7 |
pub rip: ::c_ulong, |
| 8 |
pub rdp: ::c_ulong, |
| 9 |
pub mxcsr: ::c_uint, |
| 10 |
pub mscsr_mask: ::c_uint, |
| 11 |
pub _fpreg: [[::c_uchar; 8]; 16], |
| 12 |
pub _xmm: [[::c_uchar; 16]; 16], |
| 13 |
pub _reserved_416_511: [::c_uchar; 96], |
| 14 |
} |
| 15 |
|
| 16 |
pub struct xstate_hdr { |
| 17 |
pub bv: ::c_ulong, |
| 18 |
pub xcomp_bv: ::c_ulong, |
| 19 |
pub _reserved: [::c_uchar; 48], |
| 20 |
} |
| 21 |
|
| 22 |
pub struct savefpu { |
| 23 |
pub fp_fxsave: fpu_state, |
| 24 |
pub fp_xstate: xstate_hdr, |
| 25 |
pub _fp_ymm: [[::c_uchar; 16]; 16], |
| 26 |
} |
| 27 |
|
| 28 |
pub struct mcontext_t { |
| 29 |
pub rax: ::c_ulong, |
| 30 |
pub rbx: ::c_ulong, |
| 31 |
pub rcx: ::c_ulong, |
| 32 |
pub rdx: ::c_ulong, |
| 33 |
pub rdi: ::c_ulong, |
| 34 |
pub rsi: ::c_ulong, |
| 35 |
pub rbp: ::c_ulong, |
| 36 |
pub r8: ::c_ulong, |
| 37 |
pub r9: ::c_ulong, |
| 38 |
pub r10: ::c_ulong, |
| 39 |
pub r11: ::c_ulong, |
| 40 |
pub r12: ::c_ulong, |
| 41 |
pub r13: ::c_ulong, |
| 42 |
pub r14: ::c_ulong, |
| 43 |
pub r15: ::c_ulong, |
| 44 |
pub rsp: ::c_ulong, |
| 45 |
pub rip: ::c_ulong, |
| 46 |
pub rflags: ::c_ulong, |
| 47 |
pub fpu: savefpu, |
| 48 |
} |
| 49 |
|
| 50 |
pub struct ucontext_t { |
| 51 |
pub uc_link: *mut ucontext_t, |
| 52 |
pub uc_sigmask: ::sigset_t, |
| 53 |
pub uc_stack: ::stack_t, |
| 54 |
pub uc_mcontext: mcontext_t, |
| 55 |
} |
| 56 |
} |
| 57 |
|
| 58 |
cfg_if! { |
| 59 |
if #[cfg(feature = "extra_traits")] { |
| 60 |
impl PartialEq for fpu_state { |
| 61 |
fn eq(&self, other: &fpu_state) -> bool { |
| 62 |
self.control == other.control |
| 63 |
&& self.status == other.status |
| 64 |
&& self.tag == other.tag |
| 65 |
&& self.opcode == other.opcode |
| 66 |
&& self.rip == other.rip |
| 67 |
&& self.rdp == other.rdp |
| 68 |
&& self.mxcsr == other.mxcsr |
| 69 |
&& self.mscsr_mask == other.mscsr_mask |
| 70 |
&& self._fpreg.iter().zip(other._fpreg.iter()).all(|(a, b)| a == b) |
| 71 |
&& self._xmm.iter().zip(other._xmm.iter()).all(|(a, b)| a == b) |
| 72 |
&& self._reserved_416_511. |
| 73 |
iter(). |
| 74 |
zip(other._reserved_416_511.iter()). |
| 75 |
all(|(a, b)| a == b) |
| 76 |
} |
| 77 |
} |
| 78 |
impl Eq for fpu_state {} |
| 79 |
impl ::fmt::Debug for fpu_state { |
| 80 |
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { |
| 81 |
f.debug_struct("fpu_state") |
| 82 |
.field("control", &self.control) |
| 83 |
.field("status", &self.status) |
| 84 |
.field("tag", &self.tag) |
| 85 |
.field("opcode", &self.opcode) |
| 86 |
.field("rip", &self.rip) |
| 87 |
.field("rdp", &self.rdp) |
| 88 |
.field("mxcsr", &self.mxcsr) |
| 89 |
.field("mscsr_mask", &self.mscsr_mask) |
| 90 |
// FIXME: .field("_fpreg", &self._fpreg) |
| 91 |
// FIXME: .field("_xmm", &self._xmm) |
| 92 |
// FIXME: .field("_reserved_416_511", &self._reserved_416_511) |
| 93 |
.finish() |
| 94 |
} |
| 95 |
} |
| 96 |
impl ::hash::Hash for fpu_state { |
| 97 |
fn hash<H: ::hash::Hasher>(&self, state: &mut H) { |
| 98 |
self.control.hash(state); |
| 99 |
self.status.hash(state); |
| 100 |
self.tag.hash(state); |
| 101 |
self.opcode.hash(state); |
| 102 |
self.rip.hash(state); |
| 103 |
self.rdp.hash(state); |
| 104 |
self.mxcsr.hash(state); |
| 105 |
self.mscsr_mask.hash(state); |
| 106 |
self._fpreg.hash(state); |
| 107 |
self._xmm.hash(state); |
| 108 |
self._reserved_416_511.hash(state); |
| 109 |
} |
| 110 |
} |
| 111 |
|
| 112 |
impl PartialEq for xstate_hdr { |
| 113 |
fn eq(&self, other: &xstate_hdr) -> bool { |
| 114 |
self.bv == other.bv |
| 115 |
&& self.xcomp_bv == other.xcomp_bv |
| 116 |
&& self._reserved.iter().zip(other._reserved.iter()).all(|(a, b)| a == b) |
| 117 |
} |
| 118 |
} |
| 119 |
impl Eq for xstate_hdr {} |
| 120 |
impl ::fmt::Debug for xstate_hdr { |
| 121 |
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { |
| 122 |
f.debug_struct("xstate_hdr") |
| 123 |
.field("bv", &self.bv) |
| 124 |
.field("xcomp_bv", &self.xcomp_bv) |
| 125 |
// FIXME: .field("_reserved", &field._reserved) |
| 126 |
.finish() |
| 127 |
} |
| 128 |
} |
| 129 |
impl ::hash::Hash for xstate_hdr { |
| 130 |
fn hash<H: ::hash::Hasher>(&self, state: &mut H) { |
| 131 |
self.bv.hash(state); |
| 132 |
self.xcomp_bv.hash(state); |
| 133 |
self._reserved.hash(state); |
| 134 |
} |
| 135 |
} |
| 136 |
|
| 137 |
impl PartialEq for savefpu { |
| 138 |
fn eq(&self, other: &savefpu) -> bool { |
| 139 |
self.fp_fxsave == other.fp_fxsave |
| 140 |
&& self.fp_xstate == other.fp_xstate |
| 141 |
&& self._fp_ymm.iter().zip(other._fp_ymm.iter()).all(|(a, b)| a == b) |
| 142 |
} |
| 143 |
} |
| 144 |
impl Eq for savefpu {} |
| 145 |
impl ::fmt::Debug for savefpu { |
| 146 |
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { |
| 147 |
f.debug_struct("savefpu") |
| 148 |
.field("fp_fxsave", &self.fp_fxsave) |
| 149 |
.field("fp_xstate", &self.fp_xstate) |
| 150 |
// FIXME: .field("_fp_ymm", &field._fp_ymm) |
| 151 |
.finish() |
| 152 |
} |
| 153 |
} |
| 154 |
impl ::hash::Hash for savefpu { |
| 155 |
fn hash<H: ::hash::Hasher>(&self, state: &mut H) { |
| 156 |
self.fp_fxsave.hash(state); |
| 157 |
self.fp_xstate.hash(state); |
| 158 |
self._fp_ymm.hash(state); |
| 159 |
} |
| 160 |
} |
| 161 |
|
| 162 |
impl PartialEq for mcontext_t { |
| 163 |
fn eq(&self, other: &mcontext_t) -> bool { |
| 164 |
self.rax == other.rax |
| 165 |
&& self.rbx == other.rbx |
| 166 |
&& self.rbx == other.rbx |
| 167 |
&& self.rcx == other.rcx |
| 168 |
&& self.rdx == other.rdx |
| 169 |
&& self.rdi == other.rdi |
| 170 |
&& self.rsi == other.rsi |
| 171 |
&& self.r8 == other.r8 |
| 172 |
&& self.r9 == other.r9 |
| 173 |
&& self.r10 == other.r10 |
| 174 |
&& self.r11 == other.r11 |
| 175 |
&& self.r12 == other.r12 |
| 176 |
&& self.r13 == other.r13 |
| 177 |
&& self.r14 == other.r14 |
| 178 |
&& self.r15 == other.r15 |
| 179 |
&& self.rsp == other.rsp |
| 180 |
&& self.rip == other.rip |
| 181 |
&& self.rflags == other.rflags |
| 182 |
&& self.fpu == other.fpu |
| 183 |
} |
| 184 |
} |
| 185 |
impl Eq for mcontext_t {} |
| 186 |
impl ::fmt::Debug for mcontext_t { |
| 187 |
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { |
| 188 |
f.debug_struct("mcontext_t") |
| 189 |
.field("rax", &self.rax) |
| 190 |
.field("rbx", &self.rbx) |
| 191 |
.field("rcx", &self.rcx) |
| 192 |
.field("rdx", &self.rdx) |
| 193 |
.field("rdi", &self.rdi) |
| 194 |
.field("rsi", &self.rsi) |
| 195 |
.field("rbp", &self.rbp) |
| 196 |
.field("r8", &self.r8) |
| 197 |
.field("r9", &self.r9) |
| 198 |
.field("r10", &self.r10) |
| 199 |
.field("r11", &self.r11) |
| 200 |
.field("r12", &self.r12) |
| 201 |
.field("r13", &self.r13) |
| 202 |
.field("r14", &self.r14) |
| 203 |
.field("r15", &self.r15) |
| 204 |
.field("rsp", &self.rsp) |
| 205 |
.field("rip", &self.rip) |
| 206 |
.field("rflags", &self.rflags) |
| 207 |
.field("fpu", &self.fpu) |
| 208 |
.finish() |
| 209 |
|
| 210 |
} |
| 211 |
} |
| 212 |
impl ::hash::Hash for mcontext_t { |
| 213 |
fn hash<H: ::hash::Hasher>(&self, state: &mut H) { |
| 214 |
self.rax.hash(state); |
| 215 |
self.rbx.hash(state); |
| 216 |
self.rcx.hash(state); |
| 217 |
self.rdx.hash(state); |
| 218 |
self.rdi.hash(state); |
| 219 |
self.rsi.hash(state); |
| 220 |
self.rbp.hash(state); |
| 221 |
self.r8.hash(state); |
| 222 |
self.r9.hash(state); |
| 223 |
self.r10.hash(state); |
| 224 |
self.r11.hash(state); |
| 225 |
self.r12.hash(state); |
| 226 |
self.r13.hash(state); |
| 227 |
self.r14.hash(state); |
| 228 |
self.r15.hash(state); |
| 229 |
self.rsp.hash(state); |
| 230 |
self.rip.hash(state); |
| 231 |
self.rflags.hash(state); |
| 232 |
self.fpu.hash(state); |
| 233 |
} |
| 234 |
} |
| 235 |
|
| 236 |
impl PartialEq for ucontext_t { |
| 237 |
fn eq(&self, other: &ucontext_t) -> bool { |
| 238 |
self.uc_link == other.uc_link |
| 239 |
&& self.uc_sigmask == other.uc_sigmask |
| 240 |
&& self.uc_stack == other.uc_stack |
| 241 |
&& self.uc_mcontext == other.uc_mcontext |
| 242 |
} |
| 243 |
} |
| 244 |
impl Eq for ucontext_t {} |
| 245 |
impl ::fmt::Debug for ucontext_t { |
| 246 |
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { |
| 247 |
f.debug_struct("ucontext_t") |
| 248 |
.field("uc_link", &self.uc_link) |
| 249 |
.field("uc_sigmask", &self.uc_sigmask) |
| 250 |
.field("uc_stack", &self.uc_stack) |
| 251 |
.field("uc_mcontext", &self.uc_mcontext) |
| 252 |
.finish() |
| 253 |
} |
| 254 |
} |
| 255 |
impl ::hash::Hash for ucontext_t { |
| 256 |
fn hash<H: ::hash::Hasher>(&self, state: &mut H) { |
| 257 |
self.uc_link.hash(state); |
| 258 |
self.uc_sigmask.hash(state); |
| 259 |
self.uc_stack.hash(state); |
| 260 |
self.uc_mcontext.hash(state); |
| 261 |
} |
| 262 |
} |
| 263 |
} |
| 264 |
} |