Debian Codegraph @

libgrust/libformat_parser/vendor/libc/src/unix/haiku/x86_64.rs

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