1use super::arch;
2use arch::*;
3
4macro_rules! __impl {
5 ($name: ident, $feature: tt) => {
6 impl $name {
7 #[inline(always)]
10 pub const unsafe fn new_unchecked() -> Self {
11 Self { __private: () }
12 }
13
14 #[inline(always)]
15 pub fn try_new() -> Option<Self> {
16 if feature_detected!($feature) {
17 Some(Self { __private: () })
18 } else {
19 None
20 }
21 }
22
23 #[inline(always)]
24 pub fn is_available() -> bool {
25 feature_detected!($feature)
26 }
27 }
28
29 impl ::core::fmt::Debug for $name {
30 #[inline]
31 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
32 f.write_str(stringify!($name))
33 }
34 }
35 };
36}
37
38macro_rules! __impl512 {
39 ($name: ident, $feature: tt) => {
40 impl $name {
41 #[inline(always)]
44 pub const unsafe fn new_unchecked() -> Self {
45 Self { __private: () }
46 }
47
48 #[inline(always)]
49 pub fn try_new() -> Option<Self> {
50 if Self::is_available() {
51 Some(Self { __private: () })
52 } else {
53 None
54 }
55 }
56
57 #[inline(always)]
58 pub fn is_available() -> bool {
59 feature_detected!($feature) && feature_detected!("avx512vl")
60 }
61 }
62
63 impl ::core::fmt::Debug for $name {
64 #[inline]
65 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
66 f.write_str(stringify!($name))
67 }
68 }
69 };
70}
71
72#[derive(Clone, Copy)]
73#[repr(transparent)]
74pub struct Aes {
75 __private: (),
76}
77__impl!(Aes, "aes");
78#[derive(Clone, Copy)]
79#[repr(transparent)]
80pub struct Pclmulqdq {
81 __private: (),
82}
83__impl!(Pclmulqdq, "pclmulqdq");
84#[derive(Clone, Copy)]
85#[repr(transparent)]
86pub struct Rdrand {
87 __private: (),
88}
89__impl!(Rdrand, "rdrand");
90#[derive(Clone, Copy)]
91#[repr(transparent)]
92pub struct Rdseed {
93 __private: (),
94}
95__impl!(Rdseed, "rdseed");
96#[derive(Clone, Copy)]
97#[repr(transparent)]
98pub struct Sse {
99 __private: (),
100}
101__impl!(Sse, "sse");
102#[derive(Clone, Copy)]
103#[repr(transparent)]
104pub struct Sse2 {
105 __private: (),
106}
107__impl!(Sse2, "sse2");
108#[derive(Clone, Copy)]
109#[repr(transparent)]
110pub struct Sse3 {
111 __private: (),
112}
113__impl!(Sse3, "sse3");
114#[derive(Clone, Copy)]
115#[repr(transparent)]
116pub struct Ssse3 {
117 __private: (),
118}
119__impl!(Ssse3, "ssse3");
120#[derive(Clone, Copy)]
121#[repr(transparent)]
122pub struct Sse4_1 {
123 __private: (),
124}
125__impl!(Sse4_1, "sse4.1");
126#[derive(Clone, Copy)]
127#[repr(transparent)]
128pub struct Sse4_2 {
129 __private: (),
130}
131__impl!(Sse4_2, "sse4.2");
132#[derive(Clone, Copy)]
133#[repr(transparent)]
134pub struct Sse4a {
135 __private: (),
136}
137__impl!(Sse4a, "sse4a");
138#[derive(Clone, Copy)]
139#[repr(transparent)]
140pub struct Sha {
141 __private: (),
142}
143__impl!(Sha, "sha");
144#[derive(Clone, Copy)]
145#[repr(transparent)]
146pub struct Avx {
147 __private: (),
148}
149__impl!(Avx, "avx");
150#[derive(Clone, Copy)]
151#[repr(transparent)]
152pub struct Avx2 {
153 __private: (),
154}
155__impl!(Avx2, "avx2");
156#[derive(Clone, Copy)]
157#[repr(transparent)]
158pub struct F16c {
159 __private: (),
160}
161__impl!(F16c, "f16c");
162#[derive(Clone, Copy)]
163#[repr(transparent)]
164pub struct Fma {
165 __private: (),
166}
167__impl!(Fma, "fma");
168#[derive(Clone, Copy)]
169#[repr(transparent)]
170pub struct Bmi1 {
171 __private: (),
172}
173__impl!(Bmi1, "bmi1");
174#[derive(Clone, Copy)]
175#[repr(transparent)]
176pub struct Bmi2 {
177 __private: (),
178}
179__impl!(Bmi2, "bmi2");
180#[derive(Clone, Copy)]
181#[repr(transparent)]
182pub struct Lzcnt {
183 __private: (),
184}
185__impl!(Lzcnt, "lzcnt");
186#[derive(Clone, Copy)]
187#[repr(transparent)]
188pub struct Tbm {
189 __private: (),
190}
191__impl!(Tbm, "tbm");
192#[derive(Clone, Copy)]
193#[repr(transparent)]
194pub struct Popcnt {
195 __private: (),
196}
197__impl!(Popcnt, "popcnt");
198#[derive(Clone, Copy)]
199#[repr(transparent)]
200pub struct Fxsr {
201 __private: (),
202}
203__impl!(Fxsr, "fxsr");
204#[derive(Clone, Copy)]
205#[repr(transparent)]
206pub struct Xsave {
207 __private: (),
208}
209__impl!(Xsave, "xsave");
210#[derive(Clone, Copy)]
211#[repr(transparent)]
212pub struct Xsaveopt {
213 __private: (),
214}
215__impl!(Xsaveopt, "xsaveopt");
216#[derive(Clone, Copy)]
217#[repr(transparent)]
218pub struct Xsaves {
219 __private: (),
220}
221__impl!(Xsaves, "xsaves");
222#[derive(Clone, Copy)]
223#[repr(transparent)]
224pub struct Xsavec {
225 __private: (),
226}
227__impl!(Xsavec, "xsavec");
228#[derive(Clone, Copy)]
229#[repr(transparent)]
230pub struct Cmpxchg16b {
231 __private: (),
232}
233__impl!(Cmpxchg16b, "cmpxchg16b");
234#[derive(Clone, Copy)]
235#[repr(transparent)]
236pub struct Adx {
237 __private: (),
238}
239__impl!(Adx, "adx");
240#[derive(Clone, Copy)]
241#[repr(transparent)]
242pub struct Rtm {
243 __private: (),
244}
245__impl!(Rtm, "rtm");
246
247#[cfg(feature = "x86-v4")]
248#[cfg_attr(docsrs, doc(cfg(feature = "x86-v4")))]
249mod gate_v4 {
250 #[cfg(feature = "nightly")]
251 #[cfg_attr(docsrs, doc(cfg(feature = "nightly")))]
252 mod gate_nightly {
253 #[derive(Clone, Copy)]
254 #[repr(transparent)]
255 pub struct Avx512er {
256 __private: (),
257 }
258 __impl512!(Avx512er, "avx512er");
259 #[derive(Clone, Copy)]
260 #[repr(transparent)]
261 pub struct Avx512pf {
262 __private: (),
263 }
264 __impl512!(Avx512pf, "avx512pf");
265 }
266 #[cfg(feature = "nightly")]
267 #[cfg_attr(docsrs, doc(cfg(feature = "nightly")))]
268 pub use gate_nightly::*;
269
270 #[derive(Clone, Copy)]
271 #[repr(transparent)]
272 pub struct Avx512f {
273 __private: (),
274 }
275 __impl512!(Avx512f, "avx512f");
276 #[derive(Clone, Copy)]
277 #[repr(transparent)]
278 pub struct Avx512cd {
279 __private: (),
280 }
281
282 __impl512!(Avx512cd, "avx512cd");
283
284 #[derive(Clone, Copy)]
285 #[repr(transparent)]
286 pub struct Avx512bw {
287 __private: (),
288 }
289 __impl512!(Avx512bw, "avx512bw");
290 #[derive(Clone, Copy)]
291 #[repr(transparent)]
292 pub struct Avx512dq {
293 __private: (),
294 }
295 __impl512!(Avx512dq, "avx512dq");
296
297 #[derive(Clone, Copy)]
298 #[repr(transparent)]
299 pub struct Avx512ifma {
300 __private: (),
301 }
302 __impl512!(Avx512ifma, "avx512ifma");
303 #[derive(Clone, Copy)]
304 #[repr(transparent)]
305 pub struct Avx512vbmi {
306 __private: (),
307 }
308 __impl512!(Avx512vbmi, "avx512vbmi");
309 #[derive(Clone, Copy)]
310 #[repr(transparent)]
311 pub struct Avx512vpopcntdq {
312 __private: (),
313 }
314 __impl512!(Avx512vpopcntdq, "avx512vpopcntdq");
315 #[derive(Clone, Copy)]
316 #[repr(transparent)]
317 pub struct Avx512vbmi2 {
318 __private: (),
319 }
320 __impl512!(Avx512vbmi2, "avx512vbmi2");
321 #[derive(Clone, Copy)]
322 #[repr(transparent)]
323 pub struct Gfni {
324 __private: (),
325 }
326 __impl!(Gfni, "gfni");
327
328 #[derive(Clone, Copy)]
329 #[repr(transparent)]
330 pub struct Vaes {
331 __private: (),
332 }
333 __impl!(Vaes, "vaes");
334 #[derive(Clone, Copy)]
335 #[repr(transparent)]
336 pub struct Vpclmulqdq {
337 __private: (),
338 }
339 __impl!(Vpclmulqdq, "vpclmulqdq");
340
341 #[derive(Clone, Copy)]
342 #[repr(transparent)]
343 pub struct Avx512vnni {
344 __private: (),
345 }
346 __impl512!(Avx512vnni, "avx512vnni");
347 #[derive(Clone, Copy)]
348 #[repr(transparent)]
349 pub struct Avx512bitalg {
350 __private: (),
351 }
352 __impl512!(Avx512bitalg, "avx512bitalg");
353 #[derive(Clone, Copy)]
354 #[repr(transparent)]
355 pub struct Avx512bf16 {
356 __private: (),
357 }
358 __impl512!(Avx512bf16, "avx512bf16");
359 #[derive(Clone, Copy)]
360 #[repr(transparent)]
361 pub struct Avx512vp2intersect {
362 __private: (),
363 }
364 __impl512!(Avx512vp2intersect, "avx512vp2intersect");
365}
366#[cfg(feature = "x86-v4")]
367#[cfg_attr(docsrs, doc(cfg(feature = "x86-v4")))]
368pub use gate_v4::*;
369
370mod avx;
371mod avx2;
372mod fma;
373mod sse;
374mod sse2;
375mod sse3;
376mod sse41;
377mod sse42;
378mod ssse3;
379
380#[cfg(feature = "x86-v4")]
381#[cfg_attr(docsrs, doc(cfg(feature = "x86-v4")))]
382mod avx512bw;
383#[cfg(feature = "x86-v4")]
384#[cfg_attr(docsrs, doc(cfg(feature = "x86-v4")))]
385mod avx512cd;
386#[cfg(feature = "x86-v4")]
387#[cfg_attr(docsrs, doc(cfg(feature = "x86-v4")))]
388mod avx512dq;
389#[cfg(feature = "x86-v4")]
390#[cfg_attr(docsrs, doc(cfg(feature = "x86-v4")))]
391mod avx512f;
392#[cfg(feature = "x86-v4")]
393#[cfg_attr(docsrs, doc(cfg(feature = "x86-v4")))]
394mod avx512ifma;