safe_arch/x86_x64/
m256i_.rs

1//! This module is for the `m256i` 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 256-bit AVX 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 m256i(pub __m256i);
20
21#[cfg(feature = "bytemuck")]
22unsafe impl bytemuck::Zeroable for m256i {}
23#[cfg(feature = "bytemuck")]
24unsafe impl bytemuck::Pod for m256i {}
25#[cfg(feature = "bytemuck")]
26unsafe impl bytemuck::TransparentWrapper<__m256i> for m256i {}
27
28impl Clone for m256i {
29  #[inline(always)]
30  fn clone(&self) -> Self {
31    *self
32  }
33}
34impl Copy for m256i {}
35
36impl Default for m256i {
37  #[inline(always)]
38  fn default() -> Self {
39    unsafe { core::mem::zeroed() }
40  }
41}
42
43// 8-bit
44
45impl From<[i8; 32]> for m256i {
46  #[inline(always)]
47  fn from(arr: [i8; 32]) -> Self {
48    unsafe { core::mem::transmute(arr) }
49  }
50}
51
52impl From<m256i> for [i8; 32] {
53  #[inline(always)]
54  fn from(m: m256i) -> Self {
55    unsafe { core::mem::transmute(m) }
56  }
57}
58
59impl From<[u8; 32]> for m256i {
60  #[inline(always)]
61  fn from(arr: [u8; 32]) -> Self {
62    unsafe { core::mem::transmute(arr) }
63  }
64}
65
66impl From<m256i> for [u8; 32] {
67  #[inline(always)]
68  fn from(m: m256i) -> Self {
69    unsafe { core::mem::transmute(m) }
70  }
71}
72
73// 16-bit
74
75impl From<[i16; 16]> for m256i {
76  #[inline(always)]
77  fn from(arr: [i16; 16]) -> Self {
78    unsafe { core::mem::transmute(arr) }
79  }
80}
81
82impl From<m256i> for [i16; 16] {
83  #[inline(always)]
84  fn from(m: m256i) -> Self {
85    unsafe { core::mem::transmute(m) }
86  }
87}
88
89impl From<[u16; 16]> for m256i {
90  #[inline(always)]
91  fn from(arr: [u16; 16]) -> Self {
92    unsafe { core::mem::transmute(arr) }
93  }
94}
95
96impl From<m256i> for [u16; 16] {
97  #[inline(always)]
98  fn from(m: m256i) -> Self {
99    unsafe { core::mem::transmute(m) }
100  }
101}
102
103// 32-bit
104
105impl From<[i32; 8]> for m256i {
106  #[inline(always)]
107  fn from(arr: [i32; 8]) -> Self {
108    unsafe { core::mem::transmute(arr) }
109  }
110}
111
112impl From<m256i> for [i32; 8] {
113  #[inline(always)]
114  fn from(m: m256i) -> Self {
115    unsafe { core::mem::transmute(m) }
116  }
117}
118
119impl From<[u32; 8]> for m256i {
120  #[inline(always)]
121  fn from(arr: [u32; 8]) -> Self {
122    unsafe { core::mem::transmute(arr) }
123  }
124}
125
126impl From<m256i> for [u32; 8] {
127  #[inline(always)]
128  fn from(m: m256i) -> Self {
129    unsafe { core::mem::transmute(m) }
130  }
131}
132
133// 64-bit
134
135impl From<[i64; 4]> for m256i {
136  #[inline(always)]
137  fn from(arr: [i64; 4]) -> Self {
138    unsafe { core::mem::transmute(arr) }
139  }
140}
141
142impl From<m256i> for [i64; 4] {
143  #[inline(always)]
144  fn from(m: m256i) -> Self {
145    unsafe { core::mem::transmute(m) }
146  }
147}
148
149impl From<[u64; 4]> for m256i {
150  #[inline(always)]
151  fn from(arr: [u64; 4]) -> Self {
152    unsafe { core::mem::transmute(arr) }
153  }
154}
155
156impl From<m256i> for [u64; 4] {
157  #[inline(always)]
158  fn from(m: m256i) -> Self {
159    unsafe { core::mem::transmute(m) }
160  }
161}
162
163// 256-bit
164
165impl From<[i128; 2]> for m256i {
166  #[inline(always)]
167  fn from(i: [i128; 2]) -> Self {
168    unsafe { core::mem::transmute(i) }
169  }
170}
171
172impl From<m256i> for [i128; 2] {
173  #[inline(always)]
174  fn from(m: m256i) -> Self {
175    unsafe { core::mem::transmute(m) }
176  }
177}
178
179impl From<[u128; 2]> for m256i {
180  #[inline(always)]
181  fn from(u: [u128; 2]) -> Self {
182    unsafe { core::mem::transmute(u) }
183  }
184}
185
186impl From<m256i> for [u128; 2] {
187  #[inline(always)]
188  fn from(m: m256i) -> Self {
189    unsafe { core::mem::transmute(m) }
190  }
191}
192
193//
194// PLEASE KEEP ALL THE FORMAT IMPL JUNK AT THE END OF THE FILE
195//
196
197impl Debug for m256i {
198  /// Debug formats each `i32`.
199  /// ```
200  /// # use safe_arch::*;
201  /// let f = format!("{:?}", m256i::default());
202  /// assert_eq!(&f, "m256i(0, 0, 0, 0, 0, 0, 0, 0)");
203  /// ```
204  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
205    write!(f, "m256i(")?;
206    for (i, int) in <[i32; 8]>::from(*self).iter().enumerate() {
207      if i != 0 {
208        write!(f, ", ")?;
209      }
210      Debug::fmt(int, f)?;
211    }
212    write!(f, ")")
213  }
214}
215
216impl Display for m256i {
217  /// Display formats each `i32`, and leaves the type name off of the font.
218  /// ```
219  /// # use safe_arch::*;
220  /// let f = format!("{}", m256i::default());
221  /// assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");
222  /// ```
223  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
224    write!(f, "(")?;
225    for (i, int) in <[i32; 8]>::from(*self).iter().enumerate() {
226      if i != 0 {
227        write!(f, ", ")?;
228      }
229      Display::fmt(int, f)?;
230    }
231    write!(f, ")")
232  }
233}
234
235impl Binary for m256i {
236  /// Binary formats each `i32`.
237  /// ```
238  /// # use safe_arch::*;
239  /// let f = format!("{:b}", m256i::default());
240  /// assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");
241  /// ```
242  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
243    write!(f, "(")?;
244    for (i, int) in <[i32; 8]>::from(*self).iter().enumerate() {
245      if i != 0 {
246        write!(f, ", ")?;
247      }
248      Binary::fmt(int, f)?;
249    }
250    write!(f, ")")
251  }
252}
253
254impl LowerExp for m256i {
255  /// LowerExp formats each `i32`.
256  /// ```
257  /// # use safe_arch::*;
258  /// let f = format!("{:e}", m256i::default());
259  /// assert_eq!(&f, "(0e0, 0e0, 0e0, 0e0, 0e0, 0e0, 0e0, 0e0)");
260  /// ```
261  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
262    write!(f, "(")?;
263    for (i, int) in <[i32; 8]>::from(*self).iter().enumerate() {
264      if i != 0 {
265        write!(f, ", ")?;
266      }
267      LowerExp::fmt(int, f)?;
268    }
269    write!(f, ")")
270  }
271}
272
273impl UpperExp for m256i {
274  /// UpperExp formats each `i32`.
275  /// ```
276  /// # use safe_arch::*;
277  /// let f = format!("{:E}", m256i::default());
278  /// assert_eq!(&f, "(0E0, 0E0, 0E0, 0E0, 0E0, 0E0, 0E0, 0E0)");
279  /// ```
280  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
281    write!(f, "(")?;
282    for (i, int) in <[i32; 8]>::from(*self).iter().enumerate() {
283      if i != 0 {
284        write!(f, ", ")?;
285      }
286      UpperExp::fmt(int, f)?;
287    }
288    write!(f, ")")
289  }
290}
291
292impl LowerHex for m256i {
293  /// LowerHex formats each `i32`.
294  /// ```
295  /// # use safe_arch::*;
296  /// let f = format!("{:x}", m256i::default());
297  /// assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");
298  /// ```
299  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
300    write!(f, "(")?;
301    for (i, int) in <[i32; 8]>::from(*self).iter().enumerate() {
302      if i != 0 {
303        write!(f, ", ")?;
304      }
305      LowerHex::fmt(int, f)?;
306    }
307    write!(f, ")")
308  }
309}
310
311impl UpperHex for m256i {
312  /// UpperHex formats each `i32`.
313  /// ```
314  /// # use safe_arch::*;
315  /// let f = format!("{:X}", m256i::default());
316  /// assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");
317  /// ```
318  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
319    write!(f, "(")?;
320    for (i, int) in <[i32; 8]>::from(*self).iter().enumerate() {
321      if i != 0 {
322        write!(f, ", ")?;
323      }
324      UpperHex::fmt(int, f)?;
325    }
326    write!(f, ")")
327  }
328}
329
330impl Octal for m256i {
331  /// Octal formats each `i32`.
332  /// ```
333  /// # use safe_arch::*;
334  /// let f = format!("{:o}", m256i::default());
335  /// assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");
336  /// ```
337  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
338    write!(f, "(")?;
339    for (i, int) in <[i32; 8]>::from(*self).iter().enumerate() {
340      if i != 0 {
341        write!(f, ", ")?;
342      }
343      Octal::fmt(int, f)?;
344    }
345    write!(f, ")")
346  }
347}
safe_arch/x86_x64/m256i_.rs

safe_arch/x86_x64/
m256i_.rs
