Skip to content

Commit f290210

Browse files
borsbors
committed
Auto merge of #2357 - devnexen:haiku_ucontext, r=nielx,JohnTitor
haiku ucontext for x86_64
2 parents 2ebc7b2 + f0802f9 commit f290210

File tree

3 files changed

+283
-0
lines changed

3 files changed

+283
-0
lines changed

‎libc-test/build.rs

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3426,6 +3426,10 @@ fn test_haiku(target: &str) {
34263426
("sem_t", "named_sem_id") => true,
34273427
("sigaction", "sa_sigaction") => true,
34283428
("sigevent", "sigev_value") => true,
3429+
("fpu_state", "_fpreg") => true,
3430+
// these fields have a simplified data definition in libc
3431+
("fpu_state", "_xmm") => true,
3432+
("savefpu", "_fp_ymm") => true,
34293433

34303434
// skip these enum-type fields
34313435
("thread_info", "state") => true,

‎src/unix/haiku/mod.rs

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1560,5 +1560,20 @@ cfg_if! {
15601560
}
15611561
}
15621562

1563+
cfg_if! {
1564+
if #[cfg(target_arch = "x86")] {
1565+
// TODO
1566+
// mod x86;
1567+
// pub use self::x86::*;
1568+
} else if #[cfg(target_arch = "x86_64")] {
1569+
mod x86_64;
1570+
pub use self::x86_64::*;
1571+
} else if #[cfg(target_arch = "aarch64")] {
1572+
// TODO
1573+
// mod aarch64;
1574+
// pub use self::aarch64::*;
1575+
}
1576+
}
1577+
15631578
mod native;
15641579
pub use self::native::*;

‎src/unix/haiku/x86_64.rs

Lines changed: 264 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,264 @@
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+
}

0 commit comments

Comments
 (0)