1#[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 pub struct int8x8_t(8 x pub(crate) i8);
57 pub struct uint8x8_t(8 x pub(crate) u8);
59 pub struct poly8x8_t(8 x pub(crate) p8);
61 pub struct int16x4_t(4 x pub(crate) i16);
63 pub struct uint16x4_t(4 x pub(crate) u16);
65 pub struct float16x4_t(4 x pub(crate) f16);
67 pub struct poly16x4_t(4 x pub(crate) p16);
69 pub struct int32x2_t(2 x pub(crate) i32);
71 pub struct uint32x2_t(2 x pub(crate) u32);
73 pub struct float32x2_t(2 x pub(crate) f32);
75 pub struct int64x1_t(1 x pub(crate) i64);
77 pub struct uint64x1_t(1 x pub(crate) u64);
79 pub struct poly64x1_t(1 x pub(crate) p64);
81
82 pub struct int8x16_t(16 x pub(crate) i8);
84 pub struct uint8x16_t(16 x pub(crate) u8);
86 pub struct poly8x16_t(16 x pub(crate) p8);
88 pub struct int16x8_t(8 x pub(crate) i16);
90 pub struct uint16x8_t(8 x pub(crate) u16);
92 pub struct float16x8_t(8 x pub(crate) f16);
94 pub struct poly16x8_t(8 x pub(crate) p16);
96 pub struct int32x4_t(4 x pub(crate) i32);
98 pub struct uint32x4_t(4 x pub(crate) u32);
100 pub struct float32x4_t(4 x pub(crate) f32);
102 pub struct int64x2_t(2 x pub(crate) i64);
104 pub struct uint64x2_t(2 x pub(crate) u64);
106 pub struct poly64x2_t(2 x pub(crate) p64);
108}
109
110#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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#[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 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;