safe_arch/x86_x64/
m512i_.rs

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

safe_arch/x86_x64/
m512i_.rs
