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 } 265