1s_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
58cfg_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