safe_arch/x86_x64/
m128i_.rs

1//! This module is for the `m128i` wrapper type, its bonus methods, and all
2//! necessary trait impls.
3//!
4//! Intrinsics should _not_ be in this module! They should all be free-functions
5//! in the other modules, sorted by CPU target feature.
6
7use super::*;
8
9/// The data for a 128-bit SSE register of integer data.
10///
11/// * The exact layout to view the type as depends on the operation used.
12/// * `From` and `Into` impls are provided for all the relevant signed integer
13///   array types.
14/// * Formatting impls print as four `i32` values just because they have to pick
15///   something. If you want an alternative you can turn it into an array and
16///   print as you like.
17#[repr(transparent)]
18#[allow(non_camel_case_types)]
19pub struct m128i(pub __m128i);
20
21#[cfg(feature = "bytemuck")]
22unsafe impl bytemuck::Zeroable for m128i {}
23#[cfg(feature = "bytemuck")]
24unsafe impl bytemuck::Pod for m128i {}
25#[cfg(feature = "bytemuck")]
26unsafe impl bytemuck::TransparentWrapper<__m128i> for m128i {}
27
28impl Clone for m128i {
29  #[must_use]
30  #[inline(always)]
31  fn clone(&self) -> Self {
32    *self
33  }
34}
35impl Copy for m128i {}
36
37impl Default for m128i {
38  #[must_use]
39  #[inline(always)]
40  fn default() -> Self {
41    unsafe { core::mem::zeroed() }
42  }
43}
44
45// 8-bit
46
47impl From<[i8; 16]> for m128i {
48  #[must_use]
49  #[inline(always)]
50  fn from(arr: [i8; 16]) -> Self {
51    unsafe { core::mem::transmute(arr) }
52  }
53}
54
55impl From<m128i> for [i8; 16] {
56  #[must_use]
57  #[inline(always)]
58  fn from(m: m128i) -> Self {
59    unsafe { core::mem::transmute(m) }
60  }
61}
62
63impl From<[u8; 16]> for m128i {
64  #[must_use]
65  #[inline(always)]
66  fn from(arr: [u8; 16]) -> Self {
67    unsafe { core::mem::transmute(arr) }
68  }
69}
70
71impl From<m128i> for [u8; 16] {
72  #[must_use]
73  #[inline(always)]
74  fn from(m: m128i) -> Self {
75    unsafe { core::mem::transmute(m) }
76  }
77}
78
79// 16-bit
80
81impl From<[i16; 8]> for m128i {
82  #[must_use]
83  #[inline(always)]
84  fn from(arr: [i16; 8]) -> Self {
85    unsafe { core::mem::transmute(arr) }
86  }
87}
88
89impl From<m128i> for [i16; 8] {
90  #[must_use]
91  #[inline(always)]
92  fn from(m: m128i) -> Self {
93    unsafe { core::mem::transmute(m) }
94  }
95}
96
97impl From<[u16; 8]> for m128i {
98  #[must_use]
99  #[inline(always)]
100  fn from(arr: [u16; 8]) -> Self {
101    unsafe { core::mem::transmute(arr) }
102  }
103}
104
105impl From<m128i> for [u16; 8] {
106  #[must_use]
107  #[inline(always)]
108  fn from(m: m128i) -> Self {
109    unsafe { core::mem::transmute(m) }
110  }
111}
112
113// 32-bit
114
115impl From<[i32; 4]> for m128i {
116  #[must_use]
117  #[inline(always)]
118  fn from(arr: [i32; 4]) -> Self {
119    unsafe { core::mem::transmute(arr) }
120  }
121}
122
123impl From<m128i> for [i32; 4] {
124  #[must_use]
125  #[inline(always)]
126  fn from(m: m128i) -> Self {
127    unsafe { core::mem::transmute(m) }
128  }
129}
130
131impl From<[u32; 4]> for m128i {
132  #[must_use]
133  #[inline(always)]
134  fn from(arr: [u32; 4]) -> Self {
135    unsafe { core::mem::transmute(arr) }
136  }
137}
138
139impl From<m128i> for [u32; 4] {
140  #[must_use]
141  #[inline(always)]
142  fn from(m: m128i) -> Self {
143    unsafe { core::mem::transmute(m) }
144  }
145}
146
147// 64-bit
148
149impl From<[i64; 2]> for m128i {
150  #[must_use]
151  #[inline(always)]
152  fn from(arr: [i64; 2]) -> Self {
153    unsafe { core::mem::transmute(arr) }
154  }
155}
156
157impl From<m128i> for [i64; 2] {
158  #[must_use]
159  #[inline(always)]
160  fn from(m: m128i) -> Self {
161    unsafe { core::mem::transmute(m) }
162  }
163}
164
165impl From<[u64; 2]> for m128i {
166  #[must_use]
167  #[inline(always)]
168  fn from(arr: [u64; 2]) -> Self {
169    unsafe { core::mem::transmute(arr) }
170  }
171}
172
173impl From<m128i> for [u64; 2] {
174  #[must_use]
175  #[inline(always)]
176  fn from(m: m128i) -> Self {
177    unsafe { core::mem::transmute(m) }
178  }
179}
180
181// 128-bit
182
183impl From<i128> for m128i {
184  #[must_use]
185  #[inline(always)]
186  fn from(i: i128) -> Self {
187    unsafe { core::mem::transmute(i) }
188  }
189}
190
191impl From<m128i> for i128 {
192  #[must_use]
193  #[inline(always)]
194  fn from(m: m128i) -> Self {
195    unsafe { core::mem::transmute(m) }
196  }
197}
198
199impl From<u128> for m128i {
200  #[must_use]
201  #[inline(always)]
202  fn from(u: u128) -> Self {
203    unsafe { core::mem::transmute(u) }
204  }
205}
206
207impl From<m128i> for u128 {
208  #[must_use]
209  #[inline(always)]
210  fn from(m: m128i) -> Self {
211    unsafe { core::mem::transmute(m) }
212  }
213}
214
215//
216// PLEASE KEEP ALL THE FORMAT IMPL JUNK AT THE END OF THE FILE
217//
218
219impl Debug for m128i {
220  /// Debug formats each `i32`.
221  /// ```
222  /// # use safe_arch::*;
223  /// let f = format!("{:?}", m128i::default());
224  /// assert_eq!(&f, "m128i(0, 0, 0, 0)");
225  /// ```
226  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
227    write!(f, "m128i(")?;
228    for (i, int) in <[i32; 4]>::from(*self).iter().enumerate() {
229      if i != 0 {
230        write!(f, ", ")?;
231      }
232      Debug::fmt(int, f)?;
233    }
234    write!(f, ")")
235  }
236}
237
238impl Display for m128i {
239  /// Display formats each `i32`, and leaves the type name off of the font.
240  /// ```
241  /// # use safe_arch::*;
242  /// let f = format!("{}", m128i::default());
243  /// assert_eq!(&f, "(0, 0, 0, 0)");
244  /// ```
245  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
246    write!(f, "(")?;
247    for (i, int) in <[i32; 4]>::from(*self).iter().enumerate() {
248      if i != 0 {
249        write!(f, ", ")?;
250      }
251      Display::fmt(int, f)?;
252    }
253    write!(f, ")")
254  }
255}
256
257impl Binary for m128i {
258  /// Binary formats each `i32`.
259  /// ```
260  /// # use safe_arch::*;
261  /// let f = format!("{:b}", m128i::default());
262  /// assert_eq!(&f, "(0, 0, 0, 0)");
263  /// ```
264  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
265    write!(f, "(")?;
266    for (i, int) in <[i32; 4]>::from(*self).iter().enumerate() {
267      if i != 0 {
268        write!(f, ", ")?;
269      }
270      Binary::fmt(int, f)?;
271    }
272    write!(f, ")")
273  }
274}
275
276impl LowerExp for m128i {
277  /// LowerExp formats each `i32`.
278  /// ```
279  /// # use safe_arch::*;
280  /// let f = format!("{:e}", m128i::default());
281  /// assert_eq!(&f, "(0e0, 0e0, 0e0, 0e0)");
282  /// ```
283  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
284    write!(f, "(")?;
285    for (i, int) in <[i32; 4]>::from(*self).iter().enumerate() {
286      if i != 0 {
287        write!(f, ", ")?;
288      }
289      LowerExp::fmt(int, f)?;
290    }
291    write!(f, ")")
292  }
293}
294
295impl UpperExp for m128i {
296  /// UpperExp formats each `i32`.
297  /// ```
298  /// # use safe_arch::*;
299  /// let f = format!("{:E}", m128i::default());
300  /// assert_eq!(&f, "(0E0, 0E0, 0E0, 0E0)");
301  /// ```
302  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
303    write!(f, "(")?;
304    for (i, int) in <[i32; 4]>::from(*self).iter().enumerate() {
305      if i != 0 {
306        write!(f, ", ")?;
307      }
308      UpperExp::fmt(int, f)?;
309    }
310    write!(f, ")")
311  }
312}
313
314impl LowerHex for m128i {
315  /// LowerHex formats each `i32`.
316  /// ```
317  /// # use safe_arch::*;
318  /// let f = format!("{:x}", m128i::default());
319  /// assert_eq!(&f, "(0, 0, 0, 0)");
320  /// ```
321  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
322    write!(f, "(")?;
323    for (i, int) in <[i32; 4]>::from(*self).iter().enumerate() {
324      if i != 0 {
325        write!(f, ", ")?;
326      }
327      LowerHex::fmt(int, f)?;
328    }
329    write!(f, ")")
330  }
331}
332
333impl UpperHex for m128i {
334  /// UpperHex formats each `i32`.
335  /// ```
336  /// # use safe_arch::*;
337  /// let f = format!("{:X}", m128i::default());
338  /// assert_eq!(&f, "(0, 0, 0, 0)");
339  /// ```
340  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
341    write!(f, "(")?;
342    for (i, int) in <[i32; 4]>::from(*self).iter().enumerate() {
343      if i != 0 {
344        write!(f, ", ")?;
345      }
346      UpperHex::fmt(int, f)?;
347    }
348    write!(f, ")")
349  }
350}
351
352impl Octal for m128i {
353  /// Octal formats each `i32`.
354  /// ```
355  /// # use safe_arch::*;
356  /// let f = format!("{:o}", m128i::default());
357  /// assert_eq!(&f, "(0, 0, 0, 0)");
358  /// ```
359  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
360    write!(f, "(")?;
361    for (i, int) in <[i32; 4]>::from(*self).iter().enumerate() {
362      if i != 0 {
363        write!(f, ", ")?;
364      }
365      Octal::fmt(int, f)?;
366    }
367    write!(f, ")")
368  }
369}
safe_arch/x86_x64/m128i_.rs

safe_arch/x86_x64/
m128i_.rs
