core/stdarch/crates/core_arch/src/arm_shared/neon/
mod.rs

1//! ARMv7 NEON intrinsics
2
3#[rustfmt::skip]
4mod generated;
5#[rustfmt::skip]
6#[cfg_attr(not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0"))]
7#[cfg_attr(target_arch = "arm", unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800"))]
8pub use self::generated::*;
9
10use crate::{core_arch::simd::*, hint::unreachable_unchecked, intrinsics::simd::*, mem::transmute};
11#[cfg(test)]
12use stdarch_test::assert_instr;
13
14pub(crate) trait AsUnsigned {
15    type Unsigned;
16    fn as_unsigned(self) -> Self::Unsigned;
17}
18
19pub(crate) trait AsSigned {
20    type Signed;
21    fn as_signed(self) -> Self::Signed;
22}
23
24macro_rules! impl_sign_conversions_neon {
25    ($(($signed:ty, $unsigned:ty))*) => ($(
26        impl AsUnsigned for $signed {
27            type Unsigned = $unsigned;
28
29            #[inline(always)]
30            fn as_unsigned(self) -> $unsigned {
31                unsafe { transmute(self) }
32            }
33        }
34
35        impl AsSigned for $unsigned {
36            type Signed = $signed;
37
38            #[inline(always)]
39            fn as_signed(self) -> $signed {
40                unsafe { transmute(self) }
41            }
42        }
43    )*)
44}
45
46pub(crate) type p8 = u8;
47pub(crate) type p16 = u16;
48pub(crate) type p64 = u64;
49pub(crate) type p128 = u128;
50
51types! {
52    #![cfg_attr(not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0"))]
53    #![cfg_attr(target_arch = "arm", unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800"))]
54
55    /// Arm-specific 64-bit wide vector of eight packed `i8`.
56    pub struct int8x8_t(8 x pub(crate) i8);
57    /// Arm-specific 64-bit wide vector of eight packed `u8`.
58    pub struct uint8x8_t(8 x pub(crate) u8);
59    /// Arm-specific 64-bit wide polynomial vector of eight packed `p8`.
60    pub struct poly8x8_t(8 x pub(crate) p8);
61    /// Arm-specific 64-bit wide vector of four packed `i16`.
62    pub struct int16x4_t(4 x pub(crate) i16);
63    /// Arm-specific 64-bit wide vector of four packed `u16`.
64    pub struct uint16x4_t(4 x pub(crate) u16);
65    //  Arm-specific 64-bit wide vector of four packed `f16`.
66    pub struct float16x4_t(4 x pub(crate) f16);
67    /// Arm-specific 64-bit wide vector of four packed `p16`.
68    pub struct poly16x4_t(4 x pub(crate) p16);
69    /// Arm-specific 64-bit wide vector of two packed `i32`.
70    pub struct int32x2_t(2 x pub(crate) i32);
71    /// Arm-specific 64-bit wide vector of two packed `u32`.
72    pub struct uint32x2_t(2 x pub(crate) u32);
73    /// Arm-specific 64-bit wide vector of two packed `f32`.
74    pub struct float32x2_t(2 x pub(crate) f32);
75    /// Arm-specific 64-bit wide vector of one packed `i64`.
76    pub struct int64x1_t(1 x pub(crate) i64);
77    /// Arm-specific 64-bit wide vector of one packed `u64`.
78    pub struct uint64x1_t(1 x pub(crate) u64);
79    /// Arm-specific 64-bit wide vector of one packed `p64`.
80    pub struct poly64x1_t(1 x pub(crate) p64);
81
82    /// Arm-specific 128-bit wide vector of sixteen packed `i8`.
83    pub struct int8x16_t(16 x pub(crate) i8);
84    /// Arm-specific 128-bit wide vector of sixteen packed `u8`.
85    pub struct uint8x16_t(16 x pub(crate) u8);
86    /// Arm-specific 128-bit wide vector of sixteen packed `p8`.
87    pub struct poly8x16_t(16 x pub(crate) p8);
88    /// Arm-specific 128-bit wide vector of eight packed `i16`.
89    pub struct int16x8_t(8 x pub(crate) i16);
90    /// Arm-specific 128-bit wide vector of eight packed `u16`.
91    pub struct uint16x8_t(8 x pub(crate) u16);
92    //  Arm-specific 128-bit wide vector of eight packed `f16`.
93    pub struct float16x8_t(8 x pub(crate) f16);
94    /// Arm-specific 128-bit wide vector of eight packed `p16`.
95    pub struct poly16x8_t(8 x pub(crate) p16);
96    /// Arm-specific 128-bit wide vector of four packed `i32`.
97    pub struct int32x4_t(4 x pub(crate) i32);
98    /// Arm-specific 128-bit wide vector of four packed `u32`.
99    pub struct uint32x4_t(4 x pub(crate) u32);
100    /// Arm-specific 128-bit wide vector of four packed `f32`.
101    pub struct float32x4_t(4 x pub(crate) f32);
102    /// Arm-specific 128-bit wide vector of two packed `i64`.
103    pub struct int64x2_t(2 x pub(crate) i64);
104    /// Arm-specific 128-bit wide vector of two packed `u64`.
105    pub struct uint64x2_t(2 x pub(crate) u64);
106    /// Arm-specific 128-bit wide vector of two packed `p64`.
107    pub struct poly64x2_t(2 x pub(crate) p64);
108}
109
110/// Arm-specific type containing two `int8x8_t` vectors.
111#[repr(C)]
112#[derive(Copy, Clone, Debug)]
113#[cfg_attr(
114    not(target_arch = "arm"),
115    stable(feature = "neon_intrinsics", since = "1.59.0")
116)]
117#[cfg_attr(
118    target_arch = "arm",
119    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
120)]
121pub struct int8x8x2_t(pub int8x8_t, pub int8x8_t);
122/// Arm-specific type containing three `int8x8_t` vectors.
123#[repr(C)]
124#[derive(Copy, Clone, Debug)]
125#[cfg_attr(
126    not(target_arch = "arm"),
127    stable(feature = "neon_intrinsics", since = "1.59.0")
128)]
129#[cfg_attr(
130    target_arch = "arm",
131    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
132)]
133pub struct int8x8x3_t(pub int8x8_t, pub int8x8_t, pub int8x8_t);
134/// Arm-specific type containing four `int8x8_t` vectors.
135#[repr(C)]
136#[derive(Copy, Clone, Debug)]
137#[cfg_attr(
138    not(target_arch = "arm"),
139    stable(feature = "neon_intrinsics", since = "1.59.0")
140)]
141#[cfg_attr(
142    target_arch = "arm",
143    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
144)]
145pub struct int8x8x4_t(pub int8x8_t, pub int8x8_t, pub int8x8_t, pub int8x8_t);
146
147/// Arm-specific type containing two `int8x16_t` vectors.
148#[repr(C)]
149#[derive(Copy, Clone, Debug)]
150#[cfg_attr(
151    not(target_arch = "arm"),
152    stable(feature = "neon_intrinsics", since = "1.59.0")
153)]
154#[cfg_attr(
155    target_arch = "arm",
156    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
157)]
158pub struct int8x16x2_t(pub int8x16_t, pub int8x16_t);
159/// Arm-specific type containing three `int8x16_t` vectors.
160#[repr(C)]
161#[derive(Copy, Clone, Debug)]
162#[cfg_attr(
163    not(target_arch = "arm"),
164    stable(feature = "neon_intrinsics", since = "1.59.0")
165)]
166#[cfg_attr(
167    target_arch = "arm",
168    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
169)]
170pub struct int8x16x3_t(pub int8x16_t, pub int8x16_t, pub int8x16_t);
171/// Arm-specific type containing four `int8x16_t` vectors.
172#[repr(C)]
173#[derive(Copy, Clone, Debug)]
174#[cfg_attr(
175    not(target_arch = "arm"),
176    stable(feature = "neon_intrinsics", since = "1.59.0")
177)]
178#[cfg_attr(
179    target_arch = "arm",
180    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
181)]
182pub struct int8x16x4_t(pub int8x16_t, pub int8x16_t, pub int8x16_t, pub int8x16_t);
183
184/// Arm-specific type containing two `uint8x8_t` vectors.
185#[repr(C)]
186#[derive(Copy, Clone, Debug)]
187#[cfg_attr(
188    not(target_arch = "arm"),
189    stable(feature = "neon_intrinsics", since = "1.59.0")
190)]
191#[cfg_attr(
192    target_arch = "arm",
193    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
194)]
195pub struct uint8x8x2_t(pub uint8x8_t, pub uint8x8_t);
196/// Arm-specific type containing three `uint8x8_t` vectors.
197#[repr(C)]
198#[derive(Copy, Clone, Debug)]
199#[cfg_attr(
200    not(target_arch = "arm"),
201    stable(feature = "neon_intrinsics", since = "1.59.0")
202)]
203#[cfg_attr(
204    target_arch = "arm",
205    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
206)]
207pub struct uint8x8x3_t(pub uint8x8_t, pub uint8x8_t, pub uint8x8_t);
208/// Arm-specific type containing four `uint8x8_t` vectors.
209#[repr(C)]
210#[derive(Copy, Clone, Debug)]
211#[cfg_attr(
212    not(target_arch = "arm"),
213    stable(feature = "neon_intrinsics", since = "1.59.0")
214)]
215#[cfg_attr(
216    target_arch = "arm",
217    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
218)]
219pub struct uint8x8x4_t(pub uint8x8_t, pub uint8x8_t, pub uint8x8_t, pub uint8x8_t);
220
221/// Arm-specific type containing two `uint8x16_t` vectors.
222#[repr(C)]
223#[derive(Copy, Clone, Debug)]
224#[cfg_attr(
225    not(target_arch = "arm"),
226    stable(feature = "neon_intrinsics", since = "1.59.0")
227)]
228#[cfg_attr(
229    target_arch = "arm",
230    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
231)]
232pub struct uint8x16x2_t(pub uint8x16_t, pub uint8x16_t);
233/// Arm-specific type containing three `uint8x16_t` vectors.
234#[repr(C)]
235#[derive(Copy, Clone, Debug)]
236#[cfg_attr(
237    not(target_arch = "arm"),
238    stable(feature = "neon_intrinsics", since = "1.59.0")
239)]
240#[cfg_attr(
241    target_arch = "arm",
242    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
243)]
244pub struct uint8x16x3_t(pub uint8x16_t, pub uint8x16_t, pub uint8x16_t);
245/// Arm-specific type containing four `uint8x16_t` vectors.
246#[repr(C)]
247#[derive(Copy, Clone, Debug)]
248#[cfg_attr(
249    not(target_arch = "arm"),
250    stable(feature = "neon_intrinsics", since = "1.59.0")
251)]
252#[cfg_attr(
253    target_arch = "arm",
254    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
255)]
256pub struct uint8x16x4_t(
257    pub uint8x16_t,
258    pub uint8x16_t,
259    pub uint8x16_t,
260    pub uint8x16_t,
261);
262
263/// Arm-specific type containing two `poly8x8_t` vectors.
264#[repr(C)]
265#[derive(Copy, Clone, Debug)]
266#[cfg_attr(
267    not(target_arch = "arm"),
268    stable(feature = "neon_intrinsics", since = "1.59.0")
269)]
270#[cfg_attr(
271    target_arch = "arm",
272    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
273)]
274pub struct poly8x8x2_t(pub poly8x8_t, pub poly8x8_t);
275/// Arm-specific type containing three `poly8x8_t` vectors.
276#[repr(C)]
277#[derive(Copy, Clone, Debug)]
278#[cfg_attr(
279    not(target_arch = "arm"),
280    stable(feature = "neon_intrinsics", since = "1.59.0")
281)]
282#[cfg_attr(
283    target_arch = "arm",
284    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
285)]
286pub struct poly8x8x3_t(pub poly8x8_t, pub poly8x8_t, pub poly8x8_t);
287/// Arm-specific type containing four `poly8x8_t` vectors.
288#[repr(C)]
289#[derive(Copy, Clone, Debug)]
290#[cfg_attr(
291    not(target_arch = "arm"),
292    stable(feature = "neon_intrinsics", since = "1.59.0")
293)]
294#[cfg_attr(
295    target_arch = "arm",
296    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
297)]
298pub struct poly8x8x4_t(pub poly8x8_t, pub poly8x8_t, pub poly8x8_t, pub poly8x8_t);
299
300/// Arm-specific type containing two `poly8x16_t` vectors.
301#[repr(C)]
302#[derive(Copy, Clone, Debug)]
303#[cfg_attr(
304    not(target_arch = "arm"),
305    stable(feature = "neon_intrinsics", since = "1.59.0")
306)]
307#[cfg_attr(
308    target_arch = "arm",
309    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
310)]
311pub struct poly8x16x2_t(pub poly8x16_t, pub poly8x16_t);
312/// Arm-specific type containing three `poly8x16_t` vectors.
313#[repr(C)]
314#[derive(Copy, Clone, Debug)]
315#[cfg_attr(
316    not(target_arch = "arm"),
317    stable(feature = "neon_intrinsics", since = "1.59.0")
318)]
319#[cfg_attr(
320    target_arch = "arm",
321    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
322)]
323pub struct poly8x16x3_t(pub poly8x16_t, pub poly8x16_t, pub poly8x16_t);
324/// Arm-specific type containing four `poly8x16_t` vectors.
325#[repr(C)]
326#[derive(Copy, Clone, Debug)]
327#[cfg_attr(
328    not(target_arch = "arm"),
329    stable(feature = "neon_intrinsics", since = "1.59.0")
330)]
331#[cfg_attr(
332    target_arch = "arm",
333    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
334)]
335pub struct poly8x16x4_t(
336    pub poly8x16_t,
337    pub poly8x16_t,
338    pub poly8x16_t,
339    pub poly8x16_t,
340);
341
342/// Arm-specific type containing two `int16x4_t` vectors.
343#[repr(C)]
344#[derive(Copy, Clone, Debug)]
345#[cfg_attr(
346    not(target_arch = "arm"),
347    stable(feature = "neon_intrinsics", since = "1.59.0")
348)]
349#[cfg_attr(
350    target_arch = "arm",
351    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
352)]
353pub struct int16x4x2_t(pub int16x4_t, pub int16x4_t);
354/// Arm-specific type containing three `int16x4_t` vectors.
355#[repr(C)]
356#[derive(Copy, Clone, Debug)]
357#[cfg_attr(
358    not(target_arch = "arm"),
359    stable(feature = "neon_intrinsics", since = "1.59.0")
360)]
361#[cfg_attr(
362    target_arch = "arm",
363    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
364)]
365pub struct int16x4x3_t(pub int16x4_t, pub int16x4_t, pub int16x4_t);
366/// Arm-specific type containing four `int16x4_t` vectors.
367#[repr(C)]
368#[derive(Copy, Clone, Debug)]
369#[cfg_attr(
370    not(target_arch = "arm"),
371    stable(feature = "neon_intrinsics", since = "1.59.0")
372)]
373#[cfg_attr(
374    target_arch = "arm",
375    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
376)]
377pub struct int16x4x4_t(pub int16x4_t, pub int16x4_t, pub int16x4_t, pub int16x4_t);
378
379/// Arm-specific type containing two `int16x8_t` vectors.
380#[repr(C)]
381#[derive(Copy, Clone, Debug)]
382#[cfg_attr(
383    not(target_arch = "arm"),
384    stable(feature = "neon_intrinsics", since = "1.59.0")
385)]
386#[cfg_attr(
387    target_arch = "arm",
388    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
389)]
390pub struct int16x8x2_t(pub int16x8_t, pub int16x8_t);
391/// Arm-specific type containing three `int16x8_t` vectors.
392#[repr(C)]
393#[derive(Copy, Clone, Debug)]
394#[cfg_attr(
395    not(target_arch = "arm"),
396    stable(feature = "neon_intrinsics", since = "1.59.0")
397)]
398#[cfg_attr(
399    target_arch = "arm",
400    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
401)]
402pub struct int16x8x3_t(pub int16x8_t, pub int16x8_t, pub int16x8_t);
403/// Arm-specific type containing four `int16x8_t` vectors.
404#[repr(C)]
405#[derive(Copy, Clone, Debug)]
406#[cfg_attr(
407    not(target_arch = "arm"),
408    stable(feature = "neon_intrinsics", since = "1.59.0")
409)]
410#[cfg_attr(
411    target_arch = "arm",
412    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
413)]
414pub struct int16x8x4_t(pub int16x8_t, pub int16x8_t, pub int16x8_t, pub int16x8_t);
415
416/// Arm-specific type containing two `uint16x4_t` vectors.
417#[repr(C)]
418#[derive(Copy, Clone, Debug)]
419#[cfg_attr(
420    not(target_arch = "arm"),
421    stable(feature = "neon_intrinsics", since = "1.59.0")
422)]
423#[cfg_attr(
424    target_arch = "arm",
425    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
426)]
427pub struct uint16x4x2_t(pub uint16x4_t, pub uint16x4_t);
428/// Arm-specific type containing three `uint16x4_t` vectors.
429#[repr(C)]
430#[derive(Copy, Clone, Debug)]
431#[cfg_attr(
432    not(target_arch = "arm"),
433    stable(feature = "neon_intrinsics", since = "1.59.0")
434)]
435#[cfg_attr(
436    target_arch = "arm",
437    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
438)]
439pub struct uint16x4x3_t(pub uint16x4_t, pub uint16x4_t, pub uint16x4_t);
440/// Arm-specific type containing four `uint16x4_t` vectors.
441#[repr(C)]
442#[derive(Copy, Clone, Debug)]
443#[cfg_attr(
444    not(target_arch = "arm"),
445    stable(feature = "neon_intrinsics", since = "1.59.0")
446)]
447#[cfg_attr(
448    target_arch = "arm",
449    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
450)]
451pub struct uint16x4x4_t(
452    pub uint16x4_t,
453    pub uint16x4_t,
454    pub uint16x4_t,
455    pub uint16x4_t,
456);
457
458/// Arm-specific type containing two `uint16x8_t` vectors.
459#[repr(C)]
460#[derive(Copy, Clone, Debug)]
461#[cfg_attr(
462    not(target_arch = "arm"),
463    stable(feature = "neon_intrinsics", since = "1.59.0")
464)]
465#[cfg_attr(
466    target_arch = "arm",
467    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
468)]
469pub struct uint16x8x2_t(pub uint16x8_t, pub uint16x8_t);
470/// Arm-specific type containing three `uint16x8_t` vectors.
471#[repr(C)]
472#[derive(Copy, Clone, Debug)]
473#[cfg_attr(
474    not(target_arch = "arm"),
475    stable(feature = "neon_intrinsics", since = "1.59.0")
476)]
477#[cfg_attr(
478    target_arch = "arm",
479    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
480)]
481pub struct uint16x8x3_t(pub uint16x8_t, pub uint16x8_t, pub uint16x8_t);
482/// Arm-specific type containing four `uint16x8_t` vectors.
483#[repr(C)]
484#[derive(Copy, Clone, Debug)]
485#[cfg_attr(
486    not(target_arch = "arm"),
487    stable(feature = "neon_intrinsics", since = "1.59.0")
488)]
489#[cfg_attr(
490    target_arch = "arm",
491    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
492)]
493pub struct uint16x8x4_t(
494    pub uint16x8_t,
495    pub uint16x8_t,
496    pub uint16x8_t,
497    pub uint16x8_t,
498);
499
500/// Arm-specific type containing two `poly16x4_t` vectors.
501#[repr(C)]
502#[derive(Copy, Clone, Debug)]
503#[cfg_attr(
504    not(target_arch = "arm"),
505    stable(feature = "neon_intrinsics", since = "1.59.0")
506)]
507#[cfg_attr(
508    target_arch = "arm",
509    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
510)]
511pub struct poly16x4x2_t(pub poly16x4_t, pub poly16x4_t);
512/// Arm-specific type containing three `poly16x4_t` vectors.
513#[repr(C)]
514#[derive(Copy, Clone, Debug)]
515#[cfg_attr(
516    not(target_arch = "arm"),
517    stable(feature = "neon_intrinsics", since = "1.59.0")
518)]
519#[cfg_attr(
520    target_arch = "arm",
521    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
522)]
523pub struct poly16x4x3_t(pub poly16x4_t, pub poly16x4_t, pub poly16x4_t);
524/// Arm-specific type containing four `poly16x4_t` vectors.
525#[repr(C)]
526#[derive(Copy, Clone, Debug)]
527#[cfg_attr(
528    not(target_arch = "arm"),
529    stable(feature = "neon_intrinsics", since = "1.59.0")
530)]
531#[cfg_attr(
532    target_arch = "arm",
533    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
534)]
535pub struct poly16x4x4_t(
536    pub poly16x4_t,
537    pub poly16x4_t,
538    pub poly16x4_t,
539    pub poly16x4_t,
540);
541
542/// Arm-specific type containing two `poly16x8_t` vectors.
543#[repr(C)]
544#[derive(Copy, Clone, Debug)]
545#[cfg_attr(
546    not(target_arch = "arm"),
547    stable(feature = "neon_intrinsics", since = "1.59.0")
548)]
549#[cfg_attr(
550    target_arch = "arm",
551    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
552)]
553pub struct poly16x8x2_t(pub poly16x8_t, pub poly16x8_t);
554/// Arm-specific type containing three `poly16x8_t` vectors.
555#[repr(C)]
556#[derive(Copy, Clone, Debug)]
557#[cfg_attr(
558    not(target_arch = "arm"),
559    stable(feature = "neon_intrinsics", since = "1.59.0")
560)]
561#[cfg_attr(
562    target_arch = "arm",
563    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
564)]
565pub struct poly16x8x3_t(pub poly16x8_t, pub poly16x8_t, pub poly16x8_t);
566/// Arm-specific type containing four `poly16x8_t` vectors.
567#[repr(C)]
568#[derive(Copy, Clone, Debug)]
569#[cfg_attr(
570    not(target_arch = "arm"),
571    stable(feature = "neon_intrinsics", since = "1.59.0")
572)]
573#[cfg_attr(
574    target_arch = "arm",
575    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
576)]
577pub struct poly16x8x4_t(
578    pub poly16x8_t,
579    pub poly16x8_t,
580    pub poly16x8_t,
581    pub poly16x8_t,
582);
583
584/// Arm-specific type containing two `int32x2_t` vectors.
585#[repr(C)]
586#[derive(Copy, Clone, Debug)]
587#[cfg_attr(
588    not(target_arch = "arm"),
589    stable(feature = "neon_intrinsics", since = "1.59.0")
590)]
591#[cfg_attr(
592    target_arch = "arm",
593    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
594)]
595pub struct int32x2x2_t(pub int32x2_t, pub int32x2_t);
596/// Arm-specific type containing three `int32x2_t` vectors.
597#[repr(C)]
598#[derive(Copy, Clone, Debug)]
599#[cfg_attr(
600    not(target_arch = "arm"),
601    stable(feature = "neon_intrinsics", since = "1.59.0")
602)]
603#[cfg_attr(
604    target_arch = "arm",
605    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
606)]
607pub struct int32x2x3_t(pub int32x2_t, pub int32x2_t, pub int32x2_t);
608/// Arm-specific type containing four `int32x2_t` vectors.
609#[repr(C)]
610#[derive(Copy, Clone, Debug)]
611#[cfg_attr(
612    not(target_arch = "arm"),
613    stable(feature = "neon_intrinsics", since = "1.59.0")
614)]
615#[cfg_attr(
616    target_arch = "arm",
617    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
618)]
619pub struct int32x2x4_t(pub int32x2_t, pub int32x2_t, pub int32x2_t, pub int32x2_t);
620
621/// Arm-specific type containing two `int32x4_t` vectors.
622#[repr(C)]
623#[derive(Copy, Clone, Debug)]
624#[cfg_attr(
625    not(target_arch = "arm"),
626    stable(feature = "neon_intrinsics", since = "1.59.0")
627)]
628#[cfg_attr(
629    target_arch = "arm",
630    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
631)]
632pub struct int32x4x2_t(pub int32x4_t, pub int32x4_t);
633/// Arm-specific type containing three `int32x4_t` vectors.
634#[repr(C)]
635#[derive(Copy, Clone, Debug)]
636#[cfg_attr(
637    not(target_arch = "arm"),
638    stable(feature = "neon_intrinsics", since = "1.59.0")
639)]
640#[cfg_attr(
641    target_arch = "arm",
642    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
643)]
644pub struct int32x4x3_t(pub int32x4_t, pub int32x4_t, pub int32x4_t);
645/// Arm-specific type containing four `int32x4_t` vectors.
646#[repr(C)]
647#[derive(Copy, Clone, Debug)]
648#[cfg_attr(
649    not(target_arch = "arm"),
650    stable(feature = "neon_intrinsics", since = "1.59.0")
651)]
652#[cfg_attr(
653    target_arch = "arm",
654    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
655)]
656pub struct int32x4x4_t(pub int32x4_t, pub int32x4_t, pub int32x4_t, pub int32x4_t);
657
658/// Arm-specific type containing two `uint32x2_t` vectors.
659#[repr(C)]
660#[derive(Copy, Clone, Debug)]
661#[cfg_attr(
662    not(target_arch = "arm"),
663    stable(feature = "neon_intrinsics", since = "1.59.0")
664)]
665#[cfg_attr(
666    target_arch = "arm",
667    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
668)]
669pub struct uint32x2x2_t(pub uint32x2_t, pub uint32x2_t);
670/// Arm-specific type containing three `uint32x2_t` vectors.
671#[repr(C)]
672#[derive(Copy, Clone, Debug)]
673#[cfg_attr(
674    not(target_arch = "arm"),
675    stable(feature = "neon_intrinsics", since = "1.59.0")
676)]
677#[cfg_attr(
678    target_arch = "arm",
679    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
680)]
681pub struct uint32x2x3_t(pub uint32x2_t, pub uint32x2_t, pub uint32x2_t);
682/// Arm-specific type containing four `uint32x2_t` vectors.
683#[repr(C)]
684#[derive(Copy, Clone, Debug)]
685#[cfg_attr(
686    not(target_arch = "arm"),
687    stable(feature = "neon_intrinsics", since = "1.59.0")
688)]
689#[cfg_attr(
690    target_arch = "arm",
691    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
692)]
693pub struct uint32x2x4_t(
694    pub uint32x2_t,
695    pub uint32x2_t,
696    pub uint32x2_t,
697    pub uint32x2_t,
698);
699
700/// Arm-specific type containing two `uint32x4_t` vectors.
701#[repr(C)]
702#[derive(Copy, Clone, Debug)]
703#[cfg_attr(
704    not(target_arch = "arm"),
705    stable(feature = "neon_intrinsics", since = "1.59.0")
706)]
707#[cfg_attr(
708    target_arch = "arm",
709    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
710)]
711pub struct uint32x4x2_t(pub uint32x4_t, pub uint32x4_t);
712/// Arm-specific type containing three `uint32x4_t` vectors.
713#[repr(C)]
714#[derive(Copy, Clone, Debug)]
715#[cfg_attr(
716    not(target_arch = "arm"),
717    stable(feature = "neon_intrinsics", since = "1.59.0")
718)]
719#[cfg_attr(
720    target_arch = "arm",
721    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
722)]
723pub struct uint32x4x3_t(pub uint32x4_t, pub uint32x4_t, pub uint32x4_t);
724/// Arm-specific type containing four `uint32x4_t` vectors.
725#[repr(C)]
726#[derive(Copy, Clone, Debug)]
727#[cfg_attr(
728    not(target_arch = "arm"),
729    stable(feature = "neon_intrinsics", since = "1.59.0")
730)]
731#[cfg_attr(
732    target_arch = "arm",
733    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
734)]
735pub struct uint32x4x4_t(
736    pub uint32x4_t,
737    pub uint32x4_t,
738    pub uint32x4_t,
739    pub uint32x4_t,
740);
741
742/// Arm-specific type containing two `float16x4_t` vectors.
743#[repr(C)]
744#[derive(Copy, Clone, Debug)]
745#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
746pub struct float16x4x2_t(pub float16x4_t, pub float16x4_t);
747
748/// Arm-specific type containing three `float16x4_t` vectors.
749#[repr(C)]
750#[derive(Copy, Clone, Debug)]
751#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
752pub struct float16x4x3_t(pub float16x4_t, pub float16x4_t, pub float16x4_t);
753
754/// Arm-specific type containing four `float16x4_t` vectors.
755#[repr(C)]
756#[derive(Copy, Clone, Debug)]
757#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
758pub struct float16x4x4_t(
759    pub float16x4_t,
760    pub float16x4_t,
761    pub float16x4_t,
762    pub float16x4_t,
763);
764
765/// Arm-specific type containing two `float16x8_t` vectors.
766#[repr(C)]
767#[derive(Copy, Clone, Debug)]
768#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
769pub struct float16x8x2_t(pub float16x8_t, pub float16x8_t);
770
771/// Arm-specific type containing three `float16x8_t` vectors.
772#[repr(C)]
773#[derive(Copy, Clone, Debug)]
774#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
775
776pub struct float16x8x3_t(pub float16x8_t, pub float16x8_t, pub float16x8_t);
777/// Arm-specific type containing four `float16x8_t` vectors.
778#[repr(C)]
779#[derive(Copy, Clone, Debug)]
780#[unstable(feature = "stdarch_neon_f16", issue = "136306")]
781pub struct float16x8x4_t(
782    pub float16x8_t,
783    pub float16x8_t,
784    pub float16x8_t,
785    pub float16x8_t,
786);
787
788/// Arm-specific type containing two `float32x2_t` vectors.
789#[repr(C)]
790#[derive(Copy, Clone, Debug)]
791#[cfg_attr(
792    not(target_arch = "arm"),
793    stable(feature = "neon_intrinsics", since = "1.59.0")
794)]
795#[cfg_attr(
796    target_arch = "arm",
797    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
798)]
799pub struct float32x2x2_t(pub float32x2_t, pub float32x2_t);
800/// Arm-specific type containing three `float32x2_t` vectors.
801#[repr(C)]
802#[derive(Copy, Clone, Debug)]
803#[cfg_attr(
804    not(target_arch = "arm"),
805    stable(feature = "neon_intrinsics", since = "1.59.0")
806)]
807#[cfg_attr(
808    target_arch = "arm",
809    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
810)]
811pub struct float32x2x3_t(pub float32x2_t, pub float32x2_t, pub float32x2_t);
812/// Arm-specific type containing four `float32x2_t` vectors.
813#[repr(C)]
814#[derive(Copy, Clone, Debug)]
815#[cfg_attr(
816    not(target_arch = "arm"),
817    stable(feature = "neon_intrinsics", since = "1.59.0")
818)]
819#[cfg_attr(
820    target_arch = "arm",
821    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
822)]
823pub struct float32x2x4_t(
824    pub float32x2_t,
825    pub float32x2_t,
826    pub float32x2_t,
827    pub float32x2_t,
828);
829
830/// Arm-specific type containing two `float32x4_t` vectors.
831#[repr(C)]
832#[derive(Copy, Clone, Debug)]
833#[cfg_attr(
834    not(target_arch = "arm"),
835    stable(feature = "neon_intrinsics", since = "1.59.0")
836)]
837#[cfg_attr(
838    target_arch = "arm",
839    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
840)]
841pub struct float32x4x2_t(pub float32x4_t, pub float32x4_t);
842/// Arm-specific type containing three `float32x4_t` vectors.
843#[repr(C)]
844#[derive(Copy, Clone, Debug)]
845#[cfg_attr(
846    not(target_arch = "arm"),
847    stable(feature = "neon_intrinsics", since = "1.59.0")
848)]
849#[cfg_attr(
850    target_arch = "arm",
851    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
852)]
853pub struct float32x4x3_t(pub float32x4_t, pub float32x4_t, pub float32x4_t);
854/// Arm-specific type containing four `float32x4_t` vectors.
855#[repr(C)]
856#[derive(Copy, Clone, Debug)]
857#[cfg_attr(
858    not(target_arch = "arm"),
859    stable(feature = "neon_intrinsics", since = "1.59.0")
860)]
861#[cfg_attr(
862    target_arch = "arm",
863    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
864)]
865pub struct float32x4x4_t(
866    pub float32x4_t,
867    pub float32x4_t,
868    pub float32x4_t,
869    pub float32x4_t,
870);
871
872/// Arm-specific type containing two `int64x1_t` vectors.
873#[repr(C)]
874#[derive(Copy, Clone, Debug)]
875#[cfg_attr(
876    not(target_arch = "arm"),
877    stable(feature = "neon_intrinsics", since = "1.59.0")
878)]
879#[cfg_attr(
880    target_arch = "arm",
881    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
882)]
883pub struct int64x1x2_t(pub int64x1_t, pub int64x1_t);
884/// Arm-specific type containing three `int64x1_t` vectors.
885#[repr(C)]
886#[derive(Copy, Clone, Debug)]
887#[cfg_attr(
888    not(target_arch = "arm"),
889    stable(feature = "neon_intrinsics", since = "1.59.0")
890)]
891#[cfg_attr(
892    target_arch = "arm",
893    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
894)]
895pub struct int64x1x3_t(pub int64x1_t, pub int64x1_t, pub int64x1_t);
896/// Arm-specific type containing four `int64x1_t` vectors.
897#[repr(C)]
898#[derive(Copy, Clone, Debug)]
899#[cfg_attr(
900    not(target_arch = "arm"),
901    stable(feature = "neon_intrinsics", since = "1.59.0")
902)]
903#[cfg_attr(
904    target_arch = "arm",
905    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
906)]
907pub struct int64x1x4_t(pub int64x1_t, pub int64x1_t, pub int64x1_t, pub int64x1_t);
908
909/// Arm-specific type containing two `int64x2_t` vectors.
910#[repr(C)]
911#[derive(Copy, Clone, Debug)]
912#[cfg_attr(
913    not(target_arch = "arm"),
914    stable(feature = "neon_intrinsics", since = "1.59.0")
915)]
916#[cfg_attr(
917    target_arch = "arm",
918    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
919)]
920pub struct int64x2x2_t(pub int64x2_t, pub int64x2_t);
921/// Arm-specific type containing three `int64x2_t` vectors.
922#[repr(C)]
923#[derive(Copy, Clone, Debug)]
924#[cfg_attr(
925    not(target_arch = "arm"),
926    stable(feature = "neon_intrinsics", since = "1.59.0")
927)]
928#[cfg_attr(
929    target_arch = "arm",
930    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
931)]
932pub struct int64x2x3_t(pub int64x2_t, pub int64x2_t, pub int64x2_t);
933/// Arm-specific type containing four `int64x2_t` vectors.
934#[repr(C)]
935#[derive(Copy, Clone, Debug)]
936#[cfg_attr(
937    not(target_arch = "arm"),
938    stable(feature = "neon_intrinsics", since = "1.59.0")
939)]
940#[cfg_attr(
941    target_arch = "arm",
942    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
943)]
944pub struct int64x2x4_t(pub int64x2_t, pub int64x2_t, pub int64x2_t, pub int64x2_t);
945
946/// Arm-specific type containing two `uint64x1_t` vectors.
947#[repr(C)]
948#[derive(Copy, Clone, Debug)]
949#[cfg_attr(
950    not(target_arch = "arm"),
951    stable(feature = "neon_intrinsics", since = "1.59.0")
952)]
953#[cfg_attr(
954    target_arch = "arm",
955    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
956)]
957pub struct uint64x1x2_t(pub uint64x1_t, pub uint64x1_t);
958/// Arm-specific type containing three `uint64x1_t` vectors.
959#[repr(C)]
960#[derive(Copy, Clone, Debug)]
961#[cfg_attr(
962    not(target_arch = "arm"),
963    stable(feature = "neon_intrinsics", since = "1.59.0")
964)]
965#[cfg_attr(
966    target_arch = "arm",
967    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
968)]
969pub struct uint64x1x3_t(pub uint64x1_t, pub uint64x1_t, pub uint64x1_t);
970/// Arm-specific type containing four `uint64x1_t` vectors.
971#[repr(C)]
972#[derive(Copy, Clone, Debug)]
973#[cfg_attr(
974    not(target_arch = "arm"),
975    stable(feature = "neon_intrinsics", since = "1.59.0")
976)]
977#[cfg_attr(
978    target_arch = "arm",
979    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
980)]
981pub struct uint64x1x4_t(
982    pub uint64x1_t,
983    pub uint64x1_t,
984    pub uint64x1_t,
985    pub uint64x1_t,
986);
987
988/// Arm-specific type containing two `uint64x2_t` vectors.
989#[repr(C)]
990#[derive(Copy, Clone, Debug)]
991#[cfg_attr(
992    not(target_arch = "arm"),
993    stable(feature = "neon_intrinsics", since = "1.59.0")
994)]
995#[cfg_attr(
996    target_arch = "arm",
997    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
998)]
999pub struct uint64x2x2_t(pub uint64x2_t, pub uint64x2_t);
1000/// Arm-specific type containing three `uint64x2_t` vectors.
1001#[repr(C)]
1002#[derive(Copy, Clone, Debug)]
1003#[cfg_attr(
1004    not(target_arch = "arm"),
1005    stable(feature = "neon_intrinsics", since = "1.59.0")
1006)]
1007#[cfg_attr(
1008    target_arch = "arm",
1009    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
1010)]
1011pub struct uint64x2x3_t(pub uint64x2_t, pub uint64x2_t, pub uint64x2_t);
1012/// Arm-specific type containing four `uint64x2_t` vectors.
1013#[repr(C)]
1014#[derive(Copy, Clone, Debug)]
1015#[cfg_attr(
1016    not(target_arch = "arm"),
1017    stable(feature = "neon_intrinsics", since = "1.59.0")
1018)]
1019#[cfg_attr(
1020    target_arch = "arm",
1021    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
1022)]
1023pub struct uint64x2x4_t(
1024    pub uint64x2_t,
1025    pub uint64x2_t,
1026    pub uint64x2_t,
1027    pub uint64x2_t,
1028);
1029
1030/// Arm-specific type containing two `poly64x1_t` vectors.
1031#[repr(C)]
1032#[derive(Copy, Clone, Debug)]
1033#[cfg_attr(
1034    not(target_arch = "arm"),
1035    stable(feature = "neon_intrinsics", since = "1.59.0")
1036)]
1037#[cfg_attr(
1038    target_arch = "arm",
1039    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
1040)]
1041pub struct poly64x1x2_t(pub poly64x1_t, pub poly64x1_t);
1042/// Arm-specific type containing three `poly64x1_t` vectors.
1043#[repr(C)]
1044#[derive(Copy, Clone, Debug)]
1045#[cfg_attr(
1046    not(target_arch = "arm"),
1047    stable(feature = "neon_intrinsics", since = "1.59.0")
1048)]
1049#[cfg_attr(
1050    target_arch = "arm",
1051    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
1052)]
1053pub struct poly64x1x3_t(pub poly64x1_t, pub poly64x1_t, pub poly64x1_t);
1054/// Arm-specific type containing four `poly64x1_t` vectors.
1055#[repr(C)]
1056#[derive(Copy, Clone, Debug)]
1057#[cfg_attr(
1058    not(target_arch = "arm"),
1059    stable(feature = "neon_intrinsics", since = "1.59.0")
1060)]
1061#[cfg_attr(
1062    target_arch = "arm",
1063    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
1064)]
1065pub struct poly64x1x4_t(
1066    pub poly64x1_t,
1067    pub poly64x1_t,
1068    pub poly64x1_t,
1069    pub poly64x1_t,
1070);
1071
1072/// Arm-specific type containing two `poly64x2_t` vectors.
1073#[repr(C)]
1074#[derive(Copy, Clone, Debug)]
1075#[cfg_attr(
1076    not(target_arch = "arm"),
1077    stable(feature = "neon_intrinsics", since = "1.59.0")
1078)]
1079#[cfg_attr(
1080    target_arch = "arm",
1081    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
1082)]
1083pub struct poly64x2x2_t(pub poly64x2_t, pub poly64x2_t);
1084/// Arm-specific type containing three `poly64x2_t` vectors.
1085#[repr(C)]
1086#[derive(Copy, Clone, Debug)]
1087#[cfg_attr(
1088    not(target_arch = "arm"),
1089    stable(feature = "neon_intrinsics", since = "1.59.0")
1090)]
1091#[cfg_attr(
1092    target_arch = "arm",
1093    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
1094)]
1095pub struct poly64x2x3_t(pub poly64x2_t, pub poly64x2_t, pub poly64x2_t);
1096/// Arm-specific type containing four `poly64x2_t` vectors.
1097#[repr(C)]
1098#[derive(Copy, Clone, Debug)]
1099#[cfg_attr(
1100    not(target_arch = "arm"),
1101    stable(feature = "neon_intrinsics", since = "1.59.0")
1102)]
1103#[cfg_attr(
1104    target_arch = "arm",
1105    unstable(feature = "stdarch_arm_neon_intrinsics", issue = "111800")
1106)]
1107pub struct poly64x2x4_t(
1108    pub poly64x2_t,
1109    pub poly64x2_t,
1110    pub poly64x2_t,
1111    pub poly64x2_t,
1112);
1113
1114impl_sign_conversions_neon! {
1115    (i8, u8)
1116    (i16, u16)
1117    (i32, u32)
1118    (i64, u64)
1119    (*const i8, *const u8)
1120    (*const i16, *const u16)
1121    (*const i32, *const u32)
1122    (*const i64, *const u64)
1123    (*mut i8, *mut u8)
1124    (*mut i16, *mut u16)
1125    (*mut i32, *mut u32)
1126    (*mut i64, *mut u64)
1127    (int16x4_t, uint16x4_t)
1128    (int16x8_t, uint16x8_t)
1129    (int32x2_t, uint32x2_t)
1130    (int32x4_t, uint32x4_t)
1131    (int64x1_t, uint64x1_t)
1132    (int64x2_t, uint64x2_t)
1133    (int8x16_t, uint8x16_t)
1134    (int8x8_t, uint8x8_t)
1135    (uint16x4_t, int16x4_t)
1136    (uint16x8_t, int16x8_t)
1137    (uint32x2_t, int32x2_t)
1138    (uint32x4_t, int32x4_t)
1139    (uint64x1_t, int64x1_t)
1140    (uint64x2_t, int64x2_t)
1141    (uint8x16_t, int8x16_t)
1142    (uint8x8_t, int8x8_t)
1143    (int16x4x2_t, uint16x4x2_t)
1144    (int16x4x3_t, uint16x4x3_t)
1145    (int16x4x4_t, uint16x4x4_t)
1146    (int16x8x2_t, uint16x8x2_t)
1147    (int16x8x3_t, uint16x8x3_t)
1148    (int16x8x4_t, uint16x8x4_t)
1149    (int32x2x2_t, uint32x2x2_t)
1150    (int32x2x3_t, uint32x2x3_t)
1151    (int32x2x4_t, uint32x2x4_t)
1152    (int32x4x2_t, uint32x4x2_t)
1153    (int32x4x3_t, uint32x4x3_t)
1154    (int32x4x4_t, uint32x4x4_t)
1155    (int64x1x2_t, uint64x1x2_t)
1156    (int64x1x3_t, uint64x1x3_t)
1157    (int64x1x4_t, uint64x1x4_t)
1158    (int64x2x2_t, uint64x2x2_t)
1159    (int64x2x3_t, uint64x2x3_t)
1160    (int64x2x4_t, uint64x2x4_t)
1161    (int8x16x2_t, uint8x16x2_t)
1162    (int8x16x3_t, uint8x16x3_t)
1163    (int8x16x4_t, uint8x16x4_t)
1164    (int8x8x2_t, uint8x8x2_t)
1165    (int8x8x3_t, uint8x8x3_t)
1166    (int8x8x4_t, uint8x8x4_t)
1167    (uint16x4x2_t, int16x4x2_t)
1168    (uint16x4x3_t, int16x4x3_t)
1169    (uint16x4x4_t, int16x4x4_t)
1170    (uint16x8x2_t, int16x8x2_t)
1171    (uint16x8x3_t, int16x8x3_t)
1172    (uint16x8x4_t, int16x8x4_t)
1173    (uint32x2x2_t, int32x2x2_t)
1174    (uint32x2x3_t, int32x2x3_t)
1175    (uint32x2x4_t, int32x2x4_t)
1176    (uint32x4x2_t, int32x4x2_t)
1177    (uint32x4x3_t, int32x4x3_t)
1178    (uint32x4x4_t, int32x4x4_t)
1179    (uint64x1x2_t, int64x1x2_t)
1180    (uint64x1x3_t, int64x1x3_t)
1181    (uint64x1x4_t, int64x1x4_t)
1182    (uint64x2x2_t, int64x2x2_t)
1183    (uint64x2x3_t, int64x2x3_t)
1184    (uint64x2x4_t, int64x2x4_t)
1185    (uint8x16x2_t, int8x16x2_t)
1186    (uint8x16x3_t, int8x16x3_t)
1187    (uint8x16x4_t, int8x16x4_t)
1188    (uint8x8x2_t, int8x8x2_t)
1189    (uint8x8x3_t, int8x8x3_t)
1190    (uint8x8x4_t, int8x8x4_t)
1191}
1192
1193#[cfg(test)]
1194mod tests {
1195    use super::*;
1196    #[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
1197    use crate::core_arch::aarch64::*;
1198    #[cfg(target_arch = "arm")]
1199    use crate::core_arch::arm::*;
1200    use crate::core_arch::arm_shared::test_support::*;
1201    use crate::core_arch::simd::*;
1202    use std::{mem::transmute, vec::Vec};
1203    use stdarch_test::simd_test;
1204
1205    #[simd_test(enable = "neon")]
1206    unsafe fn test_vld1_lane_s8() {
1207        let a = i8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1208        let elem: i8 = 42;
1209        let e = i8x8::new(0, 1, 2, 3, 4, 5, 6, 42);
1210        let r: i8x8 = transmute(vld1_lane_s8::<7>(&elem, transmute(a)));
1211        assert_eq!(r, e)
1212    }
1213
1214    #[simd_test(enable = "neon")]
1215    unsafe fn test_vld1q_lane_s8() {
1216        let a = i8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
1217        let elem: i8 = 42;
1218        let e = i8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 42);
1219        let r: i8x16 = transmute(vld1q_lane_s8::<15>(&elem, transmute(a)));
1220        assert_eq!(r, e)
1221    }
1222
1223    #[simd_test(enable = "neon")]
1224    unsafe fn test_vld1_lane_s16() {
1225        let a = i16x4::new(0, 1, 2, 3);
1226        let elem: i16 = 42;
1227        let e = i16x4::new(0, 1, 2, 42);
1228        let r: i16x4 = transmute(vld1_lane_s16::<3>(&elem, transmute(a)));
1229        assert_eq!(r, e)
1230    }
1231
1232    #[simd_test(enable = "neon")]
1233    unsafe fn test_vld1q_lane_s16() {
1234        let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1235        let elem: i16 = 42;
1236        let e = i16x8::new(0, 1, 2, 3, 4, 5, 6, 42);
1237        let r: i16x8 = transmute(vld1q_lane_s16::<7>(&elem, transmute(a)));
1238        assert_eq!(r, e)
1239    }
1240
1241    #[simd_test(enable = "neon")]
1242    unsafe fn test_vld1_lane_s32() {
1243        let a = i32x2::new(0, 1);
1244        let elem: i32 = 42;
1245        let e = i32x2::new(0, 42);
1246        let r: i32x2 = transmute(vld1_lane_s32::<1>(&elem, transmute(a)));
1247        assert_eq!(r, e)
1248    }
1249
1250    #[simd_test(enable = "neon")]
1251    unsafe fn test_vld1q_lane_s32() {
1252        let a = i32x4::new(0, 1, 2, 3);
1253        let elem: i32 = 42;
1254        let e = i32x4::new(0, 1, 2, 42);
1255        let r: i32x4 = transmute(vld1q_lane_s32::<3>(&elem, transmute(a)));
1256        assert_eq!(r, e)
1257    }
1258
1259    #[simd_test(enable = "neon")]
1260    unsafe fn test_vld1_lane_s64() {
1261        let a = i64x1::new(0);
1262        let elem: i64 = 42;
1263        let e = i64x1::new(42);
1264        let r: i64x1 = transmute(vld1_lane_s64::<0>(&elem, transmute(a)));
1265        assert_eq!(r, e)
1266    }
1267
1268    #[simd_test(enable = "neon")]
1269    unsafe fn test_vld1q_lane_s64() {
1270        let a = i64x2::new(0, 1);
1271        let elem: i64 = 42;
1272        let e = i64x2::new(0, 42);
1273        let r: i64x2 = transmute(vld1q_lane_s64::<1>(&elem, transmute(a)));
1274        assert_eq!(r, e)
1275    }
1276
1277    #[simd_test(enable = "neon")]
1278    unsafe fn test_vld1_lane_u8() {
1279        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1280        let elem: u8 = 42;
1281        let e = u8x8::new(0, 1, 2, 3, 4, 5, 6, 42);
1282        let r: u8x8 = transmute(vld1_lane_u8::<7>(&elem, transmute(a)));
1283        assert_eq!(r, e)
1284    }
1285
1286    #[simd_test(enable = "neon")]
1287    unsafe fn test_vld1q_lane_u8() {
1288        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
1289        let elem: u8 = 42;
1290        let e = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 42);
1291        let r: u8x16 = transmute(vld1q_lane_u8::<15>(&elem, transmute(a)));
1292        assert_eq!(r, e)
1293    }
1294
1295    #[simd_test(enable = "neon")]
1296    unsafe fn test_vld1_lane_u16() {
1297        let a = u16x4::new(0, 1, 2, 3);
1298        let elem: u16 = 42;
1299        let e = u16x4::new(0, 1, 2, 42);
1300        let r: u16x4 = transmute(vld1_lane_u16::<3>(&elem, transmute(a)));
1301        assert_eq!(r, e)
1302    }
1303
1304    #[simd_test(enable = "neon")]
1305    unsafe fn test_vld1q_lane_u16() {
1306        let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1307        let elem: u16 = 42;
1308        let e = u16x8::new(0, 1, 2, 3, 4, 5, 6, 42);
1309        let r: u16x8 = transmute(vld1q_lane_u16::<7>(&elem, transmute(a)));
1310        assert_eq!(r, e)
1311    }
1312
1313    #[simd_test(enable = "neon")]
1314    unsafe fn test_vld1_lane_u32() {
1315        let a = u32x2::new(0, 1);
1316        let elem: u32 = 42;
1317        let e = u32x2::new(0, 42);
1318        let r: u32x2 = transmute(vld1_lane_u32::<1>(&elem, transmute(a)));
1319        assert_eq!(r, e)
1320    }
1321
1322    #[simd_test(enable = "neon")]
1323    unsafe fn test_vld1q_lane_u32() {
1324        let a = u32x4::new(0, 1, 2, 3);
1325        let elem: u32 = 42;
1326        let e = u32x4::new(0, 1, 2, 42);
1327        let r: u32x4 = transmute(vld1q_lane_u32::<3>(&elem, transmute(a)));
1328        assert_eq!(r, e)
1329    }
1330
1331    #[simd_test(enable = "neon")]
1332    unsafe fn test_vld1_lane_u64() {
1333        let a = u64x1::new(0);
1334        let elem: u64 = 42;
1335        let e = u64x1::new(42);
1336        let r: u64x1 = transmute(vld1_lane_u64::<0>(&elem, transmute(a)));
1337        assert_eq!(r, e)
1338    }
1339
1340    #[simd_test(enable = "neon")]
1341    unsafe fn test_vld1q_lane_u64() {
1342        let a = u64x2::new(0, 1);
1343        let elem: u64 = 42;
1344        let e = u64x2::new(0, 42);
1345        let r: u64x2 = transmute(vld1q_lane_u64::<1>(&elem, transmute(a)));
1346        assert_eq!(r, e)
1347    }
1348
1349    #[simd_test(enable = "neon")]
1350    unsafe fn test_vld1_lane_p8() {
1351        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1352        let elem: p8 = 42;
1353        let e = u8x8::new(0, 1, 2, 3, 4, 5, 6, 42);
1354        let r: u8x8 = transmute(vld1_lane_p8::<7>(&elem, transmute(a)));
1355        assert_eq!(r, e)
1356    }
1357
1358    #[simd_test(enable = "neon")]
1359    unsafe fn test_vld1q_lane_p8() {
1360        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
1361        let elem: p8 = 42;
1362        let e = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 42);
1363        let r: u8x16 = transmute(vld1q_lane_p8::<15>(&elem, transmute(a)));
1364        assert_eq!(r, e)
1365    }
1366
1367    #[simd_test(enable = "neon")]
1368    unsafe fn test_vld1_lane_p16() {
1369        let a = u16x4::new(0, 1, 2, 3);
1370        let elem: p16 = 42;
1371        let e = u16x4::new(0, 1, 2, 42);
1372        let r: u16x4 = transmute(vld1_lane_p16::<3>(&elem, transmute(a)));
1373        assert_eq!(r, e)
1374    }
1375
1376    #[simd_test(enable = "neon")]
1377    unsafe fn test_vld1q_lane_p16() {
1378        let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1379        let elem: p16 = 42;
1380        let e = u16x8::new(0, 1, 2, 3, 4, 5, 6, 42);
1381        let r: u16x8 = transmute(vld1q_lane_p16::<7>(&elem, transmute(a)));
1382        assert_eq!(r, e)
1383    }
1384
1385    #[simd_test(enable = "neon,aes")]
1386    unsafe fn test_vld1_lane_p64() {
1387        let a = u64x1::new(0);
1388        let elem: u64 = 42;
1389        let e = u64x1::new(42);
1390        let r: u64x1 = transmute(vld1_lane_p64::<0>(&elem, transmute(a)));
1391        assert_eq!(r, e)
1392    }
1393
1394    #[simd_test(enable = "neon,aes")]
1395    unsafe fn test_vld1q_lane_p64() {
1396        let a = u64x2::new(0, 1);
1397        let elem: u64 = 42;
1398        let e = u64x2::new(0, 42);
1399        let r: u64x2 = transmute(vld1q_lane_p64::<1>(&elem, transmute(a)));
1400        assert_eq!(r, e)
1401    }
1402
1403    #[simd_test(enable = "neon")]
1404    unsafe fn test_vld1_lane_f32() {
1405        let a = f32x2::new(0., 1.);
1406        let elem: f32 = 42.;
1407        let e = f32x2::new(0., 42.);
1408        let r: f32x2 = transmute(vld1_lane_f32::<1>(&elem, transmute(a)));
1409        assert_eq!(r, e)
1410    }
1411
1412    #[simd_test(enable = "neon")]
1413    unsafe fn test_vld1q_lane_f32() {
1414        let a = f32x4::new(0., 1., 2., 3.);
1415        let elem: f32 = 42.;
1416        let e = f32x4::new(0., 1., 2., 42.);
1417        let r: f32x4 = transmute(vld1q_lane_f32::<3>(&elem, transmute(a)));
1418        assert_eq!(r, e)
1419    }
1420
1421    #[simd_test(enable = "neon")]
1422    unsafe fn test_vld1_dup_s8() {
1423        let elem: i8 = 42;
1424        let e = i8x8::new(42, 42, 42, 42, 42, 42, 42, 42);
1425        let r: i8x8 = transmute(vld1_dup_s8(&elem));
1426        assert_eq!(r, e)
1427    }
1428
1429    #[simd_test(enable = "neon")]
1430    unsafe fn test_vld1q_dup_s8() {
1431        let elem: i8 = 42;
1432        let e = i8x16::new(
1433            42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
1434        );
1435        let r: i8x16 = transmute(vld1q_dup_s8(&elem));
1436        assert_eq!(r, e)
1437    }
1438
1439    #[simd_test(enable = "neon")]
1440    unsafe fn test_vld1_dup_s16() {
1441        let elem: i16 = 42;
1442        let e = i16x4::new(42, 42, 42, 42);
1443        let r: i16x4 = transmute(vld1_dup_s16(&elem));
1444        assert_eq!(r, e)
1445    }
1446
1447    #[simd_test(enable = "neon")]
1448    unsafe fn test_vld1q_dup_s16() {
1449        let elem: i16 = 42;
1450        let e = i16x8::new(42, 42, 42, 42, 42, 42, 42, 42);
1451        let r: i16x8 = transmute(vld1q_dup_s16(&elem));
1452        assert_eq!(r, e)
1453    }
1454
1455    #[simd_test(enable = "neon")]
1456    unsafe fn test_vld1_dup_s32() {
1457        let elem: i32 = 42;
1458        let e = i32x2::new(42, 42);
1459        let r: i32x2 = transmute(vld1_dup_s32(&elem));
1460        assert_eq!(r, e)
1461    }
1462
1463    #[simd_test(enable = "neon")]
1464    unsafe fn test_vld1q_dup_s32() {
1465        let elem: i32 = 42;
1466        let e = i32x4::new(42, 42, 42, 42);
1467        let r: i32x4 = transmute(vld1q_dup_s32(&elem));
1468        assert_eq!(r, e)
1469    }
1470
1471    #[simd_test(enable = "neon")]
1472    unsafe fn test_vld1_dup_s64() {
1473        let elem: i64 = 42;
1474        let e = i64x1::new(42);
1475        let r: i64x1 = transmute(vld1_dup_s64(&elem));
1476        assert_eq!(r, e)
1477    }
1478
1479    #[simd_test(enable = "neon")]
1480    unsafe fn test_vld1q_dup_s64() {
1481        let elem: i64 = 42;
1482        let e = i64x2::new(42, 42);
1483        let r: i64x2 = transmute(vld1q_dup_s64(&elem));
1484        assert_eq!(r, e)
1485    }
1486
1487    #[simd_test(enable = "neon")]
1488    unsafe fn test_vld1_dup_u8() {
1489        let elem: u8 = 42;
1490        let e = u8x8::new(42, 42, 42, 42, 42, 42, 42, 42);
1491        let r: u8x8 = transmute(vld1_dup_u8(&elem));
1492        assert_eq!(r, e)
1493    }
1494
1495    #[simd_test(enable = "neon")]
1496    unsafe fn test_vld1q_dup_u8() {
1497        let elem: u8 = 42;
1498        let e = u8x16::new(
1499            42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
1500        );
1501        let r: u8x16 = transmute(vld1q_dup_u8(&elem));
1502        assert_eq!(r, e)
1503    }
1504
1505    #[simd_test(enable = "neon")]
1506    unsafe fn test_vld1_dup_u16() {
1507        let elem: u16 = 42;
1508        let e = u16x4::new(42, 42, 42, 42);
1509        let r: u16x4 = transmute(vld1_dup_u16(&elem));
1510        assert_eq!(r, e)
1511    }
1512
1513    #[simd_test(enable = "neon")]
1514    unsafe fn test_vld1q_dup_u16() {
1515        let elem: u16 = 42;
1516        let e = u16x8::new(42, 42, 42, 42, 42, 42, 42, 42);
1517        let r: u16x8 = transmute(vld1q_dup_u16(&elem));
1518        assert_eq!(r, e)
1519    }
1520
1521    #[simd_test(enable = "neon")]
1522    unsafe fn test_vld1_dup_u32() {
1523        let elem: u32 = 42;
1524        let e = u32x2::new(42, 42);
1525        let r: u32x2 = transmute(vld1_dup_u32(&elem));
1526        assert_eq!(r, e)
1527    }
1528
1529    #[simd_test(enable = "neon")]
1530    unsafe fn test_vld1q_dup_u32() {
1531        let elem: u32 = 42;
1532        let e = u32x4::new(42, 42, 42, 42);
1533        let r: u32x4 = transmute(vld1q_dup_u32(&elem));
1534        assert_eq!(r, e)
1535    }
1536
1537    #[simd_test(enable = "neon")]
1538    unsafe fn test_vld1_dup_u64() {
1539        let elem: u64 = 42;
1540        let e = u64x1::new(42);
1541        let r: u64x1 = transmute(vld1_dup_u64(&elem));
1542        assert_eq!(r, e)
1543    }
1544
1545    #[simd_test(enable = "neon")]
1546    unsafe fn test_vld1q_dup_u64() {
1547        let elem: u64 = 42;
1548        let e = u64x2::new(42, 42);
1549        let r: u64x2 = transmute(vld1q_dup_u64(&elem));
1550        assert_eq!(r, e)
1551    }
1552
1553    #[simd_test(enable = "neon")]
1554    unsafe fn test_vld1_dup_p8() {
1555        let elem: p8 = 42;
1556        let e = u8x8::new(42, 42, 42, 42, 42, 42, 42, 42);
1557        let r: u8x8 = transmute(vld1_dup_p8(&elem));
1558        assert_eq!(r, e)
1559    }
1560
1561    #[simd_test(enable = "neon")]
1562    unsafe fn test_vld1q_dup_p8() {
1563        let elem: p8 = 42;
1564        let e = u8x16::new(
1565            42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
1566        );
1567        let r: u8x16 = transmute(vld1q_dup_p8(&elem));
1568        assert_eq!(r, e)
1569    }
1570
1571    #[simd_test(enable = "neon")]
1572    unsafe fn test_vld1_dup_p16() {
1573        let elem: p16 = 42;
1574        let e = u16x4::new(42, 42, 42, 42);
1575        let r: u16x4 = transmute(vld1_dup_p16(&elem));
1576        assert_eq!(r, e)
1577    }
1578
1579    #[simd_test(enable = "neon")]
1580    unsafe fn test_vld1q_dup_p16() {
1581        let elem: p16 = 42;
1582        let e = u16x8::new(42, 42, 42, 42, 42, 42, 42, 42);
1583        let r: u16x8 = transmute(vld1q_dup_p16(&elem));
1584        assert_eq!(r, e)
1585    }
1586
1587    #[simd_test(enable = "neon,aes")]
1588    unsafe fn test_vld1_dup_p64() {
1589        let elem: u64 = 42;
1590        let e = u64x1::new(42);
1591        let r: u64x1 = transmute(vld1_dup_p64(&elem));
1592        assert_eq!(r, e)
1593    }
1594
1595    #[simd_test(enable = "neon,aes")]
1596    unsafe fn test_vld1q_dup_p64() {
1597        let elem: u64 = 42;
1598        let e = u64x2::new(42, 42);
1599        let r: u64x2 = transmute(vld1q_dup_p64(&elem));
1600        assert_eq!(r, e)
1601    }
1602
1603    #[simd_test(enable = "neon")]
1604    unsafe fn test_vld1_dup_f32() {
1605        let elem: f32 = 42.;
1606        let e = f32x2::new(42., 42.);
1607        let r: f32x2 = transmute(vld1_dup_f32(&elem));
1608        assert_eq!(r, e)
1609    }
1610
1611    #[simd_test(enable = "neon")]
1612    unsafe fn test_vld1q_dup_f32() {
1613        let elem: f32 = 42.;
1614        let e = f32x4::new(42., 42., 42., 42.);
1615        let r: f32x4 = transmute(vld1q_dup_f32(&elem));
1616        assert_eq!(r, e)
1617    }
1618
1619    #[simd_test(enable = "neon")]
1620    unsafe fn test_vget_lane_u8() {
1621        let v = i8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
1622        let r = vget_lane_u8::<1>(transmute(v));
1623        assert_eq!(r, 2);
1624    }
1625
1626    #[simd_test(enable = "neon")]
1627    unsafe fn test_vgetq_lane_u32() {
1628        let v = i32x4::new(1, 2, 3, 4);
1629        let r = vgetq_lane_u32::<1>(transmute(v));
1630        assert_eq!(r, 2);
1631    }
1632
1633    #[simd_test(enable = "neon")]
1634    unsafe fn test_vgetq_lane_s32() {
1635        let v = i32x4::new(1, 2, 3, 4);
1636        let r = vgetq_lane_s32::<1>(transmute(v));
1637        assert_eq!(r, 2);
1638    }
1639
1640    #[simd_test(enable = "neon")]
1641    unsafe fn test_vget_lane_u64() {
1642        let v: u64 = 1;
1643        let r = vget_lane_u64::<0>(transmute(v));
1644        assert_eq!(r, 1);
1645    }
1646
1647    #[simd_test(enable = "neon")]
1648    unsafe fn test_vgetq_lane_u16() {
1649        let v = i16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
1650        let r = vgetq_lane_u16::<1>(transmute(v));
1651        assert_eq!(r, 2);
1652    }
1653
1654    #[simd_test(enable = "neon")]
1655    unsafe fn test_vget_lane_s8() {
1656        let v = i8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1657        let r = vget_lane_s8::<2>(transmute(v));
1658        assert_eq!(r, 2);
1659        let r = vget_lane_s8::<4>(transmute(v));
1660        assert_eq!(r, 4);
1661        let r = vget_lane_s8::<5>(transmute(v));
1662        assert_eq!(r, 5);
1663    }
1664    #[simd_test(enable = "neon")]
1665    unsafe fn test_vget_lane_p8() {
1666        let v = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1667        let r = vget_lane_p8::<2>(transmute(v));
1668        assert_eq!(r, 2);
1669        let r = vget_lane_p8::<3>(transmute(v));
1670        assert_eq!(r, 3);
1671        let r = vget_lane_p8::<5>(transmute(v));
1672        assert_eq!(r, 5);
1673    }
1674
1675    #[simd_test(enable = "neon")]
1676    unsafe fn test_vget_lane_p16() {
1677        let v = u16x4::new(0, 1, 2, 3);
1678        let r = vget_lane_p16::<2>(transmute(v));
1679        assert_eq!(r, 2);
1680        let r = vget_lane_p16::<3>(transmute(v));
1681        assert_eq!(r, 3);
1682        let r = vget_lane_p16::<0>(transmute(v));
1683        assert_eq!(r, 0);
1684        let r = vget_lane_p16::<1>(transmute(v));
1685        assert_eq!(r, 1);
1686    }
1687
1688    #[simd_test(enable = "neon")]
1689    unsafe fn test_vget_lane_s16() {
1690        let v = i16x4::new(0, 1, 2, 3);
1691        let r = vget_lane_s16::<2>(transmute(v));
1692        assert_eq!(r, 2);
1693        let r = vget_lane_s16::<3>(transmute(v));
1694        assert_eq!(r, 3);
1695        let r = vget_lane_s16::<0>(transmute(v));
1696        assert_eq!(r, 0);
1697        let r = vget_lane_s16::<1>(transmute(v));
1698        assert_eq!(r, 1);
1699    }
1700
1701    #[simd_test(enable = "neon")]
1702    unsafe fn test_vget_lane_u16() {
1703        let v = u16x4::new(0, 1, 2, 3);
1704        let r = vget_lane_u16::<2>(transmute(v));
1705        assert_eq!(r, 2);
1706        let r = vget_lane_u16::<3>(transmute(v));
1707        assert_eq!(r, 3);
1708        let r = vget_lane_u16::<0>(transmute(v));
1709        assert_eq!(r, 0);
1710        let r = vget_lane_u16::<1>(transmute(v));
1711        assert_eq!(r, 1);
1712    }
1713    #[simd_test(enable = "neon")]
1714    unsafe fn test_vget_lane_f32() {
1715        let v = f32x2::new(0.0, 1.0);
1716        let r = vget_lane_f32::<1>(transmute(v));
1717        assert_eq!(r, 1.0);
1718        let r = vget_lane_f32::<0>(transmute(v));
1719        assert_eq!(r, 0.0);
1720    }
1721
1722    #[simd_test(enable = "neon")]
1723    unsafe fn test_vget_lane_s32() {
1724        let v = i32x2::new(0, 1);
1725        let r = vget_lane_s32::<1>(transmute(v));
1726        assert_eq!(r, 1);
1727        let r = vget_lane_s32::<0>(transmute(v));
1728        assert_eq!(r, 0);
1729    }
1730
1731    #[simd_test(enable = "neon")]
1732    unsafe fn test_vget_lane_u32() {
1733        let v = u32x2::new(0, 1);
1734        let r = vget_lane_u32::<1>(transmute(v));
1735        assert_eq!(r, 1);
1736        let r = vget_lane_u32::<0>(transmute(v));
1737        assert_eq!(r, 0);
1738    }
1739
1740    #[simd_test(enable = "neon")]
1741    unsafe fn test_vget_lane_s64() {
1742        let v = i64x1::new(1);
1743        let r = vget_lane_s64::<0>(transmute(v));
1744        assert_eq!(r, 1);
1745    }
1746
1747    #[simd_test(enable = "neon")]
1748    unsafe fn test_vget_lane_p64() {
1749        let v = u64x1::new(1);
1750        let r = vget_lane_p64::<0>(transmute(v));
1751        assert_eq!(r, 1);
1752    }
1753
1754    #[simd_test(enable = "neon")]
1755    unsafe fn test_vgetq_lane_s8() {
1756        let v = i8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
1757        let r = vgetq_lane_s8::<7>(transmute(v));
1758        assert_eq!(r, 7);
1759        let r = vgetq_lane_s8::<13>(transmute(v));
1760        assert_eq!(r, 13);
1761        let r = vgetq_lane_s8::<3>(transmute(v));
1762        assert_eq!(r, 3);
1763        let r = vgetq_lane_s8::<0>(transmute(v));
1764        assert_eq!(r, 0);
1765    }
1766
1767    #[simd_test(enable = "neon")]
1768    unsafe fn test_vgetq_lane_p8() {
1769        let v = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
1770        let r = vgetq_lane_p8::<7>(transmute(v));
1771        assert_eq!(r, 7);
1772        let r = vgetq_lane_p8::<13>(transmute(v));
1773        assert_eq!(r, 13);
1774        let r = vgetq_lane_p8::<3>(transmute(v));
1775        assert_eq!(r, 3);
1776        let r = vgetq_lane_p8::<0>(transmute(v));
1777        assert_eq!(r, 0);
1778    }
1779
1780    #[simd_test(enable = "neon")]
1781    unsafe fn test_vgetq_lane_u8() {
1782        let v = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
1783        let r = vgetq_lane_u8::<7>(transmute(v));
1784        assert_eq!(r, 7);
1785        let r = vgetq_lane_u8::<13>(transmute(v));
1786        assert_eq!(r, 13);
1787        let r = vgetq_lane_u8::<3>(transmute(v));
1788        assert_eq!(r, 3);
1789        let r = vgetq_lane_u8::<0>(transmute(v));
1790        assert_eq!(r, 0);
1791    }
1792
1793    #[simd_test(enable = "neon")]
1794    unsafe fn test_vgetq_lane_s16() {
1795        let v = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1796        let r = vgetq_lane_s16::<3>(transmute(v));
1797        assert_eq!(r, 3);
1798        let r = vgetq_lane_s16::<6>(transmute(v));
1799        assert_eq!(r, 6);
1800        let r = vgetq_lane_s16::<0>(transmute(v));
1801        assert_eq!(r, 0);
1802    }
1803
1804    #[simd_test(enable = "neon")]
1805    unsafe fn test_vgetq_lane_p16() {
1806        let v = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
1807        let r = vgetq_lane_p16::<3>(transmute(v));
1808        assert_eq!(r, 3);
1809        let r = vgetq_lane_p16::<7>(transmute(v));
1810        assert_eq!(r, 7);
1811        let r = vgetq_lane_p16::<1>(transmute(v));
1812        assert_eq!(r, 1);
1813    }
1814    #[simd_test(enable = "neon")]
1815    unsafe fn test_vgetq_lane_f32() {
1816        let v = f32x4::new(0.0, 1.0, 2.0, 3.0);
1817        let r = vgetq_lane_f32::<3>(transmute(v));
1818        assert_eq!(r, 3.0);
1819        let r = vgetq_lane_f32::<0>(transmute(v));
1820        assert_eq!(r, 0.0);
1821        let r = vgetq_lane_f32::<2>(transmute(v));
1822        assert_eq!(r, 2.0);
1823        let r = vgetq_lane_f32::<1>(transmute(v));
1824        assert_eq!(r, 1.0);
1825    }
1826
1827    #[simd_test(enable = "neon")]
1828    unsafe fn test_vgetq_lane_s64() {
1829        let v = i64x2::new(0, 1);
1830        let r = vgetq_lane_s64::<1>(transmute(v));
1831        assert_eq!(r, 1);
1832        let r = vgetq_lane_s64::<0>(transmute(v));
1833        assert_eq!(r, 0);
1834    }
1835
1836    #[simd_test(enable = "neon")]
1837    unsafe fn test_vgetq_lane_p64() {
1838        let v = u64x2::new(0, 1);
1839        let r = vgetq_lane_p64::<1>(transmute(v));
1840        assert_eq!(r, 1);
1841        let r = vgetq_lane_p64::<0>(transmute(v));
1842        assert_eq!(r, 0);
1843    }
1844
1845    #[simd_test(enable = "neon")]
1846    unsafe fn test_vext_s64() {
1847        let a: i64x1 = i64x1::new(0);
1848        let b: i64x1 = i64x1::new(1);
1849        let e: i64x1 = i64x1::new(0);
1850        let r: i64x1 = transmute(vext_s64::<0>(transmute(a), transmute(b)));
1851        assert_eq!(r, e);
1852    }
1853
1854    #[simd_test(enable = "neon")]
1855    unsafe fn test_vext_u64() {
1856        let a: u64x1 = u64x1::new(0);
1857        let b: u64x1 = u64x1::new(1);
1858        let e: u64x1 = u64x1::new(0);
1859        let r: u64x1 = transmute(vext_u64::<0>(transmute(a), transmute(b)));
1860        assert_eq!(r, e);
1861    }
1862
1863    #[simd_test(enable = "neon")]
1864    unsafe fn test_vget_high_s8() {
1865        let a = i8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
1866        let e = i8x8::new(9, 10, 11, 12, 13, 14, 15, 16);
1867        let r: i8x8 = transmute(vget_high_s8(transmute(a)));
1868        assert_eq!(r, e);
1869    }
1870
1871    #[simd_test(enable = "neon")]
1872    unsafe fn test_vget_high_s16() {
1873        let a = i16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
1874        let e = i16x4::new(5, 6, 7, 8);
1875        let r: i16x4 = transmute(vget_high_s16(transmute(a)));
1876        assert_eq!(r, e);
1877    }
1878
1879    #[simd_test(enable = "neon")]
1880    unsafe fn test_vget_high_s32() {
1881        let a = i32x4::new(1, 2, 3, 4);
1882        let e = i32x2::new(3, 4);
1883        let r: i32x2 = transmute(vget_high_s32(transmute(a)));
1884        assert_eq!(r, e);
1885    }
1886
1887    #[simd_test(enable = "neon")]
1888    unsafe fn test_vget_high_s64() {
1889        let a = i64x2::new(1, 2);
1890        let e = i64x1::new(2);
1891        let r: i64x1 = transmute(vget_high_s64(transmute(a)));
1892        assert_eq!(r, e);
1893    }
1894
1895    #[simd_test(enable = "neon")]
1896    unsafe fn test_vget_high_u8() {
1897        let a = u8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
1898        let e = u8x8::new(9, 10, 11, 12, 13, 14, 15, 16);
1899        let r: u8x8 = transmute(vget_high_u8(transmute(a)));
1900        assert_eq!(r, e);
1901    }
1902
1903    #[simd_test(enable = "neon")]
1904    unsafe fn test_vget_high_u16() {
1905        let a = u16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
1906        let e = u16x4::new(5, 6, 7, 8);
1907        let r: u16x4 = transmute(vget_high_u16(transmute(a)));
1908        assert_eq!(r, e);
1909    }
1910
1911    #[simd_test(enable = "neon")]
1912    unsafe fn test_vget_high_u32() {
1913        let a = u32x4::new(1, 2, 3, 4);
1914        let e = u32x2::new(3, 4);
1915        let r: u32x2 = transmute(vget_high_u32(transmute(a)));
1916        assert_eq!(r, e);
1917    }
1918
1919    #[simd_test(enable = "neon")]
1920    unsafe fn test_vget_high_u64() {
1921        let a = u64x2::new(1, 2);
1922        let e = u64x1::new(2);
1923        let r: u64x1 = transmute(vget_high_u64(transmute(a)));
1924        assert_eq!(r, e);
1925    }
1926
1927    #[simd_test(enable = "neon")]
1928    unsafe fn test_vget_high_p8() {
1929        let a = u8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
1930        let e = u8x8::new(9, 10, 11, 12, 13, 14, 15, 16);
1931        let r: u8x8 = transmute(vget_high_p8(transmute(a)));
1932        assert_eq!(r, e);
1933    }
1934
1935    #[simd_test(enable = "neon")]
1936    unsafe fn test_vget_high_p16() {
1937        let a = u16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
1938        let e = u16x4::new(5, 6, 7, 8);
1939        let r: u16x4 = transmute(vget_high_p16(transmute(a)));
1940        assert_eq!(r, e);
1941    }
1942
1943    #[simd_test(enable = "neon")]
1944    unsafe fn test_vget_high_f32() {
1945        let a = f32x4::new(1.0, 2.0, 3.0, 4.0);
1946        let e = f32x2::new(3.0, 4.0);
1947        let r: f32x2 = transmute(vget_high_f32(transmute(a)));
1948        assert_eq!(r, e);
1949    }
1950
1951    #[simd_test(enable = "neon")]
1952    unsafe fn test_vget_low_s8() {
1953        let a = i8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
1954        let e = i8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
1955        let r: i8x8 = transmute(vget_low_s8(transmute(a)));
1956        assert_eq!(r, e);
1957    }
1958
1959    #[simd_test(enable = "neon")]
1960    unsafe fn test_vget_low_s16() {
1961        let a = i16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
1962        let e = i16x4::new(1, 2, 3, 4);
1963        let r: i16x4 = transmute(vget_low_s16(transmute(a)));
1964        assert_eq!(r, e);
1965    }
1966
1967    #[simd_test(enable = "neon")]
1968    unsafe fn test_vget_low_s32() {
1969        let a = i32x4::new(1, 2, 3, 4);
1970        let e = i32x2::new(1, 2);
1971        let r: i32x2 = transmute(vget_low_s32(transmute(a)));
1972        assert_eq!(r, e);
1973    }
1974
1975    #[simd_test(enable = "neon")]
1976    unsafe fn test_vget_low_s64() {
1977        let a = i64x2::new(1, 2);
1978        let e = i64x1::new(1);
1979        let r: i64x1 = transmute(vget_low_s64(transmute(a)));
1980        assert_eq!(r, e);
1981    }
1982
1983    #[simd_test(enable = "neon")]
1984    unsafe fn test_vget_low_u8() {
1985        let a = u8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
1986        let e = u8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
1987        let r: u8x8 = transmute(vget_low_u8(transmute(a)));
1988        assert_eq!(r, e);
1989    }
1990
1991    #[simd_test(enable = "neon")]
1992    unsafe fn test_vget_low_u16() {
1993        let a = u16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
1994        let e = u16x4::new(1, 2, 3, 4);
1995        let r: u16x4 = transmute(vget_low_u16(transmute(a)));
1996        assert_eq!(r, e);
1997    }
1998
1999    #[simd_test(enable = "neon")]
2000    unsafe fn test_vget_low_u32() {
2001        let a = u32x4::new(1, 2, 3, 4);
2002        let e = u32x2::new(1, 2);
2003        let r: u32x2 = transmute(vget_low_u32(transmute(a)));
2004        assert_eq!(r, e);
2005    }
2006
2007    #[simd_test(enable = "neon")]
2008    unsafe fn test_vget_low_u64() {
2009        let a = u64x2::new(1, 2);
2010        let e = u64x1::new(1);
2011        let r: u64x1 = transmute(vget_low_u64(transmute(a)));
2012        assert_eq!(r, e);
2013    }
2014
2015    #[simd_test(enable = "neon")]
2016    unsafe fn test_vget_low_p8() {
2017        let a = u8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
2018        let e = u8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
2019        let r: u8x8 = transmute(vget_low_p8(transmute(a)));
2020        assert_eq!(r, e);
2021    }
2022
2023    #[simd_test(enable = "neon")]
2024    unsafe fn test_vget_low_p16() {
2025        let a = u16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
2026        let e = u16x4::new(1, 2, 3, 4);
2027        let r: u16x4 = transmute(vget_low_p16(transmute(a)));
2028        assert_eq!(r, e);
2029    }
2030
2031    #[simd_test(enable = "neon")]
2032    unsafe fn test_vget_low_f32() {
2033        let a = f32x4::new(1.0, 2.0, 3.0, 4.0);
2034        let e = f32x2::new(1.0, 2.0);
2035        let r: f32x2 = transmute(vget_low_f32(transmute(a)));
2036        assert_eq!(r, e);
2037    }
2038
2039    #[simd_test(enable = "neon")]
2040    unsafe fn test_vdupq_n_s8() {
2041        let v: i8 = 42;
2042        let e = i8x16::new(
2043            42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
2044        );
2045        let r: i8x16 = transmute(vdupq_n_s8(v));
2046        assert_eq!(r, e);
2047    }
2048
2049    #[simd_test(enable = "neon")]
2050    unsafe fn test_vdupq_n_s16() {
2051        let v: i16 = 64;
2052        let e = i16x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2053        let r: i16x8 = transmute(vdupq_n_s16(v));
2054        assert_eq!(r, e);
2055    }
2056
2057    #[simd_test(enable = "neon")]
2058    unsafe fn test_vdupq_n_s32() {
2059        let v: i32 = 64;
2060        let e = i32x4::new(64, 64, 64, 64);
2061        let r: i32x4 = transmute(vdupq_n_s32(v));
2062        assert_eq!(r, e);
2063    }
2064
2065    #[simd_test(enable = "neon")]
2066    unsafe fn test_vdupq_n_s64() {
2067        let v: i64 = 64;
2068        let e = i64x2::new(64, 64);
2069        let r: i64x2 = transmute(vdupq_n_s64(v));
2070        assert_eq!(r, e);
2071    }
2072
2073    #[simd_test(enable = "neon")]
2074    unsafe fn test_vdupq_n_u8() {
2075        let v: u8 = 64;
2076        let e = u8x16::new(
2077            64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
2078        );
2079        let r: u8x16 = transmute(vdupq_n_u8(v));
2080        assert_eq!(r, e);
2081    }
2082
2083    #[simd_test(enable = "neon")]
2084    unsafe fn test_vdupq_n_u16() {
2085        let v: u16 = 64;
2086        let e = u16x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2087        let r: u16x8 = transmute(vdupq_n_u16(v));
2088        assert_eq!(r, e);
2089    }
2090
2091    #[simd_test(enable = "neon")]
2092    unsafe fn test_vdupq_n_u32() {
2093        let v: u32 = 64;
2094        let e = u32x4::new(64, 64, 64, 64);
2095        let r: u32x4 = transmute(vdupq_n_u32(v));
2096        assert_eq!(r, e);
2097    }
2098
2099    #[simd_test(enable = "neon")]
2100    unsafe fn test_vdupq_n_u64() {
2101        let v: u64 = 64;
2102        let e = u64x2::new(64, 64);
2103        let r: u64x2 = transmute(vdupq_n_u64(v));
2104        assert_eq!(r, e);
2105    }
2106
2107    #[simd_test(enable = "neon")]
2108    unsafe fn test_vdupq_n_p8() {
2109        let v: p8 = 64;
2110        let e = u8x16::new(
2111            64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
2112        );
2113        let r: u8x16 = transmute(vdupq_n_p8(v));
2114        assert_eq!(r, e);
2115    }
2116
2117    #[simd_test(enable = "neon")]
2118    unsafe fn test_vdupq_n_p16() {
2119        let v: p16 = 64;
2120        let e = u16x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2121        let r: u16x8 = transmute(vdupq_n_p16(v));
2122        assert_eq!(r, e);
2123    }
2124
2125    #[simd_test(enable = "neon")]
2126    unsafe fn test_vdupq_n_f32() {
2127        let v: f32 = 64.0;
2128        let e = f32x4::new(64.0, 64.0, 64.0, 64.0);
2129        let r: f32x4 = transmute(vdupq_n_f32(v));
2130        assert_eq!(r, e);
2131    }
2132
2133    #[simd_test(enable = "neon")]
2134    unsafe fn test_vdup_n_s8() {
2135        let v: i8 = 64;
2136        let e = i8x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2137        let r: i8x8 = transmute(vdup_n_s8(v));
2138        assert_eq!(r, e);
2139    }
2140
2141    #[simd_test(enable = "neon")]
2142    unsafe fn test_vdup_n_s16() {
2143        let v: i16 = 64;
2144        let e = i16x4::new(64, 64, 64, 64);
2145        let r: i16x4 = transmute(vdup_n_s16(v));
2146        assert_eq!(r, e);
2147    }
2148
2149    #[simd_test(enable = "neon")]
2150    unsafe fn test_vdup_n_s32() {
2151        let v: i32 = 64;
2152        let e = i32x2::new(64, 64);
2153        let r: i32x2 = transmute(vdup_n_s32(v));
2154        assert_eq!(r, e);
2155    }
2156
2157    #[simd_test(enable = "neon")]
2158    unsafe fn test_vdup_n_s64() {
2159        let v: i64 = 64;
2160        let e = i64x1::new(64);
2161        let r: i64x1 = transmute(vdup_n_s64(v));
2162        assert_eq!(r, e);
2163    }
2164
2165    #[simd_test(enable = "neon")]
2166    unsafe fn test_vdup_n_u8() {
2167        let v: u8 = 64;
2168        let e = u8x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2169        let r: u8x8 = transmute(vdup_n_u8(v));
2170        assert_eq!(r, e);
2171    }
2172
2173    #[simd_test(enable = "neon")]
2174    unsafe fn test_vdup_n_u16() {
2175        let v: u16 = 64;
2176        let e = u16x4::new(64, 64, 64, 64);
2177        let r: u16x4 = transmute(vdup_n_u16(v));
2178        assert_eq!(r, e);
2179    }
2180
2181    #[simd_test(enable = "neon")]
2182    unsafe fn test_vdup_n_u32() {
2183        let v: u32 = 64;
2184        let e = u32x2::new(64, 64);
2185        let r: u32x2 = transmute(vdup_n_u32(v));
2186        assert_eq!(r, e);
2187    }
2188
2189    #[simd_test(enable = "neon")]
2190    unsafe fn test_vdup_n_u64() {
2191        let v: u64 = 64;
2192        let e = u64x1::new(64);
2193        let r: u64x1 = transmute(vdup_n_u64(v));
2194        assert_eq!(r, e);
2195    }
2196
2197    #[simd_test(enable = "neon")]
2198    unsafe fn test_vdup_n_p8() {
2199        let v: p8 = 64;
2200        let e = u8x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2201        let r: u8x8 = transmute(vdup_n_p8(v));
2202        assert_eq!(r, e);
2203    }
2204
2205    #[simd_test(enable = "neon")]
2206    unsafe fn test_vdup_n_p16() {
2207        let v: p16 = 64;
2208        let e = u16x4::new(64, 64, 64, 64);
2209        let r: u16x4 = transmute(vdup_n_p16(v));
2210        assert_eq!(r, e);
2211    }
2212
2213    #[simd_test(enable = "neon")]
2214    unsafe fn test_vdup_n_f32() {
2215        let v: f32 = 64.0;
2216        let e = f32x2::new(64.0, 64.0);
2217        let r: f32x2 = transmute(vdup_n_f32(v));
2218        assert_eq!(r, e);
2219    }
2220
2221    #[simd_test(enable = "neon")]
2222    unsafe fn test_vldrq_p128() {
2223        let v: [p128; 2] = [1, 2];
2224        let e: p128 = 2;
2225        let r: p128 = vldrq_p128(v[1..].as_ptr());
2226        assert_eq!(r, e);
2227    }
2228
2229    #[simd_test(enable = "neon")]
2230    unsafe fn test_vstrq_p128() {
2231        let v: [p128; 2] = [1, 2];
2232        let e: p128 = 2;
2233        let mut r: p128 = 1;
2234        vstrq_p128(&mut r, v[1]);
2235        assert_eq!(r, e);
2236    }
2237
2238    #[simd_test(enable = "neon")]
2239    unsafe fn test_vmov_n_s8() {
2240        let v: i8 = 64;
2241        let e = i8x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2242        let r: i8x8 = transmute(vmov_n_s8(v));
2243        assert_eq!(r, e);
2244    }
2245
2246    #[simd_test(enable = "neon")]
2247    unsafe fn test_vmov_n_s16() {
2248        let v: i16 = 64;
2249        let e = i16x4::new(64, 64, 64, 64);
2250        let r: i16x4 = transmute(vmov_n_s16(v));
2251        assert_eq!(r, e);
2252    }
2253
2254    #[simd_test(enable = "neon")]
2255    unsafe fn test_vmov_n_s32() {
2256        let v: i32 = 64;
2257        let e = i32x2::new(64, 64);
2258        let r: i32x2 = transmute(vmov_n_s32(v));
2259        assert_eq!(r, e);
2260    }
2261
2262    #[simd_test(enable = "neon")]
2263    unsafe fn test_vmov_n_s64() {
2264        let v: i64 = 64;
2265        let e = i64x1::new(64);
2266        let r: i64x1 = transmute(vmov_n_s64(v));
2267        assert_eq!(r, e);
2268    }
2269
2270    #[simd_test(enable = "neon")]
2271    unsafe fn test_vmov_n_u8() {
2272        let v: u8 = 64;
2273        let e = u8x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2274        let r: u8x8 = transmute(vmov_n_u8(v));
2275        assert_eq!(r, e);
2276    }
2277
2278    #[simd_test(enable = "neon")]
2279    unsafe fn test_vmov_n_u16() {
2280        let v: u16 = 64;
2281        let e = u16x4::new(64, 64, 64, 64);
2282        let r: u16x4 = transmute(vmov_n_u16(v));
2283        assert_eq!(r, e);
2284    }
2285
2286    #[simd_test(enable = "neon")]
2287    unsafe fn test_vmov_n_u32() {
2288        let v: u32 = 64;
2289        let e = u32x2::new(64, 64);
2290        let r: u32x2 = transmute(vmov_n_u32(v));
2291        assert_eq!(r, e);
2292    }
2293
2294    #[simd_test(enable = "neon")]
2295    unsafe fn test_vmov_n_u64() {
2296        let v: u64 = 64;
2297        let e = u64x1::new(64);
2298        let r: u64x1 = transmute(vmov_n_u64(v));
2299        assert_eq!(r, e);
2300    }
2301
2302    #[simd_test(enable = "neon")]
2303    unsafe fn test_vmov_n_p8() {
2304        let v: p8 = 64;
2305        let e = u8x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2306        let r: u8x8 = transmute(vmov_n_p8(v));
2307        assert_eq!(r, e);
2308    }
2309
2310    #[simd_test(enable = "neon")]
2311    unsafe fn test_vmov_n_p16() {
2312        let v: p16 = 64;
2313        let e = u16x4::new(64, 64, 64, 64);
2314        let r: u16x4 = transmute(vmov_n_p16(v));
2315        assert_eq!(r, e);
2316    }
2317
2318    #[simd_test(enable = "neon")]
2319    unsafe fn test_vmov_n_f32() {
2320        let v: f32 = 64.0;
2321        let e = f32x2::new(64.0, 64.0);
2322        let r: f32x2 = transmute(vmov_n_f32(v));
2323        assert_eq!(r, e);
2324    }
2325
2326    #[simd_test(enable = "neon")]
2327    unsafe fn test_vmovq_n_s8() {
2328        let v: i8 = 64;
2329        let e = i8x16::new(
2330            64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
2331        );
2332        let r: i8x16 = transmute(vmovq_n_s8(v));
2333        assert_eq!(r, e);
2334    }
2335
2336    #[simd_test(enable = "neon")]
2337    unsafe fn test_vmovq_n_s16() {
2338        let v: i16 = 64;
2339        let e = i16x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2340        let r: i16x8 = transmute(vmovq_n_s16(v));
2341        assert_eq!(r, e);
2342    }
2343
2344    #[simd_test(enable = "neon")]
2345    unsafe fn test_vmovq_n_s32() {
2346        let v: i32 = 64;
2347        let e = i32x4::new(64, 64, 64, 64);
2348        let r: i32x4 = transmute(vmovq_n_s32(v));
2349        assert_eq!(r, e);
2350    }
2351
2352    #[simd_test(enable = "neon")]
2353    unsafe fn test_vmovq_n_s64() {
2354        let v: i64 = 64;
2355        let e = i64x2::new(64, 64);
2356        let r: i64x2 = transmute(vmovq_n_s64(v));
2357        assert_eq!(r, e);
2358    }
2359
2360    #[simd_test(enable = "neon")]
2361    unsafe fn test_vmovq_n_u8() {
2362        let v: u8 = 64;
2363        let e = u8x16::new(
2364            64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
2365        );
2366        let r: u8x16 = transmute(vmovq_n_u8(v));
2367        assert_eq!(r, e);
2368    }
2369
2370    #[simd_test(enable = "neon")]
2371    unsafe fn test_vmovq_n_u16() {
2372        let v: u16 = 64;
2373        let e = u16x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2374        let r: u16x8 = transmute(vmovq_n_u16(v));
2375        assert_eq!(r, e);
2376    }
2377
2378    #[simd_test(enable = "neon")]
2379    unsafe fn test_vmovq_n_u32() {
2380        let v: u32 = 64;
2381        let e = u32x4::new(64, 64, 64, 64);
2382        let r: u32x4 = transmute(vmovq_n_u32(v));
2383        assert_eq!(r, e);
2384    }
2385
2386    #[simd_test(enable = "neon")]
2387    unsafe fn test_vmovq_n_u64() {
2388        let v: u64 = 64;
2389        let e = u64x2::new(64, 64);
2390        let r: u64x2 = transmute(vmovq_n_u64(v));
2391        assert_eq!(r, e);
2392    }
2393
2394    #[simd_test(enable = "neon")]
2395    unsafe fn test_vmovq_n_p8() {
2396        let v: p8 = 64;
2397        let e = u8x16::new(
2398            64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
2399        );
2400        let r: u8x16 = transmute(vmovq_n_p8(v));
2401        assert_eq!(r, e);
2402    }
2403
2404    #[simd_test(enable = "neon")]
2405    unsafe fn test_vmovq_n_p16() {
2406        let v: p16 = 64;
2407        let e = u16x8::new(64, 64, 64, 64, 64, 64, 64, 64);
2408        let r: u16x8 = transmute(vmovq_n_p16(v));
2409        assert_eq!(r, e);
2410    }
2411
2412    #[simd_test(enable = "neon")]
2413    unsafe fn test_vmovq_n_f32() {
2414        let v: f32 = 64.0;
2415        let e = f32x4::new(64.0, 64.0, 64.0, 64.0);
2416        let r: f32x4 = transmute(vmovq_n_f32(v));
2417        assert_eq!(r, e);
2418    }
2419
2420    #[simd_test(enable = "neon")]
2421    unsafe fn test_vgetq_lane_u64() {
2422        let v = i64x2::new(1, 2);
2423        let r = vgetq_lane_u64::<1>(transmute(v));
2424        assert_eq!(r, 2);
2425    }
2426
2427    #[simd_test(enable = "neon")]
2428    unsafe fn test_vadd_s8() {
2429        test_ari_s8(
2430            |i, j| vadd_s8(i, j),
2431            |a: i8, b: i8| -> i8 { a.overflowing_add(b).0 },
2432        );
2433    }
2434    #[simd_test(enable = "neon")]
2435    unsafe fn test_vaddq_s8() {
2436        testq_ari_s8(
2437            |i, j| vaddq_s8(i, j),
2438            |a: i8, b: i8| -> i8 { a.overflowing_add(b).0 },
2439        );
2440    }
2441    #[simd_test(enable = "neon")]
2442    unsafe fn test_vadd_s16() {
2443        test_ari_s16(
2444            |i, j| vadd_s16(i, j),
2445            |a: i16, b: i16| -> i16 { a.overflowing_add(b).0 },
2446        );
2447    }
2448    #[simd_test(enable = "neon")]
2449    unsafe fn test_vaddq_s16() {
2450        testq_ari_s16(
2451            |i, j| vaddq_s16(i, j),
2452            |a: i16, b: i16| -> i16 { a.overflowing_add(b).0 },
2453        );
2454    }
2455    #[simd_test(enable = "neon")]
2456    unsafe fn test_vadd_s32() {
2457        test_ari_s32(
2458            |i, j| vadd_s32(i, j),
2459            |a: i32, b: i32| -> i32 { a.overflowing_add(b).0 },
2460        );
2461    }
2462    #[simd_test(enable = "neon")]
2463    unsafe fn test_vaddq_s32() {
2464        testq_ari_s32(
2465            |i, j| vaddq_s32(i, j),
2466            |a: i32, b: i32| -> i32 { a.overflowing_add(b).0 },
2467        );
2468    }
2469
2470    #[simd_test(enable = "neon")]
2471    unsafe fn test_vadd_u8() {
2472        test_ari_u8(
2473            |i, j| vadd_u8(i, j),
2474            |a: u8, b: u8| -> u8 { a.overflowing_add(b).0 },
2475        );
2476    }
2477    #[simd_test(enable = "neon")]
2478    unsafe fn test_vaddq_u8() {
2479        testq_ari_u8(
2480            |i, j| vaddq_u8(i, j),
2481            |a: u8, b: u8| -> u8 { a.overflowing_add(b).0 },
2482        );
2483    }
2484    #[simd_test(enable = "neon")]
2485    unsafe fn test_vadd_u16() {
2486        test_ari_u16(
2487            |i, j| vadd_u16(i, j),
2488            |a: u16, b: u16| -> u16 { a.overflowing_add(b).0 },
2489        );
2490    }
2491    #[simd_test(enable = "neon")]
2492    unsafe fn test_vaddq_u16() {
2493        testq_ari_u16(
2494            |i, j| vaddq_u16(i, j),
2495            |a: u16, b: u16| -> u16 { a.overflowing_add(b).0 },
2496        );
2497    }
2498    #[simd_test(enable = "neon")]
2499    unsafe fn test_vadd_u32() {
2500        test_ari_u32(
2501            |i, j| vadd_u32(i, j),
2502            |a: u32, b: u32| -> u32 { a.overflowing_add(b).0 },
2503        );
2504    }
2505    #[simd_test(enable = "neon")]
2506    unsafe fn test_vaddq_u32() {
2507        testq_ari_u32(
2508            |i, j| vaddq_u32(i, j),
2509            |a: u32, b: u32| -> u32 { a.overflowing_add(b).0 },
2510        );
2511    }
2512
2513    #[simd_test(enable = "neon")]
2514    unsafe fn test_vadd_f32() {
2515        test_ari_f32(|i, j| vadd_f32(i, j), |a: f32, b: f32| -> f32 { a + b });
2516    }
2517    #[simd_test(enable = "neon")]
2518    unsafe fn test_vaddq_f32() {
2519        testq_ari_f32(|i, j| vaddq_f32(i, j), |a: f32, b: f32| -> f32 { a + b });
2520    }
2521
2522    #[simd_test(enable = "neon")]
2523    unsafe fn test_vaddl_s8() {
2524        let v = i8::MAX;
2525        let a = i8x8::new(v, v, v, v, v, v, v, v);
2526        let v = 2 * (v as i16);
2527        let e = i16x8::new(v, v, v, v, v, v, v, v);
2528        let r: i16x8 = transmute(vaddl_s8(transmute(a), transmute(a)));
2529        assert_eq!(r, e);
2530    }
2531
2532    #[simd_test(enable = "neon")]
2533    unsafe fn test_vaddl_s16() {
2534        let v = i16::MAX;
2535        let a = i16x4::new(v, v, v, v);
2536        let v = 2 * (v as i32);
2537        let e = i32x4::new(v, v, v, v);
2538        let r: i32x4 = transmute(vaddl_s16(transmute(a), transmute(a)));
2539        assert_eq!(r, e);
2540    }
2541
2542    #[simd_test(enable = "neon")]
2543    unsafe fn test_vaddl_s32() {
2544        let v = i32::MAX;
2545        let a = i32x2::new(v, v);
2546        let v = 2 * (v as i64);
2547        let e = i64x2::new(v, v);
2548        let r: i64x2 = transmute(vaddl_s32(transmute(a), transmute(a)));
2549        assert_eq!(r, e);
2550    }
2551
2552    #[simd_test(enable = "neon")]
2553    unsafe fn test_vaddl_u8() {
2554        let v = u8::MAX;
2555        let a = u8x8::new(v, v, v, v, v, v, v, v);
2556        let v = 2 * (v as u16);
2557        let e = u16x8::new(v, v, v, v, v, v, v, v);
2558        let r: u16x8 = transmute(vaddl_u8(transmute(a), transmute(a)));
2559        assert_eq!(r, e);
2560    }
2561
2562    #[simd_test(enable = "neon")]
2563    unsafe fn test_vaddl_u16() {
2564        let v = u16::MAX;
2565        let a = u16x4::new(v, v, v, v);
2566        let v = 2 * (v as u32);
2567        let e = u32x4::new(v, v, v, v);
2568        let r: u32x4 = transmute(vaddl_u16(transmute(a), transmute(a)));
2569        assert_eq!(r, e);
2570    }
2571
2572    #[simd_test(enable = "neon")]
2573    unsafe fn test_vaddl_u32() {
2574        let v = u32::MAX;
2575        let a = u32x2::new(v, v);
2576        let v = 2 * (v as u64);
2577        let e = u64x2::new(v, v);
2578        let r: u64x2 = transmute(vaddl_u32(transmute(a), transmute(a)));
2579        assert_eq!(r, e);
2580    }
2581
2582    #[simd_test(enable = "neon")]
2583    unsafe fn test_vaddl_high_s8() {
2584        let a = i8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
2585        let x = i8::MAX;
2586        let b = i8x16::new(x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x);
2587        let x = x as i16;
2588        let e = i16x8::new(x + 8, x + 9, x + 10, x + 11, x + 12, x + 13, x + 14, x + 15);
2589        let r: i16x8 = transmute(vaddl_high_s8(transmute(a), transmute(b)));
2590        assert_eq!(r, e);
2591    }
2592
2593    #[simd_test(enable = "neon")]
2594    unsafe fn test_vaddl_high_s16() {
2595        let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
2596        let x = i16::MAX;
2597        let b = i16x8::new(x, x, x, x, x, x, x, x);
2598        let x = x as i32;
2599        let e = i32x4::new(x + 4, x + 5, x + 6, x + 7);
2600        let r: i32x4 = transmute(vaddl_high_s16(transmute(a), transmute(b)));
2601        assert_eq!(r, e);
2602    }
2603
2604    #[simd_test(enable = "neon")]
2605    unsafe fn test_vaddl_high_s32() {
2606        let a = i32x4::new(0, 1, 2, 3);
2607        let x = i32::MAX;
2608        let b = i32x4::new(x, x, x, x);
2609        let x = x as i64;
2610        let e = i64x2::new(x + 2, x + 3);
2611        let r: i64x2 = transmute(vaddl_high_s32(transmute(a), transmute(b)));
2612        assert_eq!(r, e);
2613    }
2614
2615    #[simd_test(enable = "neon")]
2616    unsafe fn test_vaddl_high_u8() {
2617        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
2618        let x = u8::MAX;
2619        let b = u8x16::new(x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x);
2620        let x = x as u16;
2621        let e = u16x8::new(x + 8, x + 9, x + 10, x + 11, x + 12, x + 13, x + 14, x + 15);
2622        let r: u16x8 = transmute(vaddl_high_u8(transmute(a), transmute(b)));
2623        assert_eq!(r, e);
2624    }
2625
2626    #[simd_test(enable = "neon")]
2627    unsafe fn test_vaddl_high_u16() {
2628        let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
2629        let x = u16::MAX;
2630        let b = u16x8::new(x, x, x, x, x, x, x, x);
2631        let x = x as u32;
2632        let e = u32x4::new(x + 4, x + 5, x + 6, x + 7);
2633        let r: u32x4 = transmute(vaddl_high_u16(transmute(a), transmute(b)));
2634        assert_eq!(r, e);
2635    }
2636
2637    #[simd_test(enable = "neon")]
2638    unsafe fn test_vaddl_high_u32() {
2639        let a = u32x4::new(0, 1, 2, 3);
2640        let x = u32::MAX;
2641        let b = u32x4::new(x, x, x, x);
2642        let x = x as u64;
2643        let e = u64x2::new(x + 2, x + 3);
2644        let r: u64x2 = transmute(vaddl_high_u32(transmute(a), transmute(b)));
2645        assert_eq!(r, e);
2646    }
2647
2648    #[simd_test(enable = "neon")]
2649    unsafe fn test_vaddw_s8() {
2650        let x = i16::MAX;
2651        let a = i16x8::new(x, 1, 2, 3, 4, 5, 6, 7);
2652        let y = i8::MAX;
2653        let b = i8x8::new(y, y, y, y, y, y, y, y);
2654        let y = y as i16;
2655        let e = i16x8::new(
2656            x.wrapping_add(y),
2657            1 + y,
2658            2 + y,
2659            3 + y,
2660            4 + y,
2661            5 + y,
2662            6 + y,
2663            7 + y,
2664        );
2665        let r: i16x8 = transmute(vaddw_s8(transmute(a), transmute(b)));
2666        assert_eq!(r, e);
2667    }
2668
2669    #[simd_test(enable = "neon")]
2670    unsafe fn test_vaddw_s16() {
2671        let x = i32::MAX;
2672        let a = i32x4::new(x, 1, 2, 3);
2673        let y = i16::MAX;
2674        let b = i16x4::new(y, y, y, y);
2675        let y = y as i32;
2676        let e = i32x4::new(x.wrapping_add(y), 1 + y, 2 + y, 3 + y);
2677        let r: i32x4 = transmute(vaddw_s16(transmute(a), transmute(b)));
2678        assert_eq!(r, e);
2679    }
2680
2681    #[simd_test(enable = "neon")]
2682    unsafe fn test_vaddw_s32() {
2683        let x = i64::MAX;
2684        let a = i64x2::new(x, 1);
2685        let y = i32::MAX;
2686        let b = i32x2::new(y, y);
2687        let y = y as i64;
2688        let e = i64x2::new(x.wrapping_add(y), 1 + y);
2689        let r: i64x2 = transmute(vaddw_s32(transmute(a), transmute(b)));
2690        assert_eq!(r, e);
2691    }
2692
2693    #[simd_test(enable = "neon")]
2694    unsafe fn test_vaddw_u8() {
2695        let x = u16::MAX;
2696        let a = u16x8::new(x, 1, 2, 3, 4, 5, 6, 7);
2697        let y = u8::MAX;
2698        let b = u8x8::new(y, y, y, y, y, y, y, y);
2699        let y = y as u16;
2700        let e = u16x8::new(
2701            x.wrapping_add(y),
2702            1 + y,
2703            2 + y,
2704            3 + y,
2705            4 + y,
2706            5 + y,
2707            6 + y,
2708            7 + y,
2709        );
2710        let r: u16x8 = transmute(vaddw_u8(transmute(a), transmute(b)));
2711        assert_eq!(r, e);
2712    }
2713
2714    #[simd_test(enable = "neon")]
2715    unsafe fn test_vaddw_u16() {
2716        let x = u32::MAX;
2717        let a = u32x4::new(x, 1, 2, 3);
2718        let y = u16::MAX;
2719        let b = u16x4::new(y, y, y, y);
2720        let y = y as u32;
2721        let e = u32x4::new(x.wrapping_add(y), 1 + y, 2 + y, 3 + y);
2722        let r: u32x4 = transmute(vaddw_u16(transmute(a), transmute(b)));
2723        assert_eq!(r, e);
2724    }
2725
2726    #[simd_test(enable = "neon")]
2727    unsafe fn test_vaddw_u32() {
2728        let x = u64::MAX;
2729        let a = u64x2::new(x, 1);
2730        let y = u32::MAX;
2731        let b = u32x2::new(y, y);
2732        let y = y as u64;
2733        let e = u64x2::new(x.wrapping_add(y), 1 + y);
2734        let r: u64x2 = transmute(vaddw_u32(transmute(a), transmute(b)));
2735        assert_eq!(r, e);
2736    }
2737
2738    #[simd_test(enable = "neon")]
2739    unsafe fn test_vaddw_high_s8() {
2740        let x = i16::MAX;
2741        let a = i16x8::new(x, 1, 2, 3, 4, 5, 6, 7);
2742        let y = i8::MAX;
2743        let b = i8x16::new(0, 0, 0, 0, 0, 0, 0, 0, y, y, y, y, y, y, y, y);
2744        let y = y as i16;
2745        let e = i16x8::new(
2746            x.wrapping_add(y),
2747            1 + y,
2748            2 + y,
2749            3 + y,
2750            4 + y,
2751            5 + y,
2752            6 + y,
2753            7 + y,
2754        );
2755        let r: i16x8 = transmute(vaddw_high_s8(transmute(a), transmute(b)));
2756        assert_eq!(r, e);
2757    }
2758
2759    #[simd_test(enable = "neon")]
2760    unsafe fn test_vaddw_high_s16() {
2761        let x = i32::MAX;
2762        let a = i32x4::new(x, 1, 2, 3);
2763        let y = i16::MAX;
2764        let b = i16x8::new(0, 0, 0, 0, y, y, y, y);
2765        let y = y as i32;
2766        let e = i32x4::new(x.wrapping_add(y), 1 + y, 2 + y, 3 + y);
2767        let r: i32x4 = transmute(vaddw_high_s16(transmute(a), transmute(b)));
2768        assert_eq!(r, e);
2769    }
2770
2771    #[simd_test(enable = "neon")]
2772    unsafe fn test_vaddw_high_s32() {
2773        let x = i64::MAX;
2774        let a = i64x2::new(x, 1);
2775        let y = i32::MAX;
2776        let b = i32x4::new(0, 0, y, y);
2777        let y = y as i64;
2778        let e = i64x2::new(x.wrapping_add(y), 1 + y);
2779        let r: i64x2 = transmute(vaddw_high_s32(transmute(a), transmute(b)));
2780        assert_eq!(r, e);
2781    }
2782
2783    #[simd_test(enable = "neon")]
2784    unsafe fn test_vaddw_high_u8() {
2785        let x = u16::MAX;
2786        let a = u16x8::new(x, 1, 2, 3, 4, 5, 6, 7);
2787        let y = u8::MAX;
2788        let b = u8x16::new(0, 0, 0, 0, 0, 0, 0, 0, y, y, y, y, y, y, y, y);
2789        let y = y as u16;
2790        let e = u16x8::new(
2791            x.wrapping_add(y),
2792            1 + y,
2793            2 + y,
2794            3 + y,
2795            4 + y,
2796            5 + y,
2797            6 + y,
2798            7 + y,
2799        );
2800        let r: u16x8 = transmute(vaddw_high_u8(transmute(a), transmute(b)));
2801        assert_eq!(r, e);
2802    }
2803
2804    #[simd_test(enable = "neon")]
2805    unsafe fn test_vaddw_high_u16() {
2806        let x = u32::MAX;
2807        let a = u32x4::new(x, 1, 2, 3);
2808        let y = u16::MAX;
2809        let b = u16x8::new(0, 0, 0, 0, y, y, y, y);
2810        let y = y as u32;
2811        let e = u32x4::new(x.wrapping_add(y), 1 + y, 2 + y, 3 + y);
2812        let r: u32x4 = transmute(vaddw_high_u16(transmute(a), transmute(b)));
2813        assert_eq!(r, e);
2814    }
2815
2816    #[simd_test(enable = "neon")]
2817    unsafe fn test_vaddw_high_u32() {
2818        let x = u64::MAX;
2819        let a = u64x2::new(x, 1);
2820        let y = u32::MAX;
2821        let b = u32x4::new(0, 0, y, y);
2822        let y = y as u64;
2823        let e = u64x2::new(x.wrapping_add(y), 1 + y);
2824        let r: u64x2 = transmute(vaddw_high_u32(transmute(a), transmute(b)));
2825        assert_eq!(r, e);
2826    }
2827
2828    #[simd_test(enable = "neon")]
2829    unsafe fn test_vmvn_s8() {
2830        let a = i8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
2831        let e = i8x8::new(-1, -2, -3, -4, -5, -6, -7, -8);
2832        let r: i8x8 = transmute(vmvn_s8(transmute(a)));
2833        assert_eq!(r, e);
2834    }
2835
2836    #[simd_test(enable = "neon")]
2837    unsafe fn test_vmvnq_s8() {
2838        let a = i8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
2839        let e = i8x16::new(
2840            -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16,
2841        );
2842        let r: i8x16 = transmute(vmvnq_s8(transmute(a)));
2843        assert_eq!(r, e);
2844    }
2845
2846    #[simd_test(enable = "neon")]
2847    unsafe fn test_vmvn_s16() {
2848        let a = i16x4::new(0, 1, 2, 3);
2849        let e = i16x4::new(-1, -2, -3, -4);
2850        let r: i16x4 = transmute(vmvn_s16(transmute(a)));
2851        assert_eq!(r, e);
2852    }
2853
2854    #[simd_test(enable = "neon")]
2855    unsafe fn test_vmvnq_s16() {
2856        let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
2857        let e = i16x8::new(-1, -2, -3, -4, -5, -6, -7, -8);
2858        let r: i16x8 = transmute(vmvnq_s16(transmute(a)));
2859        assert_eq!(r, e);
2860    }
2861
2862    #[simd_test(enable = "neon")]
2863    unsafe fn test_vmvn_s32() {
2864        let a = i32x2::new(0, 1);
2865        let e = i32x2::new(-1, -2);
2866        let r: i32x2 = transmute(vmvn_s32(transmute(a)));
2867        assert_eq!(r, e);
2868    }
2869
2870    #[simd_test(enable = "neon")]
2871    unsafe fn test_vmvnq_s32() {
2872        let a = i32x4::new(0, 1, 2, 3);
2873        let e = i32x4::new(-1, -2, -3, -4);
2874        let r: i32x4 = transmute(vmvnq_s32(transmute(a)));
2875        assert_eq!(r, e);
2876    }
2877
2878    #[simd_test(enable = "neon")]
2879    unsafe fn test_vmvn_u8() {
2880        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
2881        let e = u8x8::new(255, 254, 253, 252, 251, 250, 249, 248);
2882        let r: u8x8 = transmute(vmvn_u8(transmute(a)));
2883        assert_eq!(r, e);
2884    }
2885
2886    #[simd_test(enable = "neon")]
2887    unsafe fn test_vmvnq_u8() {
2888        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
2889        let e = u8x16::new(
2890            255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240,
2891        );
2892        let r: u8x16 = transmute(vmvnq_u8(transmute(a)));
2893        assert_eq!(r, e);
2894    }
2895
2896    #[simd_test(enable = "neon")]
2897    unsafe fn test_vmvn_u16() {
2898        let a = u16x4::new(0, 1, 2, 3);
2899        let e = u16x4::new(65_535, 65_534, 65_533, 65_532);
2900        let r: u16x4 = transmute(vmvn_u16(transmute(a)));
2901        assert_eq!(r, e);
2902    }
2903
2904    #[simd_test(enable = "neon")]
2905    unsafe fn test_vmvnq_u16() {
2906        let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
2907        let e = u16x8::new(
2908            65_535, 65_534, 65_533, 65_532, 65_531, 65_530, 65_529, 65_528,
2909        );
2910        let r: u16x8 = transmute(vmvnq_u16(transmute(a)));
2911        assert_eq!(r, e);
2912    }
2913
2914    #[simd_test(enable = "neon")]
2915    unsafe fn test_vmvn_u32() {
2916        let a = u32x2::new(0, 1);
2917        let e = u32x2::new(4_294_967_295, 4_294_967_294);
2918        let r: u32x2 = transmute(vmvn_u32(transmute(a)));
2919        assert_eq!(r, e);
2920    }
2921
2922    #[simd_test(enable = "neon")]
2923    unsafe fn test_vmvnq_u32() {
2924        let a = u32x4::new(0, 1, 2, 3);
2925        let e = u32x4::new(4_294_967_295, 4_294_967_294, 4_294_967_293, 4_294_967_292);
2926        let r: u32x4 = transmute(vmvnq_u32(transmute(a)));
2927        assert_eq!(r, e);
2928    }
2929
2930    #[simd_test(enable = "neon")]
2931    unsafe fn test_vmvn_p8() {
2932        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
2933        let e = u8x8::new(255, 254, 253, 252, 251, 250, 249, 248);
2934        let r: u8x8 = transmute(vmvn_p8(transmute(a)));
2935        assert_eq!(r, e);
2936    }
2937
2938    #[simd_test(enable = "neon")]
2939    unsafe fn test_vmvnq_p8() {
2940        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
2941        let e = u8x16::new(
2942            255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240,
2943        );
2944        let r: u8x16 = transmute(vmvnq_p8(transmute(a)));
2945        assert_eq!(r, e);
2946    }
2947
2948    #[simd_test(enable = "neon")]
2949    unsafe fn test_vbic_s8() {
2950        let a = i8x8::new(0, -1, -2, -3, -4, -5, -6, -7);
2951        let b = i8x8::new(1, 1, 1, 1, 1, 1, 1, 1);
2952        let e = i8x8::new(0, -2, -2, -4, -4, -6, -6, -8);
2953        let r: i8x8 = transmute(vbic_s8(transmute(a), transmute(b)));
2954        assert_eq!(r, e);
2955    }
2956
2957    #[simd_test(enable = "neon")]
2958    unsafe fn test_vbicq_s8() {
2959        let a = i8x16::new(
2960            0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15,
2961        );
2962        let b = i8x16::new(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
2963        let e = i8x16::new(
2964            0, -2, -2, -4, -4, -6, -6, -8, -8, -10, -10, -12, -12, -14, -14, -16,
2965        );
2966        let r: i8x16 = transmute(vbicq_s8(transmute(a), transmute(b)));
2967        assert_eq!(r, e);
2968    }
2969
2970    #[simd_test(enable = "neon")]
2971    unsafe fn test_vbic_s16() {
2972        let a = i16x4::new(0, -1, -2, -3);
2973        let b = i16x4::new(1, 1, 1, 1);
2974        let e = i16x4::new(0, -2, -2, -4);
2975        let r: i16x4 = transmute(vbic_s16(transmute(a), transmute(b)));
2976        assert_eq!(r, e);
2977    }
2978
2979    #[simd_test(enable = "neon")]
2980    unsafe fn test_vbicq_s16() {
2981        let a = i16x8::new(0, -1, -2, -3, -4, -5, -6, -7);
2982        let b = i16x8::new(1, 1, 1, 1, 1, 1, 1, 1);
2983        let e = i16x8::new(0, -2, -2, -4, -4, -6, -6, -8);
2984        let r: i16x8 = transmute(vbicq_s16(transmute(a), transmute(b)));
2985        assert_eq!(r, e);
2986    }
2987
2988    #[simd_test(enable = "neon")]
2989    unsafe fn test_vbic_s32() {
2990        let a = i32x2::new(0, -1);
2991        let b = i32x2::new(1, 1);
2992        let e = i32x2::new(0, -2);
2993        let r: i32x2 = transmute(vbic_s32(transmute(a), transmute(b)));
2994        assert_eq!(r, e);
2995    }
2996
2997    #[simd_test(enable = "neon")]
2998    unsafe fn test_vbicq_s32() {
2999        let a = i32x4::new(0, -1, -2, -3);
3000        let b = i32x4::new(1, 1, 1, 1);
3001        let e = i32x4::new(0, -2, -2, -4);
3002        let r: i32x4 = transmute(vbicq_s32(transmute(a), transmute(b)));
3003        assert_eq!(r, e);
3004    }
3005
3006    #[simd_test(enable = "neon")]
3007    unsafe fn test_vbic_s64() {
3008        let a = i64x1::new(-1);
3009        let b = i64x1::new(1);
3010        let e = i64x1::new(-2);
3011        let r: i64x1 = transmute(vbic_s64(transmute(a), transmute(b)));
3012        assert_eq!(r, e);
3013    }
3014
3015    #[simd_test(enable = "neon")]
3016    unsafe fn test_vbicq_s64() {
3017        let a = i64x2::new(0, -1);
3018        let b = i64x2::new(1, 1);
3019        let e = i64x2::new(0, -2);
3020        let r: i64x2 = transmute(vbicq_s64(transmute(a), transmute(b)));
3021        assert_eq!(r, e);
3022    }
3023
3024    #[simd_test(enable = "neon")]
3025    unsafe fn test_vbic_u8() {
3026        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
3027        let b = u8x8::new(1, 1, 1, 1, 1, 1, 1, 1);
3028        let e = u8x8::new(0, 0, 2, 2, 4, 4, 6, 6);
3029        let r: u8x8 = transmute(vbic_u8(transmute(a), transmute(b)));
3030        assert_eq!(r, e);
3031    }
3032
3033    #[simd_test(enable = "neon")]
3034    unsafe fn test_vbicq_u8() {
3035        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
3036        let b = u8x16::new(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
3037        let e = u8x16::new(0, 0, 2, 2, 4, 4, 6, 6, 8, 8, 10, 10, 12, 12, 14, 14);
3038        let r: u8x16 = transmute(vbicq_u8(transmute(a), transmute(b)));
3039        assert_eq!(r, e);
3040    }
3041
3042    #[simd_test(enable = "neon")]
3043    unsafe fn test_vbic_u16() {
3044        let a = u16x4::new(0, 1, 2, 3);
3045        let b = u16x4::new(1, 1, 1, 1);
3046        let e = u16x4::new(0, 0, 2, 2);
3047        let r: u16x4 = transmute(vbic_u16(transmute(a), transmute(b)));
3048        assert_eq!(r, e);
3049    }
3050
3051    #[simd_test(enable = "neon")]
3052    unsafe fn test_vbicq_u16() {
3053        let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
3054        let b = u16x8::new(1, 1, 1, 1, 1, 1, 1, 1);
3055        let e = u16x8::new(0, 0, 2, 2, 4, 4, 6, 6);
3056        let r: u16x8 = transmute(vbicq_u16(transmute(a), transmute(b)));
3057        assert_eq!(r, e);
3058    }
3059
3060    #[simd_test(enable = "neon")]
3061    unsafe fn test_vbic_u32() {
3062        let a = u32x2::new(0, 1);
3063        let b = u32x2::new(1, 1);
3064        let e = u32x2::new(0, 0);
3065        let r: u32x2 = transmute(vbic_u32(transmute(a), transmute(b)));
3066        assert_eq!(r, e);
3067    }
3068
3069    #[simd_test(enable = "neon")]
3070    unsafe fn test_vbicq_u32() {
3071        let a = u32x4::new(0, 1, 2, 3);
3072        let b = u32x4::new(1, 1, 1, 1);
3073        let e = u32x4::new(0, 0, 2, 2);
3074        let r: u32x4 = transmute(vbicq_u32(transmute(a), transmute(b)));
3075        assert_eq!(r, e);
3076    }
3077
3078    #[simd_test(enable = "neon")]
3079    unsafe fn test_vbic_u64() {
3080        let a = u64x1::new(1);
3081        let b = u64x1::new(1);
3082        let e = u64x1::new(0);
3083        let r: u64x1 = transmute(vbic_u64(transmute(a), transmute(b)));
3084        assert_eq!(r, e);
3085    }
3086
3087    #[simd_test(enable = "neon")]
3088    unsafe fn test_vbicq_u64() {
3089        let a = u64x2::new(0, 1);
3090        let b = u64x2::new(1, 1);
3091        let e = u64x2::new(0, 0);
3092        let r: u64x2 = transmute(vbicq_u64(transmute(a), transmute(b)));
3093        assert_eq!(r, e);
3094    }
3095
3096    #[simd_test(enable = "neon")]
3097    unsafe fn test_vbsl_s8() {
3098        let a = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, 0, u8::MAX, 0);
3099        let b = i8x8::new(
3100            i8::MAX,
3101            i8::MAX,
3102            i8::MAX,
3103            i8::MAX,
3104            i8::MAX,
3105            i8::MAX,
3106            i8::MAX,
3107            i8::MAX,
3108        );
3109        let c = i8x8::new(
3110            i8::MIN,
3111            i8::MIN,
3112            i8::MIN,
3113            i8::MIN,
3114            i8::MIN,
3115            i8::MIN,
3116            i8::MIN,
3117            i8::MIN,
3118        );
3119        let e = i8x8::new(
3120            i8::MAX,
3121            i8::MIN | 1,
3122            i8::MAX,
3123            i8::MIN | 2,
3124            i8::MAX,
3125            i8::MIN,
3126            i8::MAX,
3127            i8::MIN,
3128        );
3129        let r: i8x8 = transmute(vbsl_s8(transmute(a), transmute(b), transmute(c)));
3130        assert_eq!(r, e);
3131    }
3132    #[simd_test(enable = "neon")]
3133    unsafe fn test_vbsl_s16() {
3134        let a = u16x4::new(u16::MAX, 0, 1, 2);
3135        let b = i16x4::new(i16::MAX, i16::MAX, i16::MAX, i16::MAX);
3136        let c = i16x4::new(i16::MIN, i16::MIN, i16::MIN, i16::MIN);
3137        let e = i16x4::new(i16::MAX, i16::MIN, i16::MIN | 1, i16::MIN | 2);
3138        let r: i16x4 = transmute(vbsl_s16(transmute(a), transmute(b), transmute(c)));
3139        assert_eq!(r, e);
3140    }
3141    #[simd_test(enable = "neon")]
3142    unsafe fn test_vbsl_s32() {
3143        let a = u32x2::new(u32::MAX, 1);
3144        let b = i32x2::new(i32::MAX, i32::MAX);
3145        let c = i32x2::new(i32::MIN, i32::MIN);
3146        let e = i32x2::new(i32::MAX, i32::MIN | 1);
3147        let r: i32x2 = transmute(vbsl_s32(transmute(a), transmute(b), transmute(c)));
3148        assert_eq!(r, e);
3149    }
3150    #[simd_test(enable = "neon")]
3151    unsafe fn test_vbsl_s64() {
3152        let a = u64x1::new(1);
3153        let b = i64x1::new(i64::MAX);
3154        let c = i64x1::new(i64::MIN);
3155        let e = i64x1::new(i64::MIN | 1);
3156        let r: i64x1 = transmute(vbsl_s64(transmute(a), transmute(b), transmute(c)));
3157        assert_eq!(r, e);
3158    }
3159    #[simd_test(enable = "neon")]
3160    unsafe fn test_vbsl_u8() {
3161        let a = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, 0, u8::MAX, 0);
3162        let b = u8x8::new(
3163            u8::MAX,
3164            u8::MAX,
3165            u8::MAX,
3166            u8::MAX,
3167            u8::MAX,
3168            u8::MAX,
3169            u8::MAX,
3170            u8::MAX,
3171        );
3172        let c = u8x8::new(
3173            u8::MIN,
3174            u8::MIN,
3175            u8::MIN,
3176            u8::MIN,
3177            u8::MIN,
3178            u8::MIN,
3179            u8::MIN,
3180            u8::MIN,
3181        );
3182        let e = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, u8::MIN, u8::MAX, u8::MIN);
3183        let r: u8x8 = transmute(vbsl_u8(transmute(a), transmute(b), transmute(c)));
3184        assert_eq!(r, e);
3185    }
3186    #[simd_test(enable = "neon")]
3187    unsafe fn test_vbsl_u16() {
3188        let a = u16x4::new(u16::MAX, 0, 1, 2);
3189        let b = u16x4::new(u16::MAX, u16::MAX, u16::MAX, u16::MAX);
3190        let c = u16x4::new(u16::MIN, u16::MIN, u16::MIN, u16::MIN);
3191        let e = u16x4::new(u16::MAX, 0, 1, 2);
3192        let r: u16x4 = transmute(vbsl_u16(transmute(a), transmute(b), transmute(c)));
3193        assert_eq!(r, e);
3194    }
3195    #[simd_test(enable = "neon")]
3196    unsafe fn test_vbsl_u32() {
3197        let a = u32x2::new(u32::MAX, 2);
3198        let b = u32x2::new(u32::MAX, u32::MAX);
3199        let c = u32x2::new(u32::MIN, u32::MIN);
3200        let e = u32x2::new(u32::MAX, 2);
3201        let r: u32x2 = transmute(vbsl_u32(transmute(a), transmute(b), transmute(c)));
3202        assert_eq!(r, e);
3203    }
3204    #[simd_test(enable = "neon")]
3205    unsafe fn test_vbsl_u64() {
3206        let a = u64x1::new(2);
3207        let b = u64x1::new(u64::MAX);
3208        let c = u64x1::new(u64::MIN);
3209        let e = u64x1::new(2);
3210        let r: u64x1 = transmute(vbsl_u64(transmute(a), transmute(b), transmute(c)));
3211        assert_eq!(r, e);
3212    }
3213    #[simd_test(enable = "neon")]
3214    unsafe fn test_vbsl_f32() {
3215        let a = u32x2::new(1, 0x80000000);
3216        let b = f32x2::new(8388609f32, -1.23f32);
3217        let c = f32x2::new(2097152f32, 2.34f32);
3218        let e = f32x2::new(2097152.25f32, -2.34f32);
3219        let r: f32x2 = transmute(vbsl_f32(transmute(a), transmute(b), transmute(c)));
3220        assert_eq!(r, e);
3221    }
3222    #[simd_test(enable = "neon")]
3223    unsafe fn test_vbsl_p8() {
3224        let a = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, 0, u8::MAX, 0);
3225        let b = u8x8::new(
3226            u8::MAX,
3227            u8::MAX,
3228            u8::MAX,
3229            u8::MAX,
3230            u8::MAX,
3231            u8::MAX,
3232            u8::MAX,
3233            u8::MAX,
3234        );
3235        let c = u8x8::new(
3236            u8::MIN,
3237            u8::MIN,
3238            u8::MIN,
3239            u8::MIN,
3240            u8::MIN,
3241            u8::MIN,
3242            u8::MIN,
3243            u8::MIN,
3244        );
3245        let e = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, u8::MIN, u8::MAX, u8::MIN);
3246        let r: u8x8 = transmute(vbsl_p8(transmute(a), transmute(b), transmute(c)));
3247        assert_eq!(r, e);
3248    }
3249    #[simd_test(enable = "neon")]
3250    unsafe fn test_vbsl_p16() {
3251        let a = u16x4::new(u16::MAX, 0, 1, 2);
3252        let b = u16x4::new(u16::MAX, u16::MAX, u16::MAX, u16::MAX);
3253        let c = u16x4::new(u16::MIN, u16::MIN, u16::MIN, u16::MIN);
3254        let e = u16x4::new(u16::MAX, 0, 1, 2);
3255        let r: u16x4 = transmute(vbsl_p16(transmute(a), transmute(b), transmute(c)));
3256        assert_eq!(r, e);
3257    }
3258    #[simd_test(enable = "neon")]
3259    unsafe fn test_vbslq_s8() {
3260        let a = u8x16::new(
3261            u8::MAX,
3262            1,
3263            u8::MAX,
3264            2,
3265            u8::MAX,
3266            0,
3267            u8::MAX,
3268            0,
3269            u8::MAX,
3270            0,
3271            u8::MAX,
3272            0,
3273            u8::MAX,
3274            0,
3275            u8::MAX,
3276            0,
3277        );
3278        let b = i8x16::new(
3279            i8::MAX,
3280            i8::MAX,
3281            i8::MAX,
3282            i8::MAX,
3283            i8::MAX,
3284            i8::MAX,
3285            i8::MAX,
3286            i8::MAX,
3287            i8::MAX,
3288            i8::MAX,
3289            i8::MAX,
3290            i8::MAX,
3291            i8::MAX,
3292            i8::MAX,
3293            i8::MAX,
3294            i8::MAX,
3295        );
3296        let c = i8x16::new(
3297            i8::MIN,
3298            i8::MIN,
3299            i8::MIN,
3300            i8::MIN,
3301            i8::MIN,
3302            i8::MIN,
3303            i8::MIN,
3304            i8::MIN,
3305            i8::MIN,
3306            i8::MIN,
3307            i8::MIN,
3308            i8::MIN,
3309            i8::MIN,
3310            i8::MIN,
3311            i8::MIN,
3312            i8::MIN,
3313        );
3314        let e = i8x16::new(
3315            i8::MAX,
3316            i8::MIN | 1,
3317            i8::MAX,
3318            i8::MIN | 2,
3319            i8::MAX,
3320            i8::MIN,
3321            i8::MAX,
3322            i8::MIN,
3323            i8::MAX,
3324            i8::MIN,
3325            i8::MAX,
3326            i8::MIN,
3327            i8::MAX,
3328            i8::MIN,
3329            i8::MAX,
3330            i8::MIN,
3331        );
3332        let r: i8x16 = transmute(vbslq_s8(transmute(a), transmute(b), transmute(c)));
3333        assert_eq!(r, e);
3334    }
3335    #[simd_test(enable = "neon")]
3336    unsafe fn test_vbslq_s16() {
3337        let a = u16x8::new(u16::MAX, 1, u16::MAX, 2, u16::MAX, 0, u16::MAX, 0);
3338        let b = i16x8::new(
3339            i16::MAX,
3340            i16::MAX,
3341            i16::MAX,
3342            i16::MAX,
3343            i16::MAX,
3344            i16::MAX,
3345            i16::MAX,
3346            i16::MAX,
3347        );
3348        let c = i16x8::new(
3349            i16::MIN,
3350            i16::MIN,
3351            i16::MIN,
3352            i16::MIN,
3353            i16::MIN,
3354            i16::MIN,
3355            i16::MIN,
3356            i16::MIN,
3357        );
3358        let e = i16x8::new(
3359            i16::MAX,
3360            i16::MIN | 1,
3361            i16::MAX,
3362            i16::MIN | 2,
3363            i16::MAX,
3364            i16::MIN,
3365            i16::MAX,
3366            i16::MIN,
3367        );
3368        let r: i16x8 = transmute(vbslq_s16(transmute(a), transmute(b), transmute(c)));
3369        assert_eq!(r, e);
3370    }
3371    #[simd_test(enable = "neon")]
3372    unsafe fn test_vbslq_s32() {
3373        let a = u32x4::new(u32::MAX, 1, u32::MAX, 2);
3374        let b = i32x4::new(i32::MAX, i32::MAX, i32::MAX, i32::MAX);
3375        let c = i32x4::new(i32::MIN, i32::MIN, i32::MIN, i32::MIN);
3376        let e = i32x4::new(i32::MAX, i32::MIN | 1, i32::MAX, i32::MIN | 2);
3377        let r: i32x4 = transmute(vbslq_s32(transmute(a), transmute(b), transmute(c)));
3378        assert_eq!(r, e);
3379    }
3380    #[simd_test(enable = "neon")]
3381    unsafe fn test_vbslq_s64() {
3382        let a = u64x2::new(u64::MAX, 1);
3383        let b = i64x2::new(i64::MAX, i64::MAX);
3384        let c = i64x2::new(i64::MIN, i64::MIN);
3385        let e = i64x2::new(i64::MAX, i64::MIN | 1);
3386        let r: i64x2 = transmute(vbslq_s64(transmute(a), transmute(b), transmute(c)));
3387        assert_eq!(r, e);
3388    }
3389    #[simd_test(enable = "neon")]
3390    unsafe fn test_vbslq_u8() {
3391        let a = u8x16::new(
3392            u8::MAX,
3393            1,
3394            u8::MAX,
3395            2,
3396            u8::MAX,
3397            0,
3398            u8::MAX,
3399            0,
3400            u8::MAX,
3401            0,
3402            u8::MAX,
3403            0,
3404            u8::MAX,
3405            0,
3406            u8::MAX,
3407            0,
3408        );
3409        let b = u8x16::new(
3410            u8::MAX,
3411            u8::MAX,
3412            u8::MAX,
3413            u8::MAX,
3414            u8::MAX,
3415            u8::MAX,
3416            u8::MAX,
3417            u8::MAX,
3418            u8::MAX,
3419            u8::MAX,
3420            u8::MAX,
3421            u8::MAX,
3422            u8::MAX,
3423            u8::MAX,
3424            u8::MAX,
3425            u8::MAX,
3426        );
3427        let c = u8x16::new(
3428            u8::MIN,
3429            u8::MIN,
3430            u8::MIN,
3431            u8::MIN,
3432            u8::MIN,
3433            u8::MIN,
3434            u8::MIN,
3435            u8::MIN,
3436            u8::MIN,
3437            u8::MIN,
3438            u8::MIN,
3439            u8::MIN,
3440            u8::MIN,
3441            u8::MIN,
3442            u8::MIN,
3443            u8::MIN,
3444        );
3445        let e = u8x16::new(
3446            u8::MAX,
3447            1,
3448            u8::MAX,
3449            2,
3450            u8::MAX,
3451            u8::MIN,
3452            u8::MAX,
3453            u8::MIN,
3454            u8::MAX,
3455            u8::MIN,
3456            u8::MAX,
3457            u8::MIN,
3458            u8::MAX,
3459            u8::MIN,
3460            u8::MAX,
3461            u8::MIN,
3462        );
3463        let r: u8x16 = transmute(vbslq_u8(transmute(a), transmute(b), transmute(c)));
3464        assert_eq!(r, e);
3465    }
3466    #[simd_test(enable = "neon")]
3467    unsafe fn test_vbslq_u16() {
3468        let a = u16x8::new(u16::MAX, 1, u16::MAX, 2, u16::MAX, 0, u16::MAX, 0);
3469        let b = u16x8::new(
3470            u16::MAX,
3471            u16::MAX,
3472            u16::MAX,
3473            u16::MAX,
3474            u16::MAX,
3475            u16::MAX,
3476            u16::MAX,
3477            u16::MAX,
3478        );
3479        let c = u16x8::new(
3480            u16::MIN,
3481            u16::MIN,
3482            u16::MIN,
3483            u16::MIN,
3484            u16::MIN,
3485            u16::MIN,
3486            u16::MIN,
3487            u16::MIN,
3488        );
3489        let e = u16x8::new(
3490            u16::MAX,
3491            1,
3492            u16::MAX,
3493            2,
3494            u16::MAX,
3495            u16::MIN,
3496            u16::MAX,
3497            u16::MIN,
3498        );
3499        let r: u16x8 = transmute(vbslq_u16(transmute(a), transmute(b), transmute(c)));
3500        assert_eq!(r, e);
3501    }
3502    #[simd_test(enable = "neon")]
3503    unsafe fn test_vbslq_u32() {
3504        let a = u32x4::new(u32::MAX, 1, u32::MAX, 2);
3505        let b = u32x4::new(u32::MAX, u32::MAX, u32::MAX, u32::MAX);
3506        let c = u32x4::new(u32::MIN, u32::MIN, u32::MIN, u32::MIN);
3507        let e = u32x4::new(u32::MAX, 1, u32::MAX, 2);
3508        let r: u32x4 = transmute(vbslq_u32(transmute(a), transmute(b), transmute(c)));
3509        assert_eq!(r, e);
3510    }
3511    #[simd_test(enable = "neon")]
3512    unsafe fn test_vbslq_u64() {
3513        let a = u64x2::new(u64::MAX, 1);
3514        let b = u64x2::new(u64::MAX, u64::MAX);
3515        let c = u64x2::new(u64::MIN, u64::MIN);
3516        let e = u64x2::new(u64::MAX, 1);
3517        let r: u64x2 = transmute(vbslq_u64(transmute(a), transmute(b), transmute(c)));
3518        assert_eq!(r, e);
3519    }
3520    #[simd_test(enable = "neon")]
3521    unsafe fn test_vbslq_f32() {
3522        let a = u32x4::new(u32::MAX, 0, 1, 0x80000000);
3523        let b = f32x4::new(-1.23f32, -1.23f32, 8388609f32, -1.23f32);
3524        let c = f32x4::new(2.34f32, 2.34f32, 2097152f32, 2.34f32);
3525        let e = f32x4::new(-1.23f32, 2.34f32, 2097152.25f32, -2.34f32);
3526        let r: f32x4 = transmute(vbslq_f32(transmute(a), transmute(b), transmute(c)));
3527        assert_eq!(r, e);
3528    }
3529    #[simd_test(enable = "neon")]
3530    unsafe fn test_vbslq_p8() {
3531        let a = u8x16::new(
3532            u8::MAX,
3533            1,
3534            u8::MAX,
3535            2,
3536            u8::MAX,
3537            0,
3538            u8::MAX,
3539            0,
3540            u8::MAX,
3541            0,
3542            u8::MAX,
3543            0,
3544            u8::MAX,
3545            0,
3546            u8::MAX,
3547            0,
3548        );
3549        let b = u8x16::new(
3550            u8::MAX,
3551            u8::MAX,
3552            u8::MAX,
3553            u8::MAX,
3554            u8::MAX,
3555            u8::MAX,
3556            u8::MAX,
3557            u8::MAX,
3558            u8::MAX,
3559            u8::MAX,
3560            u8::MAX,
3561            u8::MAX,
3562            u8::MAX,
3563            u8::MAX,
3564            u8::MAX,
3565            u8::MAX,
3566        );
3567        let c = u8x16::new(
3568            u8::MIN,
3569            u8::MIN,
3570            u8::MIN,
3571            u8::MIN,
3572            u8::MIN,
3573            u8::MIN,
3574            u8::MIN,
3575            u8::MIN,
3576            u8::MIN,
3577            u8::MIN,
3578            u8::MIN,
3579            u8::MIN,
3580            u8::MIN,
3581            u8::MIN,
3582            u8::MIN,
3583            u8::MIN,
3584        );
3585        let e = u8x16::new(
3586            u8::MAX,
3587            1,
3588            u8::MAX,
3589            2,
3590            u8::MAX,
3591            u8::MIN,
3592            u8::MAX,
3593            u8::MIN,
3594            u8::MAX,
3595            u8::MIN,
3596            u8::MAX,
3597            u8::MIN,
3598            u8::MAX,
3599            u8::MIN,
3600            u8::MAX,
3601            u8::MIN,
3602        );
3603        let r: u8x16 = transmute(vbslq_p8(transmute(a), transmute(b), transmute(c)));
3604        assert_eq!(r, e);
3605    }
3606    #[simd_test(enable = "neon")]
3607    unsafe fn test_vbslq_p16() {
3608        let a = u16x8::new(u16::MAX, 1, u16::MAX, 2, u16::MAX, 0, u16::MAX, 0);
3609        let b = u16x8::new(
3610            u16::MAX,
3611            u16::MAX,
3612            u16::MAX,
3613            u16::MAX,
3614            u16::MAX,
3615            u16::MAX,
3616            u16::MAX,
3617            u16::MAX,
3618        );
3619        let c = u16x8::new(
3620            u16::MIN,
3621            u16::MIN,
3622            u16::MIN,
3623            u16::MIN,
3624            u16::MIN,
3625            u16::MIN,
3626            u16::MIN,
3627            u16::MIN,
3628        );
3629        let e = u16x8::new(
3630            u16::MAX,
3631            1,
3632            u16::MAX,
3633            2,
3634            u16::MAX,
3635            u16::MIN,
3636            u16::MAX,
3637            u16::MIN,
3638        );
3639        let r: u16x8 = transmute(vbslq_p16(transmute(a), transmute(b), transmute(c)));
3640        assert_eq!(r, e);
3641    }
3642
3643    #[simd_test(enable = "neon")]
3644    unsafe fn test_vorn_s8() {
3645        let a = i8x8::new(0, -1, -2, -3, -4, -5, -6, -7);
3646        let b = i8x8::new(-2, -2, -2, -2, -2, -2, -2, -2);
3647        let e = i8x8::new(1, -1, -1, -3, -3, -5, -5, -7);
3648        let r: i8x8 = transmute(vorn_s8(transmute(a), transmute(b)));
3649        assert_eq!(r, e);
3650    }
3651
3652    #[simd_test(enable = "neon")]
3653    unsafe fn test_vornq_s8() {
3654        let a = i8x16::new(
3655            0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15,
3656        );
3657        let b = i8x16::new(
3658            -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
3659        );
3660        let e = i8x16::new(
3661            1, -1, -1, -3, -3, -5, -5, -7, -7, -9, -9, -11, -11, -13, -13, -15,
3662        );
3663        let r: i8x16 = transmute(vornq_s8(transmute(a), transmute(b)));
3664        assert_eq!(r, e);
3665    }
3666
3667    #[simd_test(enable = "neon")]
3668    unsafe fn test_vorn_s16() {
3669        let a = i16x4::new(0, -1, -2, -3);
3670        let b = i16x4::new(-2, -2, -2, -2);
3671        let e = i16x4::new(1, -1, -1, -3);
3672        let r: i16x4 = transmute(vorn_s16(transmute(a), transmute(b)));
3673        assert_eq!(r, e);
3674    }
3675
3676    #[simd_test(enable = "neon")]
3677    unsafe fn test_vornq_s16() {
3678        let a = i16x8::new(0, -1, -2, -3, -4, -5, -6, -7);
3679        let b = i16x8::new(-2, -2, -2, -2, -2, -2, -2, -2);
3680        let e = i16x8::new(1, -1, -1, -3, -3, -5, -5, -7);
3681        let r: i16x8 = transmute(vornq_s16(transmute(a), transmute(b)));
3682        assert_eq!(r, e);
3683    }
3684
3685    #[simd_test(enable = "neon")]
3686    unsafe fn test_vorn_s32() {
3687        let a = i32x2::new(0, -1);
3688        let b = i32x2::new(-2, -2);
3689        let e = i32x2::new(1, -1);
3690        let r: i32x2 = transmute(vorn_s32(transmute(a), transmute(b)));
3691        assert_eq!(r, e);
3692    }
3693
3694    #[simd_test(enable = "neon")]
3695    unsafe fn test_vornq_s32() {
3696        let a = i32x4::new(0, -1, -2, -3);
3697        let b = i32x4::new(-2, -2, -2, -2);
3698        let e = i32x4::new(1, -1, -1, -3);
3699        let r: i32x4 = transmute(vornq_s32(transmute(a), transmute(b)));
3700        assert_eq!(r, e);
3701    }
3702
3703    #[simd_test(enable = "neon")]
3704    unsafe fn test_vorn_s64() {
3705        let a = i64x1::new(0);
3706        let b = i64x1::new(-2);
3707        let e = i64x1::new(1);
3708        let r: i64x1 = transmute(vorn_s64(transmute(a), transmute(b)));
3709        assert_eq!(r, e);
3710    }
3711
3712    #[simd_test(enable = "neon")]
3713    unsafe fn test_vornq_s64() {
3714        let a = i64x2::new(0, -1);
3715        let b = i64x2::new(-2, -2);
3716        let e = i64x2::new(1, -1);
3717        let r: i64x2 = transmute(vornq_s64(transmute(a), transmute(b)));
3718        assert_eq!(r, e);
3719    }
3720
3721    #[simd_test(enable = "neon")]
3722    unsafe fn test_vorn_u8() {
3723        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
3724        let t = u8::MAX - 1;
3725        let b = u8x8::new(t, t, t, t, t, t, t, t);
3726        let e = u8x8::new(1, 1, 3, 3, 5, 5, 7, 7);
3727        let r: u8x8 = transmute(vorn_u8(transmute(a), transmute(b)));
3728        assert_eq!(r, e);
3729    }
3730
3731    #[simd_test(enable = "neon")]
3732    unsafe fn test_vornq_u8() {
3733        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
3734        let t = u8::MAX - 1;
3735        let b = u8x16::new(t, t, t, t, t, t, t, t, t, t, t, t, t, t, t, t);
3736        let e = u8x16::new(1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15);
3737        let r: u8x16 = transmute(vornq_u8(transmute(a), transmute(b)));
3738        assert_eq!(r, e);
3739    }
3740
3741    #[simd_test(enable = "neon")]
3742    unsafe fn test_vorn_u16() {
3743        let a = u16x4::new(0, 1, 2, 3);
3744        let t = u16::MAX - 1;
3745        let b = u16x4::new(t, t, t, t);
3746        let e = u16x4::new(1, 1, 3, 3);
3747        let r: u16x4 = transmute(vorn_u16(transmute(a), transmute(b)));
3748        assert_eq!(r, e);
3749    }
3750
3751    #[simd_test(enable = "neon")]
3752    unsafe fn test_vornq_u16() {
3753        let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
3754        let t = u16::MAX - 1;
3755        let b = u16x8::new(t, t, t, t, t, t, t, t);
3756        let e = u16x8::new(1, 1, 3, 3, 5, 5, 7, 7);
3757        let r: u16x8 = transmute(vornq_u16(transmute(a), transmute(b)));
3758        assert_eq!(r, e);
3759    }
3760
3761    #[simd_test(enable = "neon")]
3762    unsafe fn test_vorn_u32() {
3763        let a = u32x2::new(0, 1);
3764        let t = u32::MAX - 1;
3765        let b = u32x2::new(t, t);
3766        let e = u32x2::new(1, 1);
3767        let r: u32x2 = transmute(vorn_u32(transmute(a), transmute(b)));
3768        assert_eq!(r, e);
3769    }
3770
3771    #[simd_test(enable = "neon")]
3772    unsafe fn test_vornq_u32() {
3773        let a = u32x4::new(0, 1, 2, 3);
3774        let t = u32::MAX - 1;
3775        let b = u32x4::new(t, t, t, t);
3776        let e = u32x4::new(1, 1, 3, 3);
3777        let r: u32x4 = transmute(vornq_u32(transmute(a), transmute(b)));
3778        assert_eq!(r, e);
3779    }
3780
3781    #[simd_test(enable = "neon")]
3782    unsafe fn test_vorn_u64() {
3783        let a = u64x1::new(0);
3784        let t = u64::MAX - 1;
3785        let b = u64x1::new(t);
3786        let e = u64x1::new(1);
3787        let r: u64x1 = transmute(vorn_u64(transmute(a), transmute(b)));
3788        assert_eq!(r, e);
3789    }
3790
3791    #[simd_test(enable = "neon")]
3792    unsafe fn test_vornq_u64() {
3793        let a = u64x2::new(0, 1);
3794        let t = u64::MAX - 1;
3795        let b = u64x2::new(t, t);
3796        let e = u64x2::new(1, 1);
3797        let r: u64x2 = transmute(vornq_u64(transmute(a), transmute(b)));
3798        assert_eq!(r, e);
3799    }
3800
3801    #[simd_test(enable = "neon")]
3802    unsafe fn test_vmovn_s16() {
3803        let a = i16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
3804        let e = i8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
3805        let r: i8x8 = transmute(vmovn_s16(transmute(a)));
3806        assert_eq!(r, e);
3807    }
3808
3809    #[simd_test(enable = "neon")]
3810    unsafe fn test_vmovn_s32() {
3811        let a = i32x4::new(1, 2, 3, 4);
3812        let e = i16x4::new(1, 2, 3, 4);
3813        let r: i16x4 = transmute(vmovn_s32(transmute(a)));
3814        assert_eq!(r, e);
3815    }
3816
3817    #[simd_test(enable = "neon")]
3818    unsafe fn test_vmovn_s64() {
3819        let a = i64x2::new(1, 2);
3820        let e = i32x2::new(1, 2);
3821        let r: i32x2 = transmute(vmovn_s64(transmute(a)));
3822        assert_eq!(r, e);
3823    }
3824
3825    #[simd_test(enable = "neon")]
3826    unsafe fn test_vmovn_u16() {
3827        let a = u16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
3828        let e = u8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
3829        let r: u8x8 = transmute(vmovn_u16(transmute(a)));
3830        assert_eq!(r, e);
3831    }
3832
3833    #[simd_test(enable = "neon")]
3834    unsafe fn test_vmovn_u32() {
3835        let a = u32x4::new(1, 2, 3, 4);
3836        let e = u16x4::new(1, 2, 3, 4);
3837        let r: u16x4 = transmute(vmovn_u32(transmute(a)));
3838        assert_eq!(r, e);
3839    }
3840
3841    #[simd_test(enable = "neon")]
3842    unsafe fn test_vmovn_u64() {
3843        let a = u64x2::new(1, 2);
3844        let e = u32x2::new(1, 2);
3845        let r: u32x2 = transmute(vmovn_u64(transmute(a)));
3846        assert_eq!(r, e);
3847    }
3848
3849    #[simd_test(enable = "neon")]
3850    unsafe fn test_vmovl_s8() {
3851        let e = i16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
3852        let a = i8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
3853        let r: i16x8 = transmute(vmovl_s8(transmute(a)));
3854        assert_eq!(r, e);
3855    }
3856
3857    #[simd_test(enable = "neon")]
3858    unsafe fn test_vmovl_s16() {
3859        let e = i32x4::new(1, 2, 3, 4);
3860        let a = i16x4::new(1, 2, 3, 4);
3861        let r: i32x4 = transmute(vmovl_s16(transmute(a)));
3862        assert_eq!(r, e);
3863    }
3864
3865    #[simd_test(enable = "neon")]
3866    unsafe fn test_vmovl_s32() {
3867        let e = i64x2::new(1, 2);
3868        let a = i32x2::new(1, 2);
3869        let r: i64x2 = transmute(vmovl_s32(transmute(a)));
3870        assert_eq!(r, e);
3871    }
3872
3873    #[simd_test(enable = "neon")]
3874    unsafe fn test_vmovl_u8() {
3875        let e = u16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
3876        let a = u8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
3877        let r: u16x8 = transmute(vmovl_u8(transmute(a)));
3878        assert_eq!(r, e);
3879    }
3880
3881    #[simd_test(enable = "neon")]
3882    unsafe fn test_vmovl_u16() {
3883        let e = u32x4::new(1, 2, 3, 4);
3884        let a = u16x4::new(1, 2, 3, 4);
3885        let r: u32x4 = transmute(vmovl_u16(transmute(a)));
3886        assert_eq!(r, e);
3887    }
3888
3889    #[simd_test(enable = "neon")]
3890    unsafe fn test_vmovl_u32() {
3891        let e = u64x2::new(1, 2);
3892        let a = u32x2::new(1, 2);
3893        let r: u64x2 = transmute(vmovl_u32(transmute(a)));
3894        assert_eq!(r, e);
3895    }
3896
3897    #[simd_test(enable = "neon")]
3898    unsafe fn test_vand_s8() {
3899        test_bit_s8(|i, j| vand_s8(i, j), |a: i8, b: i8| -> i8 { a & b });
3900    }
3901    #[simd_test(enable = "neon")]
3902    unsafe fn test_vandq_s8() {
3903        testq_bit_s8(|i, j| vandq_s8(i, j), |a: i8, b: i8| -> i8 { a & b });
3904    }
3905    #[simd_test(enable = "neon")]
3906    unsafe fn test_vand_s16() {
3907        test_bit_s16(|i, j| vand_s16(i, j), |a: i16, b: i16| -> i16 { a & b });
3908    }
3909    #[simd_test(enable = "neon")]
3910    unsafe fn test_vandq_s16() {
3911        testq_bit_s16(|i, j| vandq_s16(i, j), |a: i16, b: i16| -> i16 { a & b });
3912    }
3913    #[simd_test(enable = "neon")]
3914    unsafe fn test_vand_s32() {
3915        test_bit_s32(|i, j| vand_s32(i, j), |a: i32, b: i32| -> i32 { a & b });
3916    }
3917    #[simd_test(enable = "neon")]
3918    unsafe fn test_vandq_s32() {
3919        testq_bit_s32(|i, j| vandq_s32(i, j), |a: i32, b: i32| -> i32 { a & b });
3920    }
3921    #[simd_test(enable = "neon")]
3922    unsafe fn test_vand_s64() {
3923        test_bit_s64(|i, j| vand_s64(i, j), |a: i64, b: i64| -> i64 { a & b });
3924    }
3925    #[simd_test(enable = "neon")]
3926    unsafe fn test_vandq_s64() {
3927        testq_bit_s64(|i, j| vandq_s64(i, j), |a: i64, b: i64| -> i64 { a & b });
3928    }
3929
3930    #[simd_test(enable = "neon")]
3931    unsafe fn test_vand_u8() {
3932        test_bit_u8(|i, j| vand_u8(i, j), |a: u8, b: u8| -> u8 { a & b });
3933    }
3934    #[simd_test(enable = "neon")]
3935    unsafe fn test_vandq_u8() {
3936        testq_bit_u8(|i, j| vandq_u8(i, j), |a: u8, b: u8| -> u8 { a & b });
3937    }
3938    #[simd_test(enable = "neon")]
3939    unsafe fn test_vand_u16() {
3940        test_bit_u16(|i, j| vand_u16(i, j), |a: u16, b: u16| -> u16 { a & b });
3941    }
3942    #[simd_test(enable = "neon")]
3943    unsafe fn test_vandq_u16() {
3944        testq_bit_u16(|i, j| vandq_u16(i, j), |a: u16, b: u16| -> u16 { a & b });
3945    }
3946    #[simd_test(enable = "neon")]
3947    unsafe fn test_vand_u32() {
3948        test_bit_u32(|i, j| vand_u32(i, j), |a: u32, b: u32| -> u32 { a & b });
3949    }
3950    #[simd_test(enable = "neon")]
3951    unsafe fn test_vandq_u32() {
3952        testq_bit_u32(|i, j| vandq_u32(i, j), |a: u32, b: u32| -> u32 { a & b });
3953    }
3954    #[simd_test(enable = "neon")]
3955    unsafe fn test_vand_u64() {
3956        test_bit_u64(|i, j| vand_u64(i, j), |a: u64, b: u64| -> u64 { a & b });
3957    }
3958    #[simd_test(enable = "neon")]
3959    unsafe fn test_vandq_u64() {
3960        testq_bit_u64(|i, j| vandq_u64(i, j), |a: u64, b: u64| -> u64 { a & b });
3961    }
3962
3963    #[simd_test(enable = "neon")]
3964    unsafe fn test_vorr_s8() {
3965        test_bit_s8(|i, j| vorr_s8(i, j), |a: i8, b: i8| -> i8 { a | b });
3966    }
3967    #[simd_test(enable = "neon")]
3968    unsafe fn test_vorrq_s8() {
3969        testq_bit_s8(|i, j| vorrq_s8(i, j), |a: i8, b: i8| -> i8 { a | b });
3970    }
3971    #[simd_test(enable = "neon")]
3972    unsafe fn test_vorr_s16() {
3973        test_bit_s16(|i, j| vorr_s16(i, j), |a: i16, b: i16| -> i16 { a | b });
3974    }
3975    #[simd_test(enable = "neon")]
3976    unsafe fn test_vorrq_s16() {
3977        testq_bit_s16(|i, j| vorrq_s16(i, j), |a: i16, b: i16| -> i16 { a | b });
3978    }
3979    #[simd_test(enable = "neon")]
3980    unsafe fn test_vorr_s32() {
3981        test_bit_s32(|i, j| vorr_s32(i, j), |a: i32, b: i32| -> i32 { a | b });
3982    }
3983    #[simd_test(enable = "neon")]
3984    unsafe fn test_vorrq_s32() {
3985        testq_bit_s32(|i, j| vorrq_s32(i, j), |a: i32, b: i32| -> i32 { a | b });
3986    }
3987    #[simd_test(enable = "neon")]
3988    unsafe fn test_vorr_s64() {
3989        test_bit_s64(|i, j| vorr_s64(i, j), |a: i64, b: i64| -> i64 { a | b });
3990    }
3991    #[simd_test(enable = "neon")]
3992    unsafe fn test_vorrq_s64() {
3993        testq_bit_s64(|i, j| vorrq_s64(i, j), |a: i64, b: i64| -> i64 { a | b });
3994    }
3995
3996    #[simd_test(enable = "neon")]
3997    unsafe fn test_vorr_u8() {
3998        test_bit_u8(|i, j| vorr_u8(i, j), |a: u8, b: u8| -> u8 { a | b });
3999    }
4000    #[simd_test(enable = "neon")]
4001    unsafe fn test_vorrq_u8() {
4002        testq_bit_u8(|i, j| vorrq_u8(i, j), |a: u8, b: u8| -> u8 { a | b });
4003    }
4004    #[simd_test(enable = "neon")]
4005    unsafe fn test_vorr_u16() {
4006        test_bit_u16(|i, j| vorr_u16(i, j), |a: u16, b: u16| -> u16 { a | b });
4007    }
4008    #[simd_test(enable = "neon")]
4009    unsafe fn test_vorrq_u16() {
4010        testq_bit_u16(|i, j| vorrq_u16(i, j), |a: u16, b: u16| -> u16 { a | b });
4011    }
4012    #[simd_test(enable = "neon")]
4013    unsafe fn test_vorr_u32() {
4014        test_bit_u32(|i, j| vorr_u32(i, j), |a: u32, b: u32| -> u32 { a | b });
4015    }
4016    #[simd_test(enable = "neon")]
4017    unsafe fn test_vorrq_u32() {
4018        testq_bit_u32(|i, j| vorrq_u32(i, j), |a: u32, b: u32| -> u32 { a | b });
4019    }
4020    #[simd_test(enable = "neon")]
4021    unsafe fn test_vorr_u64() {
4022        test_bit_u64(|i, j| vorr_u64(i, j), |a: u64, b: u64| -> u64 { a | b });
4023    }
4024    #[simd_test(enable = "neon")]
4025    unsafe fn test_vorrq_u64() {
4026        testq_bit_u64(|i, j| vorrq_u64(i, j), |a: u64, b: u64| -> u64 { a | b });
4027    }
4028
4029    #[simd_test(enable = "neon")]
4030    unsafe fn test_veor_s8() {
4031        test_bit_s8(|i, j| veor_s8(i, j), |a: i8, b: i8| -> i8 { a ^ b });
4032    }
4033    #[simd_test(enable = "neon")]
4034    unsafe fn test_veorq_s8() {
4035        testq_bit_s8(|i, j| veorq_s8(i, j), |a: i8, b: i8| -> i8 { a ^ b });
4036    }
4037    #[simd_test(enable = "neon")]
4038    unsafe fn test_veor_s16() {
4039        test_bit_s16(|i, j| veor_s16(i, j), |a: i16, b: i16| -> i16 { a ^ b });
4040    }
4041    #[simd_test(enable = "neon")]
4042    unsafe fn test_veorq_s16() {
4043        testq_bit_s16(|i, j| veorq_s16(i, j), |a: i16, b: i16| -> i16 { a ^ b });
4044    }
4045    #[simd_test(enable = "neon")]
4046    unsafe fn test_veor_s32() {
4047        test_bit_s32(|i, j| veor_s32(i, j), |a: i32, b: i32| -> i32 { a ^ b });
4048    }
4049    #[simd_test(enable = "neon")]
4050    unsafe fn test_veorq_s32() {
4051        testq_bit_s32(|i, j| veorq_s32(i, j), |a: i32, b: i32| -> i32 { a ^ b });
4052    }
4053    #[simd_test(enable = "neon")]
4054    unsafe fn test_veor_s64() {
4055        test_bit_s64(|i, j| veor_s64(i, j), |a: i64, b: i64| -> i64 { a ^ b });
4056    }
4057    #[simd_test(enable = "neon")]
4058    unsafe fn test_veorq_s64() {
4059        testq_bit_s64(|i, j| veorq_s64(i, j), |a: i64, b: i64| -> i64 { a ^ b });
4060    }
4061
4062    #[simd_test(enable = "neon")]
4063    unsafe fn test_veor_u8() {
4064        test_bit_u8(|i, j| veor_u8(i, j), |a: u8, b: u8| -> u8 { a ^ b });
4065    }
4066    #[simd_test(enable = "neon")]
4067    unsafe fn test_veorq_u8() {
4068        testq_bit_u8(|i, j| veorq_u8(i, j), |a: u8, b: u8| -> u8 { a ^ b });
4069    }
4070    #[simd_test(enable = "neon")]
4071    unsafe fn test_veor_u16() {
4072        test_bit_u16(|i, j| veor_u16(i, j), |a: u16, b: u16| -> u16 { a ^ b });
4073    }
4074    #[simd_test(enable = "neon")]
4075    unsafe fn test_veorq_u16() {
4076        testq_bit_u16(|i, j| veorq_u16(i, j), |a: u16, b: u16| -> u16 { a ^ b });
4077    }
4078    #[simd_test(enable = "neon")]
4079    unsafe fn test_veor_u32() {
4080        test_bit_u32(|i, j| veor_u32(i, j), |a: u32, b: u32| -> u32 { a ^ b });
4081    }
4082    #[simd_test(enable = "neon")]
4083    unsafe fn test_veorq_u32() {
4084        testq_bit_u32(|i, j| veorq_u32(i, j), |a: u32, b: u32| -> u32 { a ^ b });
4085    }
4086    #[simd_test(enable = "neon")]
4087    unsafe fn test_veor_u64() {
4088        test_bit_u64(|i, j| veor_u64(i, j), |a: u64, b: u64| -> u64 { a ^ b });
4089    }
4090    #[simd_test(enable = "neon")]
4091    unsafe fn test_veorq_u64() {
4092        testq_bit_u64(|i, j| veorq_u64(i, j), |a: u64, b: u64| -> u64 { a ^ b });
4093    }
4094
4095    #[simd_test(enable = "neon")]
4096    unsafe fn test_vceq_s8() {
4097        test_cmp_s8(
4098            |i, j| vceq_s8(i, j),
4099            |a: i8, b: i8| -> u8 { if a == b { 0xFF } else { 0 } },
4100        );
4101    }
4102    #[simd_test(enable = "neon")]
4103    unsafe fn test_vceqq_s8() {
4104        testq_cmp_s8(
4105            |i, j| vceqq_s8(i, j),
4106            |a: i8, b: i8| -> u8 { if a == b { 0xFF } else { 0 } },
4107        );
4108    }
4109    #[simd_test(enable = "neon")]
4110    unsafe fn test_vceq_s16() {
4111        test_cmp_s16(
4112            |i, j| vceq_s16(i, j),
4113            |a: i16, b: i16| -> u16 { if a == b { 0xFFFF } else { 0 } },
4114        );
4115    }
4116    #[simd_test(enable = "neon")]
4117    unsafe fn test_vceqq_s16() {
4118        testq_cmp_s16(
4119            |i, j| vceqq_s16(i, j),
4120            |a: i16, b: i16| -> u16 { if a == b { 0xFFFF } else { 0 } },
4121        );
4122    }
4123    #[simd_test(enable = "neon")]
4124    unsafe fn test_vceq_s32() {
4125        test_cmp_s32(
4126            |i, j| vceq_s32(i, j),
4127            |a: i32, b: i32| -> u32 { if a == b { 0xFFFFFFFF } else { 0 } },
4128        );
4129    }
4130    #[simd_test(enable = "neon")]
4131    unsafe fn test_vceqq_s32() {
4132        testq_cmp_s32(
4133            |i, j| vceqq_s32(i, j),
4134            |a: i32, b: i32| -> u32 { if a == b { 0xFFFFFFFF } else { 0 } },
4135        );
4136    }
4137
4138    #[simd_test(enable = "neon")]
4139    unsafe fn test_vceq_u8() {
4140        test_cmp_u8(
4141            |i, j| vceq_u8(i, j),
4142            |a: u8, b: u8| -> u8 { if a == b { 0xFF } else { 0 } },
4143        );
4144    }
4145    #[simd_test(enable = "neon")]
4146    unsafe fn test_vceqq_u8() {
4147        testq_cmp_u8(
4148            |i, j| vceqq_u8(i, j),
4149            |a: u8, b: u8| -> u8 { if a == b { 0xFF } else { 0 } },
4150        );
4151    }
4152    #[simd_test(enable = "neon")]
4153    unsafe fn test_vceq_u16() {
4154        test_cmp_u16(
4155            |i, j| vceq_u16(i, j),
4156            |a: u16, b: u16| -> u16 { if a == b { 0xFFFF } else { 0 } },
4157        );
4158    }
4159    #[simd_test(enable = "neon")]
4160    unsafe fn test_vceqq_u16() {
4161        testq_cmp_u16(
4162            |i, j| vceqq_u16(i, j),
4163            |a: u16, b: u16| -> u16 { if a == b { 0xFFFF } else { 0 } },
4164        );
4165    }
4166    #[simd_test(enable = "neon")]
4167    unsafe fn test_vceq_u32() {
4168        test_cmp_u32(
4169            |i, j| vceq_u32(i, j),
4170            |a: u32, b: u32| -> u32 { if a == b { 0xFFFFFFFF } else { 0 } },
4171        );
4172    }
4173    #[simd_test(enable = "neon")]
4174    unsafe fn test_vceqq_u32() {
4175        testq_cmp_u32(
4176            |i, j| vceqq_u32(i, j),
4177            |a: u32, b: u32| -> u32 { if a == b { 0xFFFFFFFF } else { 0 } },
4178        );
4179    }
4180
4181    #[simd_test(enable = "neon")]
4182    unsafe fn test_vceq_f32() {
4183        test_cmp_f32(
4184            |i, j| vcge_f32(i, j),
4185            |a: f32, b: f32| -> u32 { if a == b { 0xFFFFFFFF } else { 0 } },
4186        );
4187    }
4188    #[simd_test(enable = "neon")]
4189    unsafe fn test_vceqq_f32() {
4190        testq_cmp_f32(
4191            |i, j| vcgeq_f32(i, j),
4192            |a: f32, b: f32| -> u32 { if a == b { 0xFFFFFFFF } else { 0 } },
4193        );
4194    }
4195
4196    #[simd_test(enable = "neon")]
4197    unsafe fn test_vcgt_s8() {
4198        test_cmp_s8(
4199            |i, j| vcgt_s8(i, j),
4200            |a: i8, b: i8| -> u8 { if a > b { 0xFF } else { 0 } },
4201        );
4202    }
4203    #[simd_test(enable = "neon")]
4204    unsafe fn test_vcgtq_s8() {
4205        testq_cmp_s8(
4206            |i, j| vcgtq_s8(i, j),
4207            |a: i8, b: i8| -> u8 { if a > b { 0xFF } else { 0 } },
4208        );
4209    }
4210    #[simd_test(enable = "neon")]
4211    unsafe fn test_vcgt_s16() {
4212        test_cmp_s16(
4213            |i, j| vcgt_s16(i, j),
4214            |a: i16, b: i16| -> u16 { if a > b { 0xFFFF } else { 0 } },
4215        );
4216    }
4217    #[simd_test(enable = "neon")]
4218    unsafe fn test_vcgtq_s16() {
4219        testq_cmp_s16(
4220            |i, j| vcgtq_s16(i, j),
4221            |a: i16, b: i16| -> u16 { if a > b { 0xFFFF } else { 0 } },
4222        );
4223    }
4224    #[simd_test(enable = "neon")]
4225    unsafe fn test_vcgt_s32() {
4226        test_cmp_s32(
4227            |i, j| vcgt_s32(i, j),
4228            |a: i32, b: i32| -> u32 { if a > b { 0xFFFFFFFF } else { 0 } },
4229        );
4230    }
4231    #[simd_test(enable = "neon")]
4232    unsafe fn test_vcgtq_s32() {
4233        testq_cmp_s32(
4234            |i, j| vcgtq_s32(i, j),
4235            |a: i32, b: i32| -> u32 { if a > b { 0xFFFFFFFF } else { 0 } },
4236        );
4237    }
4238
4239    #[simd_test(enable = "neon")]
4240    unsafe fn test_vcgt_u8() {
4241        test_cmp_u8(
4242            |i, j| vcgt_u8(i, j),
4243            |a: u8, b: u8| -> u8 { if a > b { 0xFF } else { 0 } },
4244        );
4245    }
4246    #[simd_test(enable = "neon")]
4247    unsafe fn test_vcgtq_u8() {
4248        testq_cmp_u8(
4249            |i, j| vcgtq_u8(i, j),
4250            |a: u8, b: u8| -> u8 { if a > b { 0xFF } else { 0 } },
4251        );
4252    }
4253    #[simd_test(enable = "neon")]
4254    unsafe fn test_vcgt_u16() {
4255        test_cmp_u16(
4256            |i, j| vcgt_u16(i, j),
4257            |a: u16, b: u16| -> u16 { if a > b { 0xFFFF } else { 0 } },
4258        );
4259    }
4260    #[simd_test(enable = "neon")]
4261    unsafe fn test_vcgtq_u16() {
4262        testq_cmp_u16(
4263            |i, j| vcgtq_u16(i, j),
4264            |a: u16, b: u16| -> u16 { if a > b { 0xFFFF } else { 0 } },
4265        );
4266    }
4267    #[simd_test(enable = "neon")]
4268    unsafe fn test_vcgt_u32() {
4269        test_cmp_u32(
4270            |i, j| vcgt_u32(i, j),
4271            |a: u32, b: u32| -> u32 { if a > b { 0xFFFFFF } else { 0 } },
4272        );
4273    }
4274    #[simd_test(enable = "neon")]
4275    unsafe fn test_vcgtq_u32() {
4276        testq_cmp_u32(
4277            |i, j| vcgtq_u32(i, j),
4278            |a: u32, b: u32| -> u32 { if a > b { 0xFFFFFFFF } else { 0 } },
4279        );
4280    }
4281
4282    #[simd_test(enable = "neon")]
4283    unsafe fn test_vcgt_f32() {
4284        test_cmp_f32(
4285            |i, j| vcgt_f32(i, j),
4286            |a: f32, b: f32| -> u32 { if a > b { 0xFFFFFFFF } else { 0 } },
4287        );
4288    }
4289    #[simd_test(enable = "neon")]
4290    unsafe fn test_vcgtq_f32() {
4291        testq_cmp_f32(
4292            |i, j| vcgtq_f32(i, j),
4293            |a: f32, b: f32| -> u32 { if a > b { 0xFFFFFFFF } else { 0 } },
4294        );
4295    }
4296
4297    #[simd_test(enable = "neon")]
4298    unsafe fn test_vclt_s8() {
4299        test_cmp_s8(
4300            |i, j| vclt_s8(i, j),
4301            |a: i8, b: i8| -> u8 { if a < b { 0xFF } else { 0 } },
4302        );
4303    }
4304    #[simd_test(enable = "neon")]
4305    unsafe fn test_vcltq_s8() {
4306        testq_cmp_s8(
4307            |i, j| vcltq_s8(i, j),
4308            |a: i8, b: i8| -> u8 { if a < b { 0xFF } else { 0 } },
4309        );
4310    }
4311    #[simd_test(enable = "neon")]
4312    unsafe fn test_vclt_s16() {
4313        test_cmp_s16(
4314            |i, j| vclt_s16(i, j),
4315            |a: i16, b: i16| -> u16 { if a < b { 0xFFFF } else { 0 } },
4316        );
4317    }
4318    #[simd_test(enable = "neon")]
4319    unsafe fn test_vcltq_s16() {
4320        testq_cmp_s16(
4321            |i, j| vcltq_s16(i, j),
4322            |a: i16, b: i16| -> u16 { if a < b { 0xFFFF } else { 0 } },
4323        );
4324    }
4325    #[simd_test(enable = "neon")]
4326    unsafe fn test_vclt_s32() {
4327        test_cmp_s32(
4328            |i, j| vclt_s32(i, j),
4329            |a: i32, b: i32| -> u32 { if a < b { 0xFFFFFFFF } else { 0 } },
4330        );
4331    }
4332    #[simd_test(enable = "neon")]
4333    unsafe fn test_vcltq_s32() {
4334        testq_cmp_s32(
4335            |i, j| vcltq_s32(i, j),
4336            |a: i32, b: i32| -> u32 { if a < b { 0xFFFFFFFF } else { 0 } },
4337        );
4338    }
4339
4340    #[simd_test(enable = "neon")]
4341    unsafe fn test_vclt_u8() {
4342        test_cmp_u8(
4343            |i, j| vclt_u8(i, j),
4344            |a: u8, b: u8| -> u8 { if a < b { 0xFF } else { 0 } },
4345        );
4346    }
4347    #[simd_test(enable = "neon")]
4348    unsafe fn test_vcltq_u8() {
4349        testq_cmp_u8(
4350            |i, j| vcltq_u8(i, j),
4351            |a: u8, b: u8| -> u8 { if a < b { 0xFF } else { 0 } },
4352        );
4353    }
4354    #[simd_test(enable = "neon")]
4355    unsafe fn test_vclt_u16() {
4356        test_cmp_u16(
4357            |i, j| vclt_u16(i, j),
4358            |a: u16, b: u16| -> u16 { if a < b { 0xFFFF } else { 0 } },
4359        );
4360    }
4361    #[simd_test(enable = "neon")]
4362    unsafe fn test_vcltq_u16() {
4363        testq_cmp_u16(
4364            |i, j| vcltq_u16(i, j),
4365            |a: u16, b: u16| -> u16 { if a < b { 0xFFFF } else { 0 } },
4366        );
4367    }
4368    #[simd_test(enable = "neon")]
4369    unsafe fn test_vclt_u32() {
4370        test_cmp_u32(
4371            |i, j| vclt_u32(i, j),
4372            |a: u32, b: u32| -> u32 { if a < b { 0xFFFFFF } else { 0 } },
4373        );
4374    }
4375    #[simd_test(enable = "neon")]
4376    unsafe fn test_vcltq_u32() {
4377        testq_cmp_u32(
4378            |i, j| vcltq_u32(i, j),
4379            |a: u32, b: u32| -> u32 { if a < b { 0xFFFFFFFF } else { 0 } },
4380        );
4381    }
4382
4383    #[simd_test(enable = "neon")]
4384    unsafe fn test_vclt_f32() {
4385        test_cmp_f32(
4386            |i, j| vclt_f32(i, j),
4387            |a: f32, b: f32| -> u32 { if a < b { 0xFFFFFFFF } else { 0 } },
4388        );
4389    }
4390    #[simd_test(enable = "neon")]
4391    unsafe fn test_vcltq_f32() {
4392        testq_cmp_f32(
4393            |i, j| vcltq_f32(i, j),
4394            |a: f32, b: f32| -> u32 { if a < b { 0xFFFFFFFF } else { 0 } },
4395        );
4396    }
4397
4398    #[simd_test(enable = "neon")]
4399    unsafe fn test_vcle_s8() {
4400        test_cmp_s8(
4401            |i, j| vcle_s8(i, j),
4402            |a: i8, b: i8| -> u8 { if a <= b { 0xFF } else { 0 } },
4403        );
4404    }
4405    #[simd_test(enable = "neon")]
4406    unsafe fn test_vcleq_s8() {
4407        testq_cmp_s8(
4408            |i, j| vcleq_s8(i, j),
4409            |a: i8, b: i8| -> u8 { if a <= b { 0xFF } else { 0 } },
4410        );
4411    }
4412    #[simd_test(enable = "neon")]
4413    unsafe fn test_vcle_s16() {
4414        test_cmp_s16(
4415            |i, j| vcle_s16(i, j),
4416            |a: i16, b: i16| -> u16 { if a <= b { 0xFFFF } else { 0 } },
4417        );
4418    }
4419    #[simd_test(enable = "neon")]
4420    unsafe fn test_vcleq_s16() {
4421        testq_cmp_s16(
4422            |i, j| vcleq_s16(i, j),
4423            |a: i16, b: i16| -> u16 { if a <= b { 0xFFFF } else { 0 } },
4424        );
4425    }
4426    #[simd_test(enable = "neon")]
4427    unsafe fn test_vcle_s32() {
4428        test_cmp_s32(
4429            |i, j| vcle_s32(i, j),
4430            |a: i32, b: i32| -> u32 { if a <= b { 0xFFFFFFFF } else { 0 } },
4431        );
4432    }
4433    #[simd_test(enable = "neon")]
4434    unsafe fn test_vcleq_s32() {
4435        testq_cmp_s32(
4436            |i, j| vcleq_s32(i, j),
4437            |a: i32, b: i32| -> u32 { if a <= b { 0xFFFFFFFF } else { 0 } },
4438        );
4439    }
4440
4441    #[simd_test(enable = "neon")]
4442    unsafe fn test_vcle_u8() {
4443        test_cmp_u8(
4444            |i, j| vcle_u8(i, j),
4445            |a: u8, b: u8| -> u8 { if a <= b { 0xFF } else { 0 } },
4446        );
4447    }
4448    #[simd_test(enable = "neon")]
4449    unsafe fn test_vcleq_u8() {
4450        testq_cmp_u8(
4451            |i, j| vcleq_u8(i, j),
4452            |a: u8, b: u8| -> u8 { if a <= b { 0xFF } else { 0 } },
4453        );
4454    }
4455    #[simd_test(enable = "neon")]
4456    unsafe fn test_vcle_u16() {
4457        test_cmp_u16(
4458            |i, j| vcle_u16(i, j),
4459            |a: u16, b: u16| -> u16 { if a <= b { 0xFFFF } else { 0 } },
4460        );
4461    }
4462    #[simd_test(enable = "neon")]
4463    unsafe fn test_vcleq_u16() {
4464        testq_cmp_u16(
4465            |i, j| vcleq_u16(i, j),
4466            |a: u16, b: u16| -> u16 { if a <= b { 0xFFFF } else { 0 } },
4467        );
4468    }
4469    #[simd_test(enable = "neon")]
4470    unsafe fn test_vcle_u32() {
4471        test_cmp_u32(
4472            |i, j| vcle_u32(i, j),
4473            |a: u32, b: u32| -> u32 { if a <= b { 0xFFFFFFFF } else { 0 } },
4474        );
4475    }
4476    #[simd_test(enable = "neon")]
4477    unsafe fn test_vcleq_u32() {
4478        testq_cmp_u32(
4479            |i, j| vcleq_u32(i, j),
4480            |a: u32, b: u32| -> u32 { if a <= b { 0xFFFFFFFF } else { 0 } },
4481        );
4482    }
4483
4484    #[simd_test(enable = "neon")]
4485    unsafe fn test_vcle_f32() {
4486        test_cmp_f32(
4487            |i, j| vcle_f32(i, j),
4488            |a: f32, b: f32| -> u32 { if a <= b { 0xFFFFFFFF } else { 0 } },
4489        );
4490    }
4491    #[simd_test(enable = "neon")]
4492    unsafe fn test_vcleq_f32() {
4493        testq_cmp_f32(
4494            |i, j| vcleq_f32(i, j),
4495            |a: f32, b: f32| -> u32 { if a <= b { 0xFFFFFFFF } else { 0 } },
4496        );
4497    }
4498
4499    #[simd_test(enable = "neon")]
4500    unsafe fn test_vcge_s8() {
4501        test_cmp_s8(
4502            |i, j| vcge_s8(i, j),
4503            |a: i8, b: i8| -> u8 { if a >= b { 0xFF } else { 0 } },
4504        );
4505    }
4506    #[simd_test(enable = "neon")]
4507    unsafe fn test_vcgeq_s8() {
4508        testq_cmp_s8(
4509            |i, j| vcgeq_s8(i, j),
4510            |a: i8, b: i8| -> u8 { if a >= b { 0xFF } else { 0 } },
4511        );
4512    }
4513    #[simd_test(enable = "neon")]
4514    unsafe fn test_vcge_s16() {
4515        test_cmp_s16(
4516            |i, j| vcge_s16(i, j),
4517            |a: i16, b: i16| -> u16 { if a >= b { 0xFFFF } else { 0 } },
4518        );
4519    }
4520    #[simd_test(enable = "neon")]
4521    unsafe fn test_vcgeq_s16() {
4522        testq_cmp_s16(
4523            |i, j| vcgeq_s16(i, j),
4524            |a: i16, b: i16| -> u16 { if a >= b { 0xFFFF } else { 0 } },
4525        );
4526    }
4527    #[simd_test(enable = "neon")]
4528    unsafe fn test_vcge_s32() {
4529        test_cmp_s32(
4530            |i, j| vcge_s32(i, j),
4531            |a: i32, b: i32| -> u32 { if a >= b { 0xFFFFFFFF } else { 0 } },
4532        );
4533    }
4534    #[simd_test(enable = "neon")]
4535    unsafe fn test_vcgeq_s32() {
4536        testq_cmp_s32(
4537            |i, j| vcgeq_s32(i, j),
4538            |a: i32, b: i32| -> u32 { if a >= b { 0xFFFFFFFF } else { 0 } },
4539        );
4540    }
4541
4542    #[simd_test(enable = "neon")]
4543    unsafe fn test_vcge_u8() {
4544        test_cmp_u8(
4545            |i, j| vcge_u8(i, j),
4546            |a: u8, b: u8| -> u8 { if a >= b { 0xFF } else { 0 } },
4547        );
4548    }
4549    #[simd_test(enable = "neon")]
4550    unsafe fn test_vcgeq_u8() {
4551        testq_cmp_u8(
4552            |i, j| vcgeq_u8(i, j),
4553            |a: u8, b: u8| -> u8 { if a >= b { 0xFF } else { 0 } },
4554        );
4555    }
4556    #[simd_test(enable = "neon")]
4557    unsafe fn test_vcge_u16() {
4558        test_cmp_u16(
4559            |i, j| vcge_u16(i, j),
4560            |a: u16, b: u16| -> u16 { if a >= b { 0xFFFF } else { 0 } },
4561        );
4562    }
4563    #[simd_test(enable = "neon")]
4564    unsafe fn test_vcgeq_u16() {
4565        testq_cmp_u16(
4566            |i, j| vcgeq_u16(i, j),
4567            |a: u16, b: u16| -> u16 { if a >= b { 0xFFFF } else { 0 } },
4568        );
4569    }
4570    #[simd_test(enable = "neon")]
4571    unsafe fn test_vcge_u32() {
4572        test_cmp_u32(
4573            |i, j| vcge_u32(i, j),
4574            |a: u32, b: u32| -> u32 { if a >= b { 0xFFFFFFFF } else { 0 } },
4575        );
4576    }
4577    #[simd_test(enable = "neon")]
4578    unsafe fn test_vcgeq_u32() {
4579        testq_cmp_u32(
4580            |i, j| vcgeq_u32(i, j),
4581            |a: u32, b: u32| -> u32 { if a >= b { 0xFFFFFFFF } else { 0 } },
4582        );
4583    }
4584
4585    #[simd_test(enable = "neon")]
4586    unsafe fn test_vcge_f32() {
4587        test_cmp_f32(
4588            |i, j| vcge_f32(i, j),
4589            |a: f32, b: f32| -> u32 { if a >= b { 0xFFFFFFFF } else { 0 } },
4590        );
4591    }
4592    #[simd_test(enable = "neon")]
4593    unsafe fn test_vcgeq_f32() {
4594        testq_cmp_f32(
4595            |i, j| vcgeq_f32(i, j),
4596            |a: f32, b: f32| -> u32 { if a >= b { 0xFFFFFFFF } else { 0 } },
4597        );
4598    }
4599
4600    #[simd_test(enable = "neon")]
4601    unsafe fn test_vqsub_s8() {
4602        test_ari_s8(
4603            |i, j| vqsub_s8(i, j),
4604            |a: i8, b: i8| -> i8 { a.saturating_sub(b) },
4605        );
4606    }
4607    #[simd_test(enable = "neon")]
4608    unsafe fn test_vqsubq_s8() {
4609        testq_ari_s8(
4610            |i, j| vqsubq_s8(i, j),
4611            |a: i8, b: i8| -> i8 { a.saturating_sub(b) },
4612        );
4613    }
4614    #[simd_test(enable = "neon")]
4615    unsafe fn test_vqsub_s16() {
4616        test_ari_s16(
4617            |i, j| vqsub_s16(i, j),
4618            |a: i16, b: i16| -> i16 { a.saturating_sub(b) },
4619        );
4620    }
4621    #[simd_test(enable = "neon")]
4622    unsafe fn test_vqsubq_s16() {
4623        testq_ari_s16(
4624            |i, j| vqsubq_s16(i, j),
4625            |a: i16, b: i16| -> i16 { a.saturating_sub(b) },
4626        );
4627    }
4628    #[simd_test(enable = "neon")]
4629    unsafe fn test_vqsub_s32() {
4630        test_ari_s32(
4631            |i, j| vqsub_s32(i, j),
4632            |a: i32, b: i32| -> i32 { a.saturating_sub(b) },
4633        );
4634    }
4635    #[simd_test(enable = "neon")]
4636    unsafe fn test_vqsubq_s32() {
4637        testq_ari_s32(
4638            |i, j| vqsubq_s32(i, j),
4639            |a: i32, b: i32| -> i32 { a.saturating_sub(b) },
4640        );
4641    }
4642
4643    #[simd_test(enable = "neon")]
4644    unsafe fn test_vqsub_u8() {
4645        test_ari_u8(
4646            |i, j| vqsub_u8(i, j),
4647            |a: u8, b: u8| -> u8 { a.saturating_sub(b) },
4648        );
4649    }
4650    #[simd_test(enable = "neon")]
4651    unsafe fn test_vqsubq_u8() {
4652        testq_ari_u8(
4653            |i, j| vqsubq_u8(i, j),
4654            |a: u8, b: u8| -> u8 { a.saturating_sub(b) },
4655        );
4656    }
4657    #[simd_test(enable = "neon")]
4658    unsafe fn test_vqsub_u16() {
4659        test_ari_u16(
4660            |i, j| vqsub_u16(i, j),
4661            |a: u16, b: u16| -> u16 { a.saturating_sub(b) },
4662        );
4663    }
4664    #[simd_test(enable = "neon")]
4665    unsafe fn test_vqsubq_u16() {
4666        testq_ari_u16(
4667            |i, j| vqsubq_u16(i, j),
4668            |a: u16, b: u16| -> u16 { a.saturating_sub(b) },
4669        );
4670    }
4671    #[simd_test(enable = "neon")]
4672    unsafe fn test_vqsub_u32() {
4673        test_ari_u32(
4674            |i, j| vqsub_u32(i, j),
4675            |a: u32, b: u32| -> u32 { a.saturating_sub(b) },
4676        );
4677    }
4678    #[simd_test(enable = "neon")]
4679    unsafe fn test_vqsubq_u32() {
4680        testq_ari_u32(
4681            |i, j| vqsubq_u32(i, j),
4682            |a: u32, b: u32| -> u32 { a.saturating_sub(b) },
4683        );
4684    }
4685
4686    #[simd_test(enable = "neon")]
4687    unsafe fn test_vhadd_s8() {
4688        test_ari_s8(|i, j| vhadd_s8(i, j), |a: i8, b: i8| -> i8 { a & b });
4689    }
4690    #[simd_test(enable = "neon")]
4691    unsafe fn test_vhaddq_s8() {
4692        testq_ari_s8(|i, j| vhaddq_s8(i, j), |a: i8, b: i8| -> i8 { a & b });
4693    }
4694    #[simd_test(enable = "neon")]
4695    unsafe fn test_vhadd_s16() {
4696        test_ari_s16(|i, j| vhadd_s16(i, j), |a: i16, b: i16| -> i16 { a & b });
4697    }
4698    #[simd_test(enable = "neon")]
4699    unsafe fn test_vhaddq_s16() {
4700        testq_ari_s16(|i, j| vhaddq_s16(i, j), |a: i16, b: i16| -> i16 { a & b });
4701    }
4702    #[simd_test(enable = "neon")]
4703    unsafe fn test_vhadd_s32() {
4704        test_ari_s32(|i, j| vhadd_s32(i, j), |a: i32, b: i32| -> i32 { a & b });
4705    }
4706    #[simd_test(enable = "neon")]
4707    unsafe fn test_vhaddq_s32() {
4708        testq_ari_s32(|i, j| vhaddq_s32(i, j), |a: i32, b: i32| -> i32 { a & b });
4709    }
4710
4711    #[simd_test(enable = "neon")]
4712    unsafe fn test_vhadd_u8() {
4713        test_ari_u8(|i, j| vhadd_u8(i, j), |a: u8, b: u8| -> u8 { a & b });
4714    }
4715    #[simd_test(enable = "neon")]
4716    unsafe fn test_vhaddq_u8() {
4717        testq_ari_u8(|i, j| vhaddq_u8(i, j), |a: u8, b: u8| -> u8 { a & b });
4718    }
4719    #[simd_test(enable = "neon")]
4720    unsafe fn test_vhadd_u16() {
4721        test_ari_u16(|i, j| vhadd_u16(i, j), |a: u16, b: u16| -> u16 { a & b });
4722    }
4723    #[simd_test(enable = "neon")]
4724    unsafe fn test_vhaddq_u16() {
4725        testq_ari_u16(|i, j| vhaddq_u16(i, j), |a: u16, b: u16| -> u16 { a & b });
4726    }
4727    #[simd_test(enable = "neon")]
4728    unsafe fn test_vhadd_u32() {
4729        test_ari_u32(|i, j| vhadd_u32(i, j), |a: u32, b: u32| -> u32 { a & b });
4730    }
4731    #[simd_test(enable = "neon")]
4732    unsafe fn test_vhaddq_u32() {
4733        testq_ari_u32(|i, j| vhaddq_u32(i, j), |a: u32, b: u32| -> u32 { a & b });
4734    }
4735
4736    #[simd_test(enable = "neon")]
4737    unsafe fn test_vrhadd_s8() {
4738        test_ari_s8(|i, j| vrhadd_s8(i, j), |a: i8, b: i8| -> i8 { a & b });
4739    }
4740    #[simd_test(enable = "neon")]
4741    unsafe fn test_vrhaddq_s8() {
4742        testq_ari_s8(|i, j| vrhaddq_s8(i, j), |a: i8, b: i8| -> i8 { a & b });
4743    }
4744    #[simd_test(enable = "neon")]
4745    unsafe fn test_vrhadd_s16() {
4746        test_ari_s16(|i, j| vrhadd_s16(i, j), |a: i16, b: i16| -> i16 { a & b });
4747    }
4748    #[simd_test(enable = "neon")]
4749    unsafe fn test_vrhaddq_s16() {
4750        testq_ari_s16(|i, j| vrhaddq_s16(i, j), |a: i16, b: i16| -> i16 { a & b });
4751    }
4752    #[simd_test(enable = "neon")]
4753    unsafe fn test_vrhadd_s32() {
4754        test_ari_s32(|i, j| vrhadd_s32(i, j), |a: i32, b: i32| -> i32 { a & b });
4755    }
4756    #[simd_test(enable = "neon")]
4757    unsafe fn test_vrhaddq_s32() {
4758        testq_ari_s32(|i, j| vrhaddq_s32(i, j), |a: i32, b: i32| -> i32 { a & b });
4759    }
4760
4761    #[simd_test(enable = "neon")]
4762    unsafe fn test_vrhadd_u8() {
4763        test_ari_u8(|i, j| vrhadd_u8(i, j), |a: u8, b: u8| -> u8 { a & b });
4764    }
4765    #[simd_test(enable = "neon")]
4766    unsafe fn test_vrhaddq_u8() {
4767        testq_ari_u8(|i, j| vrhaddq_u8(i, j), |a: u8, b: u8| -> u8 { a & b });
4768    }
4769    #[simd_test(enable = "neon")]
4770    unsafe fn test_vrhadd_u16() {
4771        test_ari_u16(|i, j| vrhadd_u16(i, j), |a: u16, b: u16| -> u16 { a & b });
4772    }
4773    #[simd_test(enable = "neon")]
4774    unsafe fn test_vrhaddq_u16() {
4775        testq_ari_u16(|i, j| vrhaddq_u16(i, j), |a: u16, b: u16| -> u16 { a & b });
4776    }
4777    #[simd_test(enable = "neon")]
4778    unsafe fn test_vrhadd_u32() {
4779        test_ari_u32(|i, j| vrhadd_u32(i, j), |a: u32, b: u32| -> u32 { a & b });
4780    }
4781    #[simd_test(enable = "neon")]
4782    unsafe fn test_vrhaddq_u32() {
4783        testq_ari_u32(|i, j| vrhaddq_u32(i, j), |a: u32, b: u32| -> u32 { a & b });
4784    }
4785
4786    #[simd_test(enable = "neon")]
4787    unsafe fn test_vqadd_s8() {
4788        test_ari_s8(
4789            |i, j| vqadd_s8(i, j),
4790            |a: i8, b: i8| -> i8 { a.saturating_add(b) },
4791        );
4792    }
4793    #[simd_test(enable = "neon")]
4794    unsafe fn test_vqaddq_s8() {
4795        testq_ari_s8(
4796            |i, j| vqaddq_s8(i, j),
4797            |a: i8, b: i8| -> i8 { a.saturating_add(b) },
4798        );
4799    }
4800    #[simd_test(enable = "neon")]
4801    unsafe fn test_vqadd_s16() {
4802        test_ari_s16(
4803            |i, j| vqadd_s16(i, j),
4804            |a: i16, b: i16| -> i16 { a.saturating_add(b) },
4805        );
4806    }
4807    #[simd_test(enable = "neon")]
4808    unsafe fn test_vqaddq_s16() {
4809        testq_ari_s16(
4810            |i, j| vqaddq_s16(i, j),
4811            |a: i16, b: i16| -> i16 { a.saturating_add(b) },
4812        );
4813    }
4814    #[simd_test(enable = "neon")]
4815    unsafe fn test_vqadd_s32() {
4816        test_ari_s32(
4817            |i, j| vqadd_s32(i, j),
4818            |a: i32, b: i32| -> i32 { a.saturating_add(b) },
4819        );
4820    }
4821    #[simd_test(enable = "neon")]
4822    unsafe fn test_vqaddq_s32() {
4823        testq_ari_s32(
4824            |i, j| vqaddq_s32(i, j),
4825            |a: i32, b: i32| -> i32 { a.saturating_add(b) },
4826        );
4827    }
4828
4829    #[simd_test(enable = "neon")]
4830    unsafe fn test_vqadd_u8() {
4831        test_ari_u8(
4832            |i, j| vqadd_u8(i, j),
4833            |a: u8, b: u8| -> u8 { a.saturating_add(b) },
4834        );
4835    }
4836    #[simd_test(enable = "neon")]
4837    unsafe fn test_vqaddq_u8() {
4838        testq_ari_u8(
4839            |i, j| vqaddq_u8(i, j),
4840            |a: u8, b: u8| -> u8 { a.saturating_add(b) },
4841        );
4842    }
4843    #[simd_test(enable = "neon")]
4844    unsafe fn test_vqadd_u16() {
4845        test_ari_u16(
4846            |i, j| vqadd_u16(i, j),
4847            |a: u16, b: u16| -> u16 { a.saturating_add(b) },
4848        );
4849    }
4850    #[simd_test(enable = "neon")]
4851    unsafe fn test_vqaddq_u16() {
4852        testq_ari_u16(
4853            |i, j| vqaddq_u16(i, j),
4854            |a: u16, b: u16| -> u16 { a.saturating_add(b) },
4855        );
4856    }
4857    #[simd_test(enable = "neon")]
4858    unsafe fn test_vqadd_u32() {
4859        test_ari_u32(
4860            |i, j| vqadd_u32(i, j),
4861            |a: u32, b: u32| -> u32 { a.saturating_add(b) },
4862        );
4863    }
4864    #[simd_test(enable = "neon")]
4865    unsafe fn test_vqaddq_u32() {
4866        testq_ari_u32(
4867            |i, j| vqaddq_u32(i, j),
4868            |a: u32, b: u32| -> u32 { a.saturating_add(b) },
4869        );
4870    }
4871
4872    #[simd_test(enable = "neon")]
4873    unsafe fn test_vmul_s8() {
4874        test_ari_s8(
4875            |i, j| vmul_s8(i, j),
4876            |a: i8, b: i8| -> i8 { a.overflowing_mul(b).0 },
4877        );
4878    }
4879    #[simd_test(enable = "neon")]
4880    unsafe fn test_vmulq_s8() {
4881        testq_ari_s8(
4882            |i, j| vmulq_s8(i, j),
4883            |a: i8, b: i8| -> i8 { a.overflowing_mul(b).0 },
4884        );
4885    }
4886    #[simd_test(enable = "neon")]
4887    unsafe fn test_vmul_s16() {
4888        test_ari_s16(
4889            |i, j| vmul_s16(i, j),
4890            |a: i16, b: i16| -> i16 { a.overflowing_mul(b).0 },
4891        );
4892    }
4893    #[simd_test(enable = "neon")]
4894    unsafe fn test_vmulq_s16() {
4895        testq_ari_s16(
4896            |i, j| vmulq_s16(i, j),
4897            |a: i16, b: i16| -> i16 { a.overflowing_mul(b).0 },
4898        );
4899    }
4900    #[simd_test(enable = "neon")]
4901    unsafe fn test_vmul_s32() {
4902        test_ari_s32(
4903            |i, j| vmul_s32(i, j),
4904            |a: i32, b: i32| -> i32 { a.overflowing_mul(b).0 },
4905        );
4906    }
4907    #[simd_test(enable = "neon")]
4908    unsafe fn test_vmulq_s32() {
4909        testq_ari_s32(
4910            |i, j| vmulq_s32(i, j),
4911            |a: i32, b: i32| -> i32 { a.overflowing_mul(b).0 },
4912        );
4913    }
4914
4915    #[simd_test(enable = "neon")]
4916    unsafe fn test_vmul_u8() {
4917        test_ari_u8(
4918            |i, j| vmul_u8(i, j),
4919            |a: u8, b: u8| -> u8 { a.overflowing_mul(b).0 },
4920        );
4921    }
4922    #[simd_test(enable = "neon")]
4923    unsafe fn test_vmulq_u8() {
4924        testq_ari_u8(
4925            |i, j| vmulq_u8(i, j),
4926            |a: u8, b: u8| -> u8 { a.overflowing_mul(b).0 },
4927        );
4928    }
4929    #[simd_test(enable = "neon")]
4930    unsafe fn test_vmul_u16() {
4931        test_ari_u16(
4932            |i, j| vmul_u16(i, j),
4933            |a: u16, b: u16| -> u16 { a.overflowing_mul(b).0 },
4934        );
4935    }
4936    #[simd_test(enable = "neon")]
4937    unsafe fn test_vmulq_u16() {
4938        testq_ari_u16(
4939            |i, j| vmulq_u16(i, j),
4940            |a: u16, b: u16| -> u16 { a.overflowing_mul(b).0 },
4941        );
4942    }
4943    #[simd_test(enable = "neon")]
4944    unsafe fn test_vmul_u32() {
4945        test_ari_u32(
4946            |i, j| vmul_u32(i, j),
4947            |a: u32, b: u32| -> u32 { a.overflowing_mul(b).0 },
4948        );
4949    }
4950    #[simd_test(enable = "neon")]
4951    unsafe fn test_vmulq_u32() {
4952        testq_ari_u32(
4953            |i, j| vmulq_u32(i, j),
4954            |a: u32, b: u32| -> u32 { a.overflowing_mul(b).0 },
4955        );
4956    }
4957
4958    #[simd_test(enable = "neon")]
4959    unsafe fn test_vmul_f32() {
4960        test_ari_f32(|i, j| vmul_f32(i, j), |a: f32, b: f32| -> f32 { a * b });
4961    }
4962    #[simd_test(enable = "neon")]
4963    unsafe fn test_vmulq_f32() {
4964        testq_ari_f32(|i, j| vmulq_f32(i, j), |a: f32, b: f32| -> f32 { a * b });
4965    }
4966
4967    #[simd_test(enable = "neon")]
4968    unsafe fn test_vsub_s8() {
4969        test_ari_s8(|i, j| vsub_s8(i, j), |a: i8, b: i8| -> i8 { a - b });
4970    }
4971    #[simd_test(enable = "neon")]
4972    unsafe fn test_vsubq_s8() {
4973        testq_ari_s8(|i, j| vsubq_s8(i, j), |a: i8, b: i8| -> i8 { a - b });
4974    }
4975    #[simd_test(enable = "neon")]
4976    unsafe fn test_vsub_s16() {
4977        test_ari_s16(|i, j| vsub_s16(i, j), |a: i16, b: i16| -> i16 { a - b });
4978    }
4979    #[simd_test(enable = "neon")]
4980    unsafe fn test_vsubq_s16() {
4981        testq_ari_s16(|i, j| vsubq_s16(i, j), |a: i16, b: i16| -> i16 { a - b });
4982    }
4983    #[simd_test(enable = "neon")]
4984    unsafe fn test_vsub_s32() {
4985        test_ari_s32(|i, j| vsub_s32(i, j), |a: i32, b: i32| -> i32 { a - b });
4986    }
4987    #[simd_test(enable = "neon")]
4988    unsafe fn test_vsubq_s32() {
4989        testq_ari_s32(|i, j| vsubq_s32(i, j), |a: i32, b: i32| -> i32 { a - b });
4990    }
4991
4992    #[simd_test(enable = "neon")]
4993    unsafe fn test_vsub_u8() {
4994        test_ari_u8(|i, j| vsub_u8(i, j), |a: u8, b: u8| -> u8 { a - b });
4995    }
4996    #[simd_test(enable = "neon")]
4997    unsafe fn test_vsubq_u8() {
4998        testq_ari_u8(|i, j| vsubq_u8(i, j), |a: u8, b: u8| -> u8 { a - b });
4999    }
5000    #[simd_test(enable = "neon")]
5001    unsafe fn test_vsub_u16() {
5002        test_ari_u16(|i, j| vsub_u16(i, j), |a: u16, b: u16| -> u16 { a - b });
5003    }
5004    #[simd_test(enable = "neon")]
5005    unsafe fn test_vsubq_u16() {
5006        testq_ari_u16(|i, j| vsubq_u16(i, j), |a: u16, b: u16| -> u16 { a - b });
5007    }
5008    #[simd_test(enable = "neon")]
5009    unsafe fn test_vsub_u32() {
5010        test_ari_u32(|i, j| vsub_u32(i, j), |a: u32, b: u32| -> u32 { a - b });
5011    }
5012    #[simd_test(enable = "neon")]
5013    unsafe fn test_vsubq_u32() {
5014        testq_ari_u32(|i, j| vsubq_u32(i, j), |a: u32, b: u32| -> u32 { a - b });
5015    }
5016
5017    #[simd_test(enable = "neon")]
5018    unsafe fn test_vsub_f32() {
5019        test_ari_f32(|i, j| vsub_f32(i, j), |a: f32, b: f32| -> f32 { a - b });
5020    }
5021    #[simd_test(enable = "neon")]
5022    unsafe fn test_vsubq_f32() {
5023        testq_ari_f32(|i, j| vsubq_f32(i, j), |a: f32, b: f32| -> f32 { a - b });
5024    }
5025
5026    #[simd_test(enable = "neon")]
5027    unsafe fn test_vhsub_s8() {
5028        test_ari_s8(
5029            |i, j| vhsub_s8(i, j),
5030            |a: i8, b: i8| -> i8 { (((a as i16) - (b as i16)) / 2) as i8 },
5031        );
5032    }
5033    #[simd_test(enable = "neon")]
5034    unsafe fn test_vhsubq_s8() {
5035        testq_ari_s8(
5036            |i, j| vhsubq_s8(i, j),
5037            |a: i8, b: i8| -> i8 { (((a as i16) - (b as i16)) / 2) as i8 },
5038        );
5039    }
5040    #[simd_test(enable = "neon")]
5041    unsafe fn test_vhsub_s16() {
5042        test_ari_s16(
5043            |i, j| vhsub_s16(i, j),
5044            |a: i16, b: i16| -> i16 { (((a as i32) - (b as i32)) / 2) as i16 },
5045        );
5046    }
5047    #[simd_test(enable = "neon")]
5048    unsafe fn test_vhsubq_s16() {
5049        testq_ari_s16(
5050            |i, j| vhsubq_s16(i, j),
5051            |a: i16, b: i16| -> i16 { (((a as i32) - (b as i32)) / 2) as i16 },
5052        );
5053    }
5054    #[simd_test(enable = "neon")]
5055    unsafe fn test_vhsub_s32() {
5056        test_ari_s32(
5057            |i, j| vhsub_s32(i, j),
5058            |a: i32, b: i32| -> i32 { (((a as i64) - (b as i64)) / 2) as i32 },
5059        );
5060    }
5061    #[simd_test(enable = "neon")]
5062    unsafe fn test_vhsubq_s32() {
5063        testq_ari_s32(
5064            |i, j| vhsubq_s32(i, j),
5065            |a: i32, b: i32| -> i32 { (((a as i64) - (b as i64)) / 2) as i32 },
5066        );
5067    }
5068
5069    #[simd_test(enable = "neon")]
5070    unsafe fn test_vhsub_u8() {
5071        test_ari_u8(
5072            |i, j| vhsub_u8(i, j),
5073            |a: u8, b: u8| -> u8 { (((a as u16) - (b as u16)) / 2) as u8 },
5074        );
5075    }
5076    #[simd_test(enable = "neon")]
5077    unsafe fn test_vhsubq_u8() {
5078        testq_ari_u8(
5079            |i, j| vhsubq_u8(i, j),
5080            |a: u8, b: u8| -> u8 { (((a as u16) - (b as u16)) / 2) as u8 },
5081        );
5082    }
5083    #[simd_test(enable = "neon")]
5084    unsafe fn test_vhsub_u16() {
5085        test_ari_u16(
5086            |i, j| vhsub_u16(i, j),
5087            |a: u16, b: u16| -> u16 { (((a as u16) - (b as u16)) / 2) as u16 },
5088        );
5089    }
5090    #[simd_test(enable = "neon")]
5091    unsafe fn test_vhsubq_u16() {
5092        testq_ari_u16(
5093            |i, j| vhsubq_u16(i, j),
5094            |a: u16, b: u16| -> u16 { (((a as u16) - (b as u16)) / 2) as u16 },
5095        );
5096    }
5097    #[simd_test(enable = "neon")]
5098    unsafe fn test_vhsub_u32() {
5099        test_ari_u32(
5100            |i, j| vhsub_u32(i, j),
5101            |a: u32, b: u32| -> u32 { (((a as u64) - (b as u64)) / 2) as u32 },
5102        );
5103    }
5104    #[simd_test(enable = "neon")]
5105    unsafe fn test_vhsubq_u32() {
5106        testq_ari_u32(
5107            |i, j| vhsubq_u32(i, j),
5108            |a: u32, b: u32| -> u32 { (((a as u64) - (b as u64)) / 2) as u32 },
5109        );
5110    }
5111
5112    #[simd_test(enable = "neon")]
5113    unsafe fn test_vaba_s8() {
5114        let a = i8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
5115        let b = i8x8::new(1, 1, 1, 1, 1, 1, 1, 1);
5116        let c = i8x8::new(10, 9, 8, 7, 6, 5, 4, 3);
5117        let r: i8x8 = transmute(vaba_s8(transmute(a), transmute(b), transmute(c)));
5118        let e = i8x8::new(10, 10, 10, 10, 10, 10, 10, 10);
5119        assert_eq!(r, e);
5120    }
5121    #[simd_test(enable = "neon")]
5122    unsafe fn test_vaba_s16() {
5123        let a = i16x4::new(1, 2, 3, 4);
5124        let b = i16x4::new(1, 1, 1, 1);
5125        let c = i16x4::new(10, 9, 8, 7);
5126        let r: i16x4 = transmute(vaba_s16(transmute(a), transmute(b), transmute(c)));
5127        let e = i16x4::new(10, 10, 10, 10);
5128        assert_eq!(r, e);
5129    }
5130    #[simd_test(enable = "neon")]
5131    unsafe fn test_vaba_s32() {
5132        let a = i32x2::new(1, 2);
5133        let b = i32x2::new(1, 1);
5134        let c = i32x2::new(10, 9);
5135        let r: i32x2 = transmute(vaba_s32(transmute(a), transmute(b), transmute(c)));
5136        let e = i32x2::new(10, 10);
5137        assert_eq!(r, e);
5138    }
5139    #[simd_test(enable = "neon")]
5140    unsafe fn test_vaba_u8() {
5141        let a = u8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
5142        let b = u8x8::new(1, 1, 1, 1, 1, 1, 1, 1);
5143        let c = u8x8::new(10, 9, 8, 7, 6, 5, 4, 3);
5144        let r: u8x8 = transmute(vaba_u8(transmute(a), transmute(b), transmute(c)));
5145        let e = u8x8::new(10, 10, 10, 10, 10, 10, 10, 10);
5146        assert_eq!(r, e);
5147    }
5148    #[simd_test(enable = "neon")]
5149    unsafe fn test_vaba_u16() {
5150        let a = u16x4::new(1, 2, 3, 4);
5151        let b = u16x4::new(1, 1, 1, 1);
5152        let c = u16x4::new(10, 9, 8, 7);
5153        let r: u16x4 = transmute(vaba_u16(transmute(a), transmute(b), transmute(c)));
5154        let e = u16x4::new(10, 10, 10, 10);
5155        assert_eq!(r, e);
5156    }
5157    #[simd_test(enable = "neon")]
5158    unsafe fn test_vaba_u32() {
5159        let a = u32x2::new(1, 2);
5160        let b = u32x2::new(1, 1);
5161        let c = u32x2::new(10, 9);
5162        let r: u32x2 = transmute(vaba_u32(transmute(a), transmute(b), transmute(c)));
5163        let e = u32x2::new(10, 10);
5164        assert_eq!(r, e);
5165    }
5166    #[simd_test(enable = "neon")]
5167    unsafe fn test_vabaq_s8() {
5168        let a = i8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2);
5169        let b = i8x16::new(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
5170        let c = i8x16::new(10, 9, 8, 7, 6, 5, 4, 3, 12, 13, 14, 15, 16, 17, 18, 19);
5171        let r: i8x16 = transmute(vabaq_s8(transmute(a), transmute(b), transmute(c)));
5172        let e = i8x16::new(
5173            10, 10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 20, 20, 20,
5174        );
5175        assert_eq!(r, e);
5176    }
5177    #[simd_test(enable = "neon")]
5178    unsafe fn test_vabaq_s16() {
5179        let a = i16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
5180        let b = i16x8::new(1, 1, 1, 1, 1, 1, 1, 1);
5181        let c = i16x8::new(10, 9, 8, 7, 6, 5, 4, 3);
5182        let r: i16x8 = transmute(vabaq_s16(transmute(a), transmute(b), transmute(c)));
5183        let e = i16x8::new(10, 10, 10, 10, 10, 10, 10, 10);
5184        assert_eq!(r, e);
5185    }
5186    #[simd_test(enable = "neon")]
5187    unsafe fn test_vabaq_s32() {
5188        let a = i32x4::new(1, 2, 3, 4);
5189        let b = i32x4::new(1, 1, 1, 1);
5190        let c = i32x4::new(10, 9, 8, 7);
5191        let r: i32x4 = transmute(vabaq_s32(transmute(a), transmute(b), transmute(c)));
5192        let e = i32x4::new(10, 10, 10, 10);
5193        assert_eq!(r, e);
5194    }
5195    #[simd_test(enable = "neon")]
5196    unsafe fn test_vabaq_u8() {
5197        let a = u8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2);
5198        let b = u8x16::new(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
5199        let c = u8x16::new(10, 9, 8, 7, 6, 5, 4, 3, 12, 13, 14, 15, 16, 17, 18, 19);
5200        let r: u8x16 = transmute(vabaq_u8(transmute(a), transmute(b), transmute(c)));
5201        let e = u8x16::new(
5202            10, 10, 10, 10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 20, 20, 20,
5203        );
5204        assert_eq!(r, e);
5205    }
5206    #[simd_test(enable = "neon")]
5207    unsafe fn test_vabaq_u16() {
5208        let a = u16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
5209        let b = u16x8::new(1, 1, 1, 1, 1, 1, 1, 1);
5210        let c = u16x8::new(10, 9, 8, 7, 6, 5, 4, 3);
5211        let r: u16x8 = transmute(vabaq_u16(transmute(a), transmute(b), transmute(c)));
5212        let e = u16x8::new(10, 10, 10, 10, 10, 10, 10, 10);
5213        assert_eq!(r, e);
5214    }
5215    #[simd_test(enable = "neon")]
5216    unsafe fn test_vabaq_u32() {
5217        let a = u32x4::new(1, 2, 3, 4);
5218        let b = u32x4::new(1, 1, 1, 1);
5219        let c = u32x4::new(10, 9, 8, 7);
5220        let r: u32x4 = transmute(vabaq_u32(transmute(a), transmute(b), transmute(c)));
5221        let e = u32x4::new(10, 10, 10, 10);
5222        assert_eq!(r, e);
5223    }
5224
5225    #[simd_test(enable = "neon")]
5226    unsafe fn test_vrev16_s8() {
5227        let a = i8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5228        let r = i8x8::new(1, 0, 3, 2, 5, 4, 7, 6);
5229        let e: i8x8 = transmute(vrev16_s8(transmute(a)));
5230        assert_eq!(r, e);
5231    }
5232    #[simd_test(enable = "neon")]
5233    unsafe fn test_vrev16q_s8() {
5234        let a = i8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
5235        let r = i8x16::new(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
5236        let e: i8x16 = transmute(vrev16q_s8(transmute(a)));
5237        assert_eq!(r, e);
5238    }
5239    #[simd_test(enable = "neon")]
5240    unsafe fn test_vrev16_u8() {
5241        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5242        let r = u8x8::new(1, 0, 3, 2, 5, 4, 7, 6);
5243        let e: u8x8 = transmute(vrev16_u8(transmute(a)));
5244        assert_eq!(r, e);
5245    }
5246    #[simd_test(enable = "neon")]
5247    unsafe fn test_vrev16q_u8() {
5248        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
5249        let r = u8x16::new(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
5250        let e: u8x16 = transmute(vrev16q_u8(transmute(a)));
5251        assert_eq!(r, e);
5252    }
5253    #[simd_test(enable = "neon")]
5254    unsafe fn test_vrev16_p8() {
5255        let a = i8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5256        let r = i8x8::new(1, 0, 3, 2, 5, 4, 7, 6);
5257        let e: i8x8 = transmute(vrev16_p8(transmute(a)));
5258        assert_eq!(r, e);
5259    }
5260    #[simd_test(enable = "neon")]
5261    unsafe fn test_vrev16q_p8() {
5262        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
5263        let r = u8x16::new(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
5264        let e: u8x16 = transmute(vrev16q_p8(transmute(a)));
5265        assert_eq!(r, e);
5266    }
5267    #[simd_test(enable = "neon")]
5268    unsafe fn test_vrev32_s8() {
5269        let a = i8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5270        let r = i8x8::new(3, 2, 1, 0, 7, 6, 5, 4);
5271        let e: i8x8 = transmute(vrev32_s8(transmute(a)));
5272        assert_eq!(r, e);
5273    }
5274    #[simd_test(enable = "neon")]
5275    unsafe fn test_vrev32q_s8() {
5276        let a = i8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
5277        let r = i8x16::new(3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
5278        let e: i8x16 = transmute(vrev32q_s8(transmute(a)));
5279        assert_eq!(r, e);
5280    }
5281    #[simd_test(enable = "neon")]
5282    unsafe fn test_vrev32_u8() {
5283        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5284        let r = u8x8::new(3, 2, 1, 0, 7, 6, 5, 4);
5285        let e: u8x8 = transmute(vrev32_u8(transmute(a)));
5286        assert_eq!(r, e);
5287    }
5288    #[simd_test(enable = "neon")]
5289    unsafe fn test_vrev32q_u8() {
5290        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
5291        let r = u8x16::new(3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
5292        let e: u8x16 = transmute(vrev32q_u8(transmute(a)));
5293        assert_eq!(r, e);
5294    }
5295    #[simd_test(enable = "neon")]
5296    unsafe fn test_vrev32_s16() {
5297        let a = i16x4::new(0, 1, 2, 3);
5298        let r = i16x4::new(1, 0, 3, 2);
5299        let e: i16x4 = transmute(vrev32_s16(transmute(a)));
5300        assert_eq!(r, e);
5301    }
5302    #[simd_test(enable = "neon")]
5303    unsafe fn test_vrev32q_s16() {
5304        let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5305        let r = i16x8::new(1, 0, 3, 2, 5, 4, 7, 6);
5306        let e: i16x8 = transmute(vrev32q_s16(transmute(a)));
5307        assert_eq!(r, e);
5308    }
5309    #[simd_test(enable = "neon")]
5310    unsafe fn test_vrev32_p16() {
5311        let a = i16x4::new(0, 1, 2, 3);
5312        let r = i16x4::new(1, 0, 3, 2);
5313        let e: i16x4 = transmute(vrev32_p16(transmute(a)));
5314        assert_eq!(r, e);
5315    }
5316    #[simd_test(enable = "neon")]
5317    unsafe fn test_vrev32q_p16() {
5318        let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5319        let r = i16x8::new(1, 0, 3, 2, 5, 4, 7, 6);
5320        let e: i16x8 = transmute(vrev32q_p16(transmute(a)));
5321        assert_eq!(r, e);
5322    }
5323    #[simd_test(enable = "neon")]
5324    unsafe fn test_vrev32_u16() {
5325        let a = u16x4::new(0, 1, 2, 3);
5326        let r = u16x4::new(1, 0, 3, 2);
5327        let e: u16x4 = transmute(vrev32_u16(transmute(a)));
5328        assert_eq!(r, e);
5329    }
5330    #[simd_test(enable = "neon")]
5331    unsafe fn test_vrev32q_u16() {
5332        let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5333        let r = u16x8::new(1, 0, 3, 2, 5, 4, 7, 6);
5334        let e: u16x8 = transmute(vrev32q_u16(transmute(a)));
5335        assert_eq!(r, e);
5336    }
5337    #[simd_test(enable = "neon")]
5338    unsafe fn test_vrev32_p8() {
5339        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5340        let r = u8x8::new(3, 2, 1, 0, 7, 6, 5, 4);
5341        let e: u8x8 = transmute(vrev32_p8(transmute(a)));
5342        assert_eq!(r, e);
5343    }
5344    #[simd_test(enable = "neon")]
5345    unsafe fn test_vrev32q_p8() {
5346        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
5347        let r = u8x16::new(3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
5348        let e: u8x16 = transmute(vrev32q_p8(transmute(a)));
5349        assert_eq!(r, e);
5350    }
5351    #[simd_test(enable = "neon")]
5352    unsafe fn test_vrev64_s8() {
5353        let a = i8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5354        let r = i8x8::new(7, 6, 5, 4, 3, 2, 1, 0);
5355        let e: i8x8 = transmute(vrev64_s8(transmute(a)));
5356        assert_eq!(r, e);
5357    }
5358    #[simd_test(enable = "neon")]
5359    unsafe fn test_vrev64q_s8() {
5360        let a = i8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
5361        let r = i8x16::new(7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
5362        let e: i8x16 = transmute(vrev64q_s8(transmute(a)));
5363        assert_eq!(r, e);
5364    }
5365    #[simd_test(enable = "neon")]
5366    unsafe fn test_vrev64_s16() {
5367        let a = i16x4::new(0, 1, 2, 3);
5368        let r = i16x4::new(3, 2, 1, 0);
5369        let e: i16x4 = transmute(vrev64_s16(transmute(a)));
5370        assert_eq!(r, e);
5371    }
5372    #[simd_test(enable = "neon")]
5373    unsafe fn test_vrev64q_s16() {
5374        let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5375        let r = i16x8::new(3, 2, 1, 0, 7, 6, 5, 4);
5376        let e: i16x8 = transmute(vrev64q_s16(transmute(a)));
5377        assert_eq!(r, e);
5378    }
5379    #[simd_test(enable = "neon")]
5380    unsafe fn test_vrev64_s32() {
5381        let a = i32x2::new(0, 1);
5382        let r = i32x2::new(1, 0);
5383        let e: i32x2 = transmute(vrev64_s32(transmute(a)));
5384        assert_eq!(r, e);
5385    }
5386    #[simd_test(enable = "neon")]
5387    unsafe fn test_vrev64q_s32() {
5388        let a = i32x4::new(0, 1, 2, 3);
5389        let r = i32x4::new(1, 0, 3, 2);
5390        let e: i32x4 = transmute(vrev64q_s32(transmute(a)));
5391        assert_eq!(r, e);
5392    }
5393    #[simd_test(enable = "neon")]
5394    unsafe fn test_vrev64_u8() {
5395        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5396        let r = u8x8::new(7, 6, 5, 4, 3, 2, 1, 0);
5397        let e: u8x8 = transmute(vrev64_u8(transmute(a)));
5398        assert_eq!(r, e);
5399    }
5400    #[simd_test(enable = "neon")]
5401    unsafe fn test_vrev64q_u8() {
5402        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
5403        let r = u8x16::new(7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
5404        let e: u8x16 = transmute(vrev64q_u8(transmute(a)));
5405        assert_eq!(r, e);
5406    }
5407    #[simd_test(enable = "neon")]
5408    unsafe fn test_vrev64_u16() {
5409        let a = u16x4::new(0, 1, 2, 3);
5410        let r = u16x4::new(3, 2, 1, 0);
5411        let e: u16x4 = transmute(vrev64_u16(transmute(a)));
5412        assert_eq!(r, e);
5413    }
5414    #[simd_test(enable = "neon")]
5415    unsafe fn test_vrev64q_u16() {
5416        let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5417        let r = u16x8::new(3, 2, 1, 0, 7, 6, 5, 4);
5418        let e: u16x8 = transmute(vrev64q_u16(transmute(a)));
5419        assert_eq!(r, e);
5420    }
5421    #[simd_test(enable = "neon")]
5422    unsafe fn test_vrev64_u32() {
5423        let a = u32x2::new(0, 1);
5424        let r = u32x2::new(1, 0);
5425        let e: u32x2 = transmute(vrev64_u32(transmute(a)));
5426        assert_eq!(r, e);
5427    }
5428    #[simd_test(enable = "neon")]
5429    unsafe fn test_vrev64q_u32() {
5430        let a = u32x4::new(0, 1, 2, 3);
5431        let r = u32x4::new(1, 0, 3, 2);
5432        let e: u32x4 = transmute(vrev64q_u32(transmute(a)));
5433        assert_eq!(r, e);
5434    }
5435    #[simd_test(enable = "neon")]
5436    unsafe fn test_vrev64_f32() {
5437        let a = f32x2::new(1.0, 2.0);
5438        let r = f32x2::new(2.0, 1.0);
5439        let e: f32x2 = transmute(vrev64_f32(transmute(a)));
5440        assert_eq!(r, e);
5441    }
5442    #[simd_test(enable = "neon")]
5443    unsafe fn test_vrev64q_f32() {
5444        let a = f32x4::new(1.0, 2.0, -2.0, -1.0);
5445        let r = f32x4::new(2.0, 1.0, -1.0, -2.0);
5446        let e: f32x4 = transmute(vrev64q_f32(transmute(a)));
5447        assert_eq!(r, e);
5448    }
5449    #[simd_test(enable = "neon")]
5450    unsafe fn test_vrev64_p8() {
5451        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5452        let r = u8x8::new(7, 6, 5, 4, 3, 2, 1, 0);
5453        let e: u8x8 = transmute(vrev64_p8(transmute(a)));
5454        assert_eq!(r, e);
5455    }
5456    #[simd_test(enable = "neon")]
5457    unsafe fn test_vrev64q_p8() {
5458        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
5459        let r = u8x16::new(7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
5460        let e: u8x16 = transmute(vrev64q_p8(transmute(a)));
5461        assert_eq!(r, e);
5462    }
5463    #[simd_test(enable = "neon")]
5464    unsafe fn test_vrev64_p16() {
5465        let a = u16x4::new(0, 1, 2, 3);
5466        let r = u16x4::new(3, 2, 1, 0);
5467        let e: u16x4 = transmute(vrev64_p16(transmute(a)));
5468        assert_eq!(r, e);
5469    }
5470    #[simd_test(enable = "neon")]
5471    unsafe fn test_vrev64q_p16() {
5472        let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
5473        let r = u16x8::new(3, 2, 1, 0, 7, 6, 5, 4);
5474        let e: u16x8 = transmute(vrev64q_p16(transmute(a)));
5475        assert_eq!(r, e);
5476    }
5477
5478    macro_rules! test_vcombine {
5479        ($test_id:ident => $fn_id:ident ([$($a:expr),*], [$($b:expr),*])) => {
5480            #[allow(unused_assignments)]
5481            #[simd_test(enable = "neon")]
5482            unsafe fn $test_id() {
5483                let a = [$($a),*];
5484                let b = [$($b),*];
5485                let e = [$($a),* $(, $b)*];
5486                let c = $fn_id(transmute(a), transmute(b));
5487                let mut d = e;
5488                d = transmute(c);
5489                assert_eq!(d, e);
5490            }
5491        }
5492    }
5493
5494    test_vcombine!(test_vcombine_s8 => vcombine_s8([3_i8, -4, 5, -6, 7, 8, 9, 10], [13_i8, -14, 15, -16, 17, 18, 19, 110]));
5495    test_vcombine!(test_vcombine_u8 => vcombine_u8([3_u8, 4, 5, 6, 7, 8, 9, 10], [13_u8, 14, 15, 16, 17, 18, 19, 110]));
5496    test_vcombine!(test_vcombine_p8 => vcombine_p8([3_u8, 4, 5, 6, 7, 8, 9, 10], [13_u8, 14, 15, 16, 17, 18, 19, 110]));
5497
5498    test_vcombine!(test_vcombine_s16 => vcombine_s16([3_i16, -4, 5, -6], [13_i16, -14, 15, -16]));
5499    test_vcombine!(test_vcombine_u16 => vcombine_u16([3_u16, 4, 5, 6], [13_u16, 14, 15, 16]));
5500    test_vcombine!(test_vcombine_p16 => vcombine_p16([3_u16, 4, 5, 6], [13_u16, 14, 15, 16]));
5501    test_vcombine!(test_vcombine_f16 => vcombine_f16([3_f16, 4., 5., 6.],
5502    [13_f16, 14., 15., 16.]));
5503
5504    test_vcombine!(test_vcombine_s32 => vcombine_s32([3_i32, -4], [13_i32, -14]));
5505    test_vcombine!(test_vcombine_u32 => vcombine_u32([3_u32, 4], [13_u32, 14]));
5506    // note: poly32x4 does not exist, and neither does vcombine_p32
5507    test_vcombine!(test_vcombine_f32 => vcombine_f32([3_f32, -4.], [13_f32, -14.]));
5508
5509    test_vcombine!(test_vcombine_s64 => vcombine_s64([-3_i64], [13_i64]));
5510    test_vcombine!(test_vcombine_u64 => vcombine_u64([3_u64], [13_u64]));
5511    test_vcombine!(test_vcombine_p64 => vcombine_p64([3_u64], [13_u64]));
5512    #[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
5513    test_vcombine!(test_vcombine_f64 => vcombine_f64([-3_f64], [13_f64]));
5514}
5515
5516#[cfg(all(test, target_arch = "arm"))]
5517mod table_lookup_tests;
5518
5519#[cfg(all(test, target_arch = "arm"))]
5520mod shift_and_insert_tests;
5521
5522#[cfg(all(test, target_arch = "arm"))]
5523mod load_tests;
5524
5525#[cfg(all(test, target_arch = "arm"))]
5526mod store_tests;