Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/simd/mf8_data_1.c

raw
1 /* { dg-do assemble } */
2 /* { dg-additional-options "-O -std=gnu23 --save-temps" } */
3 /* { dg-final { check-function-bodies "**" "" "" } } */
4
5 #include <arm_neon.h>
6
7 /*
8 ** test_bsl1:
9 ** bsl v0.8b, v1.8b, v2.8b
10 ** ret
11 */
12 mfloat8x8_t test_bsl1(uint8x8_t a, mfloat8x8_t b, mfloat8x8_t c)
13 {
14 return vbsl_mf8(a, b, c);
15 }
16
17 /*
18 ** test_bsl2:
19 ** bif v0.8b, v2.8b, v1.8b
20 ** ret
21 */
22 mfloat8x8_t test_bsl2(mfloat8x8_t a, uint8x8_t b, mfloat8x8_t c)
23 {
24 return vbsl_mf8(b, a, c);
25 }
26
27 /*
28 ** test_bsl3:
29 ** bit v0.8b, v2.8b, v1.8b
30 ** ret
31 */
32 mfloat8x8_t test_bsl3(mfloat8x8_t a, uint8x8_t b, mfloat8x8_t c)
33 {
34 return vbsl_mf8(b, c, a);
35 }
36
37 /*
38 ** test_bslq1:
39 ** bsl v0.16b, v1.16b, v2.16b
40 ** ret
41 */
42 mfloat8x16_t test_bslq1(uint8x16_t a, mfloat8x16_t b, mfloat8x16_t c)
43 {
44 return vbslq_mf8(a, b, c);
45 }
46
47 /*
48 ** test_bslq2:
49 ** bif v0.16b, v2.16b, v1.16b
50 ** ret
51 */
52 mfloat8x16_t test_bslq2(mfloat8x16_t a, uint8x16_t b, mfloat8x16_t c)
53 {
54 return vbslq_mf8(b, a, c);
55 }
56
57 /*
58 ** test_bslq3:
59 ** bit v0.16b, v2.16b, v1.16b
60 ** ret
61 */
62 mfloat8x16_t test_bslq3(mfloat8x16_t a, uint8x16_t b, mfloat8x16_t c)
63 {
64 return vbslq_mf8(b, c, a);
65 }
66
67 /*
68 ** test_combine1:
69 ** uzp1 v0.2d, v1.2d, v2.2d
70 ** ret
71 */
72 mfloat8x16_t test_combine1(mfloat8_t a, mfloat8x8_t b, mfloat8x8_t c)
73 {
74 return vcombine_mf8(b, c);
75 }
76
77 /*
78 ** test_copy_lane1:
79 ** ins v0.b\[0\], v1.b\[0\]
80 ** ret
81 */
82 mfloat8x8_t test_copy_lane1(mfloat8x8_t a, mfloat8x8_t b)
83 {
84 return vcopy_lane_mf8(a, 0, b, 0);
85 }
86
87 /*
88 ** test_copy_lane2:
89 ** ins v0.b\[0\], v1.b\[7\]
90 ** ret
91 */
92 mfloat8x8_t test_copy_lane2(mfloat8x8_t a, mfloat8x8_t b)
93 {
94 return vcopy_lane_mf8(a, 0, b, 7);
95 }
96
97 /*
98 ** test_copy_lane3:
99 ** ins v0.b\[7\], v1.b\[0\]
100 ** ret
101 */
102 mfloat8x8_t test_copy_lane3(mfloat8x8_t a, mfloat8x8_t b)
103 {
104 return vcopy_lane_mf8(a, 7, b, 0);
105 }
106
107 /*
108 ** test_copy_lane4:
109 ** ins v0.b\[5\], v1.b\[2\]
110 ** ret
111 */
112 mfloat8x8_t test_copy_lane4(mfloat8x8_t a, mfloat8x8_t b)
113 {
114 return vcopy_lane_mf8(a, 5, b, 2);
115 }
116
117 /*
118 ** test_copy_laneq1:
119 ** ins v0.b\[0\], v1.b\[0\]
120 ** ret
121 */
122 mfloat8x8_t test_copy_laneq1(mfloat8x8_t a, mfloat8x16_t b)
123 {
124 return vcopy_laneq_mf8(a, 0, b, 0);
125 }
126
127 /*
128 ** test_copy_laneq2:
129 ** ins v0.b\[0\], v1.b\[15\]
130 ** ret
131 */
132 mfloat8x8_t test_copy_laneq2(mfloat8x8_t a, mfloat8x16_t b)
133 {
134 return vcopy_laneq_mf8(a, 0, b, 15);
135 }
136
137 /*
138 ** test_copy_laneq3:
139 ** ins v0.b\[7\], v1.b\[0\]
140 ** ret
141 */
142 mfloat8x8_t test_copy_laneq3(mfloat8x8_t a, mfloat8x16_t b)
143 {
144 return vcopy_laneq_mf8(a, 7, b, 0);
145 }
146
147 /*
148 ** test_copy_laneq4:
149 ** ins v0.b\[6\], v1.b\[13\]
150 ** ret
151 */
152 mfloat8x8_t test_copy_laneq4(mfloat8x8_t a, mfloat8x16_t b)
153 {
154 return vcopy_laneq_mf8(a, 6, b, 13);
155 }
156
157 /*
158 ** test_copyq_lane1:
159 ** ins v0.b\[0\], v1.b\[0\]
160 ** ret
161 */
162 mfloat8x16_t test_copyq_lane1(mfloat8x16_t a, mfloat8x8_t b)
163 {
164 return vcopyq_lane_mf8(a, 0, b, 0);
165 }
166
167 /*
168 ** test_copyq_lane2:
169 ** ins v0.b\[0\], v1.b\[7\]
170 ** ret
171 */
172 mfloat8x16_t test_copyq_lane2(mfloat8x16_t a, mfloat8x8_t b)
173 {
174 return vcopyq_lane_mf8(a, 0, b, 7);
175 }
176
177 /*
178 ** test_copyq_lane3:
179 ** ins v0.b\[15\], v1.b\[0\]
180 ** ret
181 */
182 mfloat8x16_t test_copyq_lane3(mfloat8x16_t a, mfloat8x8_t b)
183 {
184 return vcopyq_lane_mf8(a, 15, b, 0);
185 }
186
187 /*
188 ** test_copyq_lane4:
189 ** ins v0.b\[11\], v1.b\[2\]
190 ** ret
191 */
192 mfloat8x16_t test_copyq_lane4(mfloat8x16_t a, mfloat8x8_t b)
193 {
194 return vcopyq_lane_mf8(a, 11, b, 2);
195 }
196
197 /*
198 ** test_copyq_laneq1:
199 ** ins v0.b\[0\], v1.b\[0\]
200 ** ret
201 */
202 mfloat8x16_t test_copyq_laneq1(mfloat8x16_t a, mfloat8x16_t b)
203 {
204 return vcopyq_laneq_mf8(a, 0, b, 0);
205 }
206
207 /*
208 ** test_copyq_laneq2:
209 ** ins v0.b\[0\], v1.b\[15\]
210 ** ret
211 */
212 mfloat8x16_t test_copyq_laneq2(mfloat8x16_t a, mfloat8x16_t b)
213 {
214 return vcopyq_laneq_mf8(a, 0, b, 15);
215 }
216
217 /*
218 ** test_copyq_laneq3:
219 ** ins v0.b\[15\], v1.b\[0\]
220 ** ret
221 */
222 mfloat8x16_t test_copyq_laneq3(mfloat8x16_t a, mfloat8x16_t b)
223 {
224 return vcopyq_laneq_mf8(a, 15, b, 0);
225 }
226
227 /*
228 ** test_copyq_laneq4:
229 ** ins v0.b\[9\], v1.b\[13\]
230 ** ret
231 */
232 mfloat8x16_t test_copyq_laneq4(mfloat8x16_t a, mfloat8x16_t b)
233 {
234 return vcopyq_laneq_mf8(a, 9, b, 13);
235 }
236
237 /*
238 ** test_create1:
239 ** fmov d0, x0
240 ** ret
241 */
242 mfloat8x8_t test_create1(uint64_t a)
243 {
244 return vcreate_mf8(a);
245 }
246
247 /*
248 ** test_create2:
249 ** movi d0, #?0xffff
250 ** ret
251 */
252 mfloat8x8_t test_create2()
253 {
254 return vcreate_mf8(0xffff);
255 }
256
257 /*
258 ** test_dup1:
259 ** dup v0.8b, v1.b\[0\]
260 ** ret
261 */
262 mfloat8x8_t test_dup1(mfloat8_t a, mfloat8_t b)
263 {
264 return vdup_n_mf8(b);
265 }
266
267 /*
268 ** test_dup2:
269 ** movi v0.2s, #?0
270 ** ret
271 */
272 mfloat8x8_t test_dup2()
273 {
274 return vdup_n_mf8(((union { uint8_t x; mfloat8_t y; }) { 0 }).y);
275 }
276
277 /*
278 ** test_dup3:
279 ** movi v0.8b, #?0xf
280 ** ret
281 */
282 mfloat8x8_t test_dup3()
283 {
284 return vdup_n_mf8(((union { uint8_t x; mfloat8_t y; }) { 0x0f }).y);
285 }
286
287 /*
288 ** test_dupq1:
289 ** dup v0.16b, v1.b\[0\]
290 ** ret
291 */
292 mfloat8x16_t test_dupq1(mfloat8_t a, mfloat8_t b)
293 {
294 return vdupq_n_mf8(b);
295 }
296
297 /*
298 ** test_dupq2:
299 ** movi v0.4s, #?0
300 ** ret
301 */
302 mfloat8x16_t test_dupq2()
303 {
304 return vdupq_n_mf8(((union { uint8_t x; mfloat8_t y; }) { 0 }).y);
305 }
306
307 /*
308 ** test_dupq3:
309 ** movi v0.16b, #?0xf
310 ** ret
311 */
312 mfloat8x16_t test_dupq3()
313 {
314 return vdupq_n_mf8(((union { uint8_t x; mfloat8_t y; }) { 0x0f }).y);
315 }
316
317 /*
318 ** test_dup_lane1:
319 ** dup v0.8b, v1.b\[0\]
320 ** ret
321 */
322 mfloat8x8_t test_dup_lane1(mfloat8_t a, mfloat8x8_t b)
323 {
324 return vdup_lane_mf8(b, 0);
325 }
326
327 /*
328 ** test_dup_lane2:
329 ** dup v0.8b, v1.b\[7\]
330 ** ret
331 */
332 mfloat8x8_t test_dup_lane2(mfloat8_t a, mfloat8x8_t b)
333 {
334 return vdup_lane_mf8(b, 7);
335 }
336
337 /*
338 ** test_dup_laneq1:
339 ** dup v0.8b, v1.b\[0\]
340 ** ret
341 */
342 mfloat8x8_t test_dup_laneq1(mfloat8_t a, mfloat8x16_t b)
343 {
344 return vdup_laneq_mf8(b, 0);
345 }
346
347 /*
348 ** test_dup_laneq2:
349 ** dup v0.8b, v1.b\[15\]
350 ** ret
351 */
352 mfloat8x8_t test_dup_laneq2(mfloat8_t a, mfloat8x16_t b)
353 {
354 return vdup_laneq_mf8(b, 15);
355 }
356
357 /*
358 ** test_dupq_lane1:
359 ** dup v0.16b, v1.b\[0\]
360 ** ret
361 */
362 mfloat8x16_t test_dupq_lane1(mfloat8_t a, mfloat8x8_t b)
363 {
364 return vdupq_lane_mf8(b, 0);
365 }
366
367 /*
368 ** test_dupq_lane2:
369 ** dup v0.16b, v1.b\[7\]
370 ** ret
371 */
372 mfloat8x16_t test_dupq_lane2(mfloat8_t a, mfloat8x8_t b)
373 {
374 return vdupq_lane_mf8(b, 7);
375 }
376
377 /*
378 ** test_dupq_laneq1:
379 ** dup v0.16b, v1.b\[0\]
380 ** ret
381 */
382 mfloat8x16_t test_dupq_laneq1(mfloat8_t a, mfloat8x16_t b)
383 {
384 return vdupq_laneq_mf8(b, 0);
385 }
386
387 /*
388 ** test_dupq_laneq2:
389 ** dup v0.16b, v1.b\[15\]
390 ** ret
391 */
392 mfloat8x16_t test_dupq_laneq2(mfloat8_t a, mfloat8x16_t b)
393 {
394 return vdupq_laneq_mf8(b, 15);
395 }
396
397 /*
398 ** test_dupb_lane1:
399 ** dup b0, v1.b\[0\]
400 ** ret
401 */
402 mfloat8_t test_dupb_lane1(mfloat8_t a, mfloat8x8_t b)
403 {
404 return vdupb_lane_mf8(b, 0);
405 }
406
407 /*
408 ** test_dupb_lane2:
409 ** dup b0, v1.b\[7\]
410 ** ret
411 */
412 mfloat8_t test_dupb_lane2(mfloat8_t a, mfloat8x8_t b)
413 {
414 return vdupb_lane_mf8(b, 7);
415 }
416
417 /*
418 ** test_dupb_laneq1:
419 ** dup b0, v1.b\[0\]
420 ** ret
421 */
422 mfloat8_t test_dupb_laneq1(mfloat8_t a, mfloat8x16_t b)
423 {
424 return vdupb_laneq_mf8(b, 0);
425 }
426
427 /*
428 ** test_dupb_laneq2:
429 ** dup b0, v1.b\[15\]
430 ** ret
431 */
432 mfloat8_t test_dupb_laneq2(mfloat8_t a, mfloat8x16_t b)
433 {
434 return vdupb_laneq_mf8(b, 15);
435 }
436
437 /*
438 ** test_ext1:
439 ** ext v0.8b, v0.8b, v1.8b, #1
440 ** ret
441 */
442 mfloat8x8_t test_ext1(mfloat8x8_t a, mfloat8x8_t b)
443 {
444 return vext_mf8(a, b, 1);
445 }
446
447 /*
448 ** test_ext2:
449 ** ext v0.8b, v1.8b, v2.8b, #7
450 ** ret
451 */
452 mfloat8x8_t test_ext2(mfloat8x8_t a, mfloat8x8_t b, mfloat8x8_t c)
453 {
454 return vext_mf8(b, c, 7);
455 }
456
457 /*
458 ** test_extq1:
459 ** ext v0.16b, v0.16b, v1.16b, #1
460 ** ret
461 */
462 mfloat8x16_t test_extq1(mfloat8x16_t a, mfloat8x16_t b)
463 {
464 return vextq_mf8(a, b, 1);
465 }
466
467 /*
468 ** test_extq2:
469 ** ext v0.16b, v1.16b, v2.16b, #15
470 ** ret
471 */
472 mfloat8x16_t test_extq2(mfloat8x16_t a, mfloat8x16_t b, mfloat8x16_t c)
473 {
474 return vextq_mf8(b, c, 15);
475 }
476
477 /*
478 ** test_ld1: { target { le && lp64 } }
479 ** ldr d0, \[x0\]
480 ** ret
481 */
482 /*
483 ** test_ld1: { target { be && lp64 } }
484 ** ld1 {v0.8b}, \[x0\]
485 ** ret
486 */
487 mfloat8x8_t test_ld1(const mfloat8_t *ptr)
488 {
489 return vld1_mf8(ptr);
490 }
491
492 /*
493 ** test_ld1q: { target { le && lp64 } }
494 ** ldr q0, \[x0\]
495 ** ret
496 */
497 /*
498 ** test_ld1q: { target { be && lp64 } }
499 ** ld1 {v0.16b}, \[x0\]
500 ** ret
501 */
502 mfloat8x16_t test_ld1q(const mfloat8_t *ptr)
503 {
504 return vld1q_mf8(ptr);
505 }
506
507 /*
508 ** test_ld1_dup: { target lp64 }
509 ** ld1r {v0.8b}, \[x0\]
510 ** ret
511 */
512 mfloat8x8_t test_ld1_dup(const mfloat8_t *ptr)
513 {
514 return vld1_dup_mf8(ptr);
515 }
516
517 /*
518 ** test_ld1q_dup: { target lp64 }
519 ** ld1r {v0.16b}, \[x0\]
520 ** ret
521 */
522 mfloat8x16_t test_ld1q_dup(const mfloat8_t *ptr)
523 {
524 return vld1q_dup_mf8(ptr);
525 }
526
527 /*
528 ** test_ld1_lane1: { target lp64 }
529 ** ld1 {v0.b}\[0\], \[x0\]
530 ** ret
531 */
532 mfloat8x8_t test_ld1_lane1(const mfloat8_t *ptr, mfloat8x8_t a)
533 {
534 return vld1_lane_mf8(ptr, a, 0);
535 }
536
537 /*
538 ** test_ld1_lane2: { target lp64 }
539 ** ld1 {v0.b}\[7\], \[x0\]
540 ** ret
541 */
542 mfloat8x8_t test_ld1_lane2(const mfloat8_t *ptr, mfloat8x8_t a)
543 {
544 return vld1_lane_mf8(ptr, a, 7);
545 }
546
547 /*
548 ** test_ld1q_lane1: { target lp64 }
549 ** ld1 {v0.b}\[0\], \[x0\]
550 ** ret
551 */
552 mfloat8x16_t test_ld1q_lane1(const mfloat8_t *ptr, mfloat8x16_t a)
553 {
554 return vld1q_lane_mf8(ptr, a, 0);
555 }
556
557 /*
558 ** test_ld1q_lane2: { target lp64 }
559 ** ld1 {v0.b}\[15\], \[x0\]
560 ** ret
561 */
562 mfloat8x16_t test_ld1q_lane2(const mfloat8_t *ptr, mfloat8x16_t a)
563 {
564 return vld1q_lane_mf8(ptr, a, 15);
565 }
566
567 /*
568 ** test_ld1_x2: { target lp64 }
569 ** ld1 {v0.8b( - |, )v1.8b}, \[x0\]
570 ** ret
571 */
572 mfloat8x8x2_t test_ld1_x2(const mfloat8_t *ptr)
573 {
574 return vld1_mf8_x2(ptr);
575 }
576
577 /*
578 ** test_ld1q_x2: { target lp64 }
579 ** ld1 {v0.16b( - |, )v1.16b}, \[x0\]
580 ** ret
581 */
582 mfloat8x16x2_t test_ld1q_x2(const mfloat8_t *ptr)
583 {
584 return vld1q_mf8_x2(ptr);
585 }
586
587 /*
588 ** test_ld1_x3: { target lp64 }
589 ** ld1 {v0.8b - v2.8b}, \[x0\]
590 ** ret
591 */
592 mfloat8x8x3_t test_ld1_x3(const mfloat8_t *ptr)
593 {
594 return vld1_mf8_x3(ptr);
595 }
596
597 /*
598 ** test_ld1q_x3: { target lp64 }
599 ** ld1 {v0.16b - v2.16b}, \[x0\]
600 ** ret
601 */
602 mfloat8x16x3_t test_ld1q_x3(const mfloat8_t *ptr)
603 {
604 return vld1q_mf8_x3(ptr);
605 }
606
607 /*
608 ** test_ld1_x4: { target lp64 }
609 ** ld1 {v0.8b - v3.8b}, \[x0\]
610 ** ret
611 */
612 mfloat8x8x4_t test_ld1_x4(const mfloat8_t *ptr)
613 {
614 return vld1_mf8_x4(ptr);
615 }
616
617 /*
618 ** test_ld1q_x4: { target lp64 }
619 ** ld1 {v0.16b - v3.16b}, \[x0\]
620 ** ret
621 */
622 mfloat8x16x4_t test_ld1q_x4(const mfloat8_t *ptr)
623 {
624 return vld1q_mf8_x4(ptr);
625 }
626
627 /*
628 ** test_ld2: { target lp64 }
629 ** ld2 {v0.8b( - |, )v1.8b}, \[x0\]
630 ** ret
631 */
632 mfloat8x8x2_t test_ld2(const mfloat8_t *ptr)
633 {
634 return vld2_mf8(ptr);
635 }
636
637 /*
638 ** test_ld2q: { target lp64 }
639 ** ld2 {v0.16b( - |, )v1.16b}, \[x0\]
640 ** ret
641 */
642 mfloat8x16x2_t test_ld2q(const mfloat8_t *ptr)
643 {
644 return vld2q_mf8(ptr);
645 }
646
647 /*
648 ** test_ld2_dup: { target lp64 }
649 ** ld2r {v0.8b( - |, )v1.8b}, \[x0\]
650 ** ret
651 */
652 mfloat8x8x2_t test_ld2_dup(const mfloat8_t *ptr)
653 {
654 return vld2_dup_mf8(ptr);
655 }
656
657 /*
658 ** test_ld2q_dup: { target lp64 }
659 ** ld2r {v0.16b( - |, )v1.16b}, \[x0\]
660 ** ret
661 */
662 mfloat8x16x2_t test_ld2q_dup(const mfloat8_t *ptr)
663 {
664 return vld2q_dup_mf8(ptr);
665 }
666
667 /*
668 ** test_ld2_lane1: { target lp64 }
669 ** ld2 {v0.b( - |, )v1.b}\[0\], \[x0\]
670 ** ret
671 */
672 mfloat8x8x2_t test_ld2_lane1(const mfloat8_t *ptr, mfloat8x8x2_t a)
673 {
674 return vld2_lane_mf8(ptr, a, 0);
675 }
676
677 /*
678 ** test_ld2_lane2: { target lp64 }
679 ** ld2 {v0.b( - |, )v1.b}\[7\], \[x0\]
680 ** ret
681 */
682 mfloat8x8x2_t test_ld2_lane2(const mfloat8_t *ptr, mfloat8x8x2_t a)
683 {
684 return vld2_lane_mf8(ptr, a, 7);
685 }
686
687 /*
688 ** test_ld2q_lane1: { target lp64 }
689 ** ld2 {v0.b( - |, )v1.b}\[0\], \[x0\]
690 ** ret
691 */
692 mfloat8x16x2_t test_ld2q_lane1(const mfloat8_t *ptr, mfloat8x16x2_t a)
693 {
694 return vld2q_lane_mf8(ptr, a, 0);
695 }
696
697 /*
698 ** test_ld2q_lane2: { target lp64 }
699 ** ld2 {v0.b( - |, )v1.b}\[15\], \[x0\]
700 ** ret
701 */
702 mfloat8x16x2_t test_ld2q_lane2(const mfloat8_t *ptr, mfloat8x16x2_t a)
703 {
704 return vld2q_lane_mf8(ptr, a, 15);
705 }
706
707 /*
708 ** test_ld3: { target lp64 }
709 ** ld3 {v0.8b - v2.8b}, \[x0\]
710 ** ret
711 */
712 mfloat8x8x3_t test_ld3(const mfloat8_t *ptr)
713 {
714 return vld3_mf8(ptr);
715 }
716
717 /*
718 ** test_ld3q: { target lp64 }
719 ** ld3 {v0.16b - v2.16b}, \[x0\]
720 ** ret
721 */
722 mfloat8x16x3_t test_ld3q(const mfloat8_t *ptr)
723 {
724 return vld3q_mf8(ptr);
725 }
726
727 /*
728 ** test_ld3_dup: { target lp64 }
729 ** ld3r {v0.8b - v2.8b}, \[x0\]
730 ** ret
731 */
732 mfloat8x8x3_t test_ld3_dup(const mfloat8_t *ptr)
733 {
734 return vld3_dup_mf8(ptr);
735 }
736
737 /*
738 ** test_ld3q_dup: { target lp64 }
739 ** ld3r {v0.16b - v2.16b}, \[x0\]
740 ** ret
741 */
742 mfloat8x16x3_t test_ld3q_dup(const mfloat8_t *ptr)
743 {
744 return vld3q_dup_mf8(ptr);
745 }
746
747 /*
748 ** test_ld3_lane1: { target lp64 }
749 ** ld3 {v0.b - v2.b}\[0\], \[x0\]
750 ** ret
751 */
752 mfloat8x8x3_t test_ld3_lane1(const mfloat8_t *ptr, mfloat8x8x3_t a)
753 {
754 return vld3_lane_mf8(ptr, a, 0);
755 }
756
757 /*
758 ** test_ld3_lane2: { target lp64 }
759 ** ld3 {v0.b - v2.b}\[7\], \[x0\]
760 ** ret
761 */
762 mfloat8x8x3_t test_ld3_lane2(const mfloat8_t *ptr, mfloat8x8x3_t a)
763 {
764 return vld3_lane_mf8(ptr, a, 7);
765 }
766
767 /*
768 ** test_ld3q_lane1: { target lp64 }
769 ** ld3 {v0.b - v2.b}\[0\], \[x0\]
770 ** ret
771 */
772 mfloat8x16x3_t test_ld3q_lane1(const mfloat8_t *ptr, mfloat8x16x3_t a)
773 {
774 return vld3q_lane_mf8(ptr, a, 0);
775 }
776
777 /*
778 ** test_ld3q_lane2: { target lp64 }
779 ** ld3 {v0.b - v2.b}\[15\], \[x0\]
780 ** ret
781 */
782 mfloat8x16x3_t test_ld3q_lane2(const mfloat8_t *ptr, mfloat8x16x3_t a)
783 {
784 return vld3q_lane_mf8(ptr, a, 15);
785 }
786
787 /*
788 ** test_ld4: { target lp64 }
789 ** ld4 {v0.8b - v3.8b}, \[x0\]
790 ** ret
791 */
792 mfloat8x8x4_t test_ld4(const mfloat8_t *ptr)
793 {
794 return vld4_mf8(ptr);
795 }
796
797 /*
798 ** test_ld4q: { target lp64 }
799 ** ld4 {v0.16b - v3.16b}, \[x0\]
800 ** ret
801 */
802 mfloat8x16x4_t test_ld4q(const mfloat8_t *ptr)
803 {
804 return vld4q_mf8(ptr);
805 }
806
807 /*
808 ** test_ld4_dup: { target lp64 }
809 ** ld4r {v0.8b - v3.8b}, \[x0\]
810 ** ret
811 */
812 mfloat8x8x4_t test_ld4_dup(const mfloat8_t *ptr)
813 {
814 return vld4_dup_mf8(ptr);
815 }
816
817 /*
818 ** test_ld4q_dup: { target lp64 }
819 ** ld4r {v0.16b - v3.16b}, \[x0\]
820 ** ret
821 */
822 mfloat8x16x4_t test_ld4q_dup(const mfloat8_t *ptr)
823 {
824 return vld4q_dup_mf8(ptr);
825 }
826
827 /*
828 ** test_ld4_lane1: { target lp64 }
829 ** ld4 {v0.b - v3.b}\[0\], \[x0\]
830 ** ret
831 */
832 mfloat8x8x4_t test_ld4_lane1(const mfloat8_t *ptr, mfloat8x8x4_t a)
833 {
834 return vld4_lane_mf8(ptr, a, 0);
835 }
836
837 /*
838 ** test_ld4_lane2: { target lp64 }
839 ** ld4 {v0.b - v3.b}\[7\], \[x0\]
840 ** ret
841 */
842 mfloat8x8x4_t test_ld4_lane2(const mfloat8_t *ptr, mfloat8x8x4_t a)
843 {
844 return vld4_lane_mf8(ptr, a, 7);
845 }
846
847 /*
848 ** test_ld4q_lane1: { target lp64 }
849 ** ld4 {v0.b - v3.b}\[0\], \[x0\]
850 ** ret
851 */
852 mfloat8x16x4_t test_ld4q_lane1(const mfloat8_t *ptr, mfloat8x16x4_t a)
853 {
854 return vld4q_lane_mf8(ptr, a, 0);
855 }
856
857 /*
858 ** test_ld4q_lane2: { target lp64 }
859 ** ld4 {v0.b - v3.b}\[15\], \[x0\]
860 ** ret
861 */
862 mfloat8x16x4_t test_ld4q_lane2(const mfloat8_t *ptr, mfloat8x16x4_t a)
863 {
864 return vld4q_lane_mf8(ptr, a, 15);
865 }
866
867 /*
868 ** test_mov1:
869 ** dup v0.8b, v1.b\[0\]
870 ** ret
871 */
872 mfloat8x8_t test_mov1(mfloat8_t a, mfloat8_t b)
873 {
874 return vmov_n_mf8(b);
875 }
876
877 /*
878 ** test_mov2:
879 ** movi v0.2s, #?0
880 ** ret
881 */
882 mfloat8x8_t test_mov2()
883 {
884 return vmov_n_mf8(((union { uint8_t x; mfloat8_t y; }) { 0 }).y);
885 }
886
887 /*
888 ** test_mov3:
889 ** movi v0.8b, #?0xf
890 ** ret
891 */
892 mfloat8x8_t test_mov3()
893 {
894 return vmov_n_mf8(((union { uint8_t x; mfloat8_t y; }) { 0x0f }).y);
895 }
896
897 /*
898 ** test_movq1:
899 ** dup v0.16b, v1.b\[0\]
900 ** ret
901 */
902 mfloat8x16_t test_movq1(mfloat8_t a, mfloat8_t b)
903 {
904 return vmovq_n_mf8(b);
905 }
906
907 /*
908 ** test_movq2:
909 ** movi v0.4s, #?0
910 ** ret
911 */
912 mfloat8x16_t test_movq2()
913 {
914 return vmovq_n_mf8(((union { uint8_t x; mfloat8_t y; }) { 0 }).y);
915 }
916
917 /*
918 ** test_movq3:
919 ** movi v0.16b, #?0xf
920 ** ret
921 */
922 mfloat8x16_t test_movq3()
923 {
924 return vmovq_n_mf8(((union { uint8_t x; mfloat8_t y; }) { 0x0f }).y);
925 }
926
927 /*
928 ** test_rev16:
929 ** rev16 v0.8b, v1.8b
930 ** ret
931 */
932 mfloat8x8_t test_rev16(mfloat8_t a, mfloat8x8_t b)
933 {
934 return vrev16_mf8(b);
935 }
936
937 /*
938 ** test_rev16q:
939 ** rev16 v0.16b, v1.16b
940 ** ret
941 */
942 mfloat8x16_t test_rev16q(mfloat8_t a, mfloat8x16_t b)
943 {
944 return vrev16q_mf8(b);
945 }
946
947 /*
948 ** test_rev32:
949 ** rev32 v0.8b, v1.8b
950 ** ret
951 */
952 mfloat8x8_t test_rev32(mfloat8_t a, mfloat8x8_t b)
953 {
954 return vrev32_mf8(b);
955 }
956
957 /*
958 ** test_rev32q:
959 ** rev32 v0.16b, v1.16b
960 ** ret
961 */
962 mfloat8x16_t test_rev32q(mfloat8_t a, mfloat8x16_t b)
963 {
964 return vrev32q_mf8(b);
965 }
966
967 /*
968 ** test_rev64:
969 ** rev64 v0.8b, v1.8b
970 ** ret
971 */
972 mfloat8x8_t test_rev64(mfloat8_t a, mfloat8x8_t b)
973 {
974 return vrev64_mf8(b);
975 }
976
977 /*
978 ** test_rev64q:
979 ** rev64 v0.16b, v1.16b
980 ** ret
981 */
982 mfloat8x16_t test_rev64q(mfloat8_t a, mfloat8x16_t b)
983 {
984 return vrev64q_mf8(b);
985 }
986
987 /*
988 ** test_set_lane1:
989 ** ins v0.b\[0\], v1.b\[0\]
990 ** ret
991 */
992 mfloat8x8_t test_set_lane1(mfloat8x8_t a, mfloat8_t b)
993 {
994 return vset_lane_mf8(b, a, 0);
995 }
996
997 /*
998 ** test_set_lane2:
999 ** ins v0.b\[7\], v1.b\[0\]
1000 ** ret
1001 */
1002 mfloat8x8_t test_set_lane2(mfloat8x8_t a, mfloat8_t b)
1003 {
1004 return vset_lane_mf8(b, a, 7);
1005 }
1006
1007 /*
1008 ** test_set_lane3: { target lp64 }
1009 ** ld1 {v0.b}\[3\], \[x0\]
1010 ** ret
1011 */
1012 mfloat8x8_t test_set_lane3(mfloat8x8_t a, const mfloat8_t *ptr)
1013 {
1014 return vset_lane_mf8(*ptr, a, 3);
1015 }
1016
1017 /*
1018 ** test_set_lane4:
1019 ** ins v0.b\[6\], wzr
1020 ** ret
1021 */
1022 mfloat8x8_t test_set_lane4(mfloat8x8_t a)
1023 {
1024 return vset_lane_mf8(((union { uint8_t x; mfloat8_t y; }) { 0 }).y, a, 6);
1025 }
1026
1027 /*
1028 ** test_setq_lane1:
1029 ** ins v0.b\[0\], v1.b\[0\]
1030 ** ret
1031 */
1032 mfloat8x16_t test_setq_lane1(mfloat8x16_t a, mfloat8_t b)
1033 {
1034 return vsetq_lane_mf8(b, a, 0);
1035 }
1036
1037 /*
1038 ** test_setq_lane2:
1039 ** ins v0.b\[15\], v1.b\[0\]
1040 ** ret
1041 */
1042 mfloat8x16_t test_setq_lane2(mfloat8x16_t a, mfloat8_t b)
1043 {
1044 return vsetq_lane_mf8(b, a, 15);
1045 }
1046
1047 /*
1048 ** test_setq_lane3: { target lp64 }
1049 ** ld1 {v0.b}\[9\], \[x0\]
1050 ** ret
1051 */
1052 mfloat8x16_t test_setq_lane3(mfloat8x16_t a, const mfloat8_t *ptr)
1053 {
1054 return vsetq_lane_mf8(*ptr, a, 9);
1055 }
1056
1057 /*
1058 ** test_setq_lane4:
1059 ** ins v0.b\[14\], wzr
1060 ** ret
1061 */
1062 mfloat8x16_t test_setq_lane4(mfloat8x16_t a)
1063 {
1064 return vsetq_lane_mf8(((union { uint8_t x; mfloat8_t y; }) { 0 }).y, a, 14);
1065 }
1066
1067 /*
1068 ** test_st1: { target { le && lp64 } }
1069 ** str d0, \[x0\]
1070 ** ret
1071 */
1072 /*
1073 ** test_st1: { target { be && lp64 } }
1074 ** st1 {v0.8b}, \[x0\]
1075 ** ret
1076 */
1077 void test_st1(mfloat8_t *ptr, mfloat8x8_t a)
1078 {
1079 vst1_mf8(ptr, a);
1080 }
1081
1082 /*
1083 ** test_st1q: { target { le && lp64 } }
1084 ** str q0, \[x0\]
1085 ** ret
1086 */
1087 /*
1088 ** test_st1q: { target { be && lp64 } }
1089 ** st1 {v0.16b}, \[x0\]
1090 ** ret
1091 */
1092 void test_st1q(mfloat8_t *ptr, mfloat8x16_t a)
1093 {
1094 vst1q_mf8(ptr, a);
1095 }
1096
1097 /*
1098 ** test_st1_lane1: { target lp64 }
1099 ** str b0, \[x0\]
1100 ** ret
1101 */
1102 void test_st1_lane1(mfloat8_t *ptr, mfloat8x8_t a)
1103 {
1104 vst1_lane_mf8(ptr, a, 0);
1105 }
1106
1107 /*
1108 ** test_st1_lane2: { target lp64 }
1109 ** st1 {v0.b}\[7\], \[x0\]
1110 ** ret
1111 */
1112 void test_st1_lane2(mfloat8_t *ptr, mfloat8x8_t a)
1113 {
1114 vst1_lane_mf8(ptr, a, 7);
1115 }
1116
1117 /*
1118 ** test_st1q_lane1: { target lp64 }
1119 ** str b0, \[x0\]
1120 ** ret
1121 */
1122 void test_st1q_lane1(mfloat8_t *ptr, mfloat8x16_t a)
1123 {
1124 vst1q_lane_mf8(ptr, a, 0);
1125 }
1126
1127 /*
1128 ** test_st1q_lane2: { target lp64 }
1129 ** st1 {v0.b}\[15\], \[x0\]
1130 ** ret
1131 */
1132 void test_st1q_lane2(mfloat8_t *ptr, mfloat8x16_t a)
1133 {
1134 vst1q_lane_mf8(ptr, a, 15);
1135 }
1136
1137 /*
1138 ** test_st1_x2: { target lp64 }
1139 ** st1 {v0.8b( - |, )v1.8b}, \[x0\]
1140 ** ret
1141 */
1142 void test_st1_x2(mfloat8_t *ptr, mfloat8x8x2_t a)
1143 {
1144 vst1_mf8_x2(ptr, a);
1145 }
1146
1147 /*
1148 ** test_st1q_x2: { target lp64 }
1149 ** st1 {v0.16b( - |, )v1.16b}, \[x0\]
1150 ** ret
1151 */
1152 void test_st1q_x2(mfloat8_t *ptr, mfloat8x16x2_t a)
1153 {
1154 vst1q_mf8_x2(ptr, a);
1155 }
1156
1157 /*
1158 ** test_st1_x3: { target lp64 }
1159 ** st1 {v0.8b - v2.8b}, \[x0\]
1160 ** ret
1161 */
1162 void test_st1_x3(mfloat8_t *ptr, mfloat8x8x3_t a)
1163 {
1164 vst1_mf8_x3(ptr, a);
1165 }
1166
1167 /*
1168 ** test_st1q_x3: { target lp64 }
1169 ** st1 {v0.16b - v2.16b}, \[x0\]
1170 ** ret
1171 */
1172 void test_st1q_x3(mfloat8_t *ptr, mfloat8x16x3_t a)
1173 {
1174 vst1q_mf8_x3(ptr, a);
1175 }
1176
1177 /*
1178 ** test_st1_x4: { target lp64 }
1179 ** st1 {v0.8b - v3.8b}, \[x0\]
1180 ** ret
1181 */
1182 void test_st1_x4(mfloat8_t *ptr, mfloat8x8x4_t a)
1183 {
1184 vst1_mf8_x4(ptr, a);
1185 }
1186
1187 /*
1188 ** test_st1q_x4: { target lp64 }
1189 ** st1 {v0.16b - v3.16b}, \[x0\]
1190 ** ret
1191 */
1192 void test_st1q_x4(mfloat8_t *ptr, mfloat8x16x4_t a)
1193 {
1194 vst1q_mf8_x4(ptr, a);
1195 }
1196
1197 /*
1198 ** test_st2: { target lp64 }
1199 ** st2 {v0.8b( - |, )v1.8b}, \[x0\]
1200 ** ret
1201 */
1202 void test_st2(mfloat8_t *ptr, mfloat8x8x2_t a)
1203 {
1204 vst2_mf8(ptr, a);
1205 }
1206
1207 /*
1208 ** test_st2q: { target lp64 }
1209 ** st2 {v0.16b( - |, )v1.16b}, \[x0\]
1210 ** ret
1211 */
1212 void test_st2q(mfloat8_t *ptr, mfloat8x16x2_t a)
1213 {
1214 vst2q_mf8(ptr, a);
1215 }
1216
1217 /*
1218 ** test_st2_lane1: { target lp64 }
1219 ** st2 {v0.b( - |, )v1.b}\[0\], \[x0\]
1220 ** ret
1221 */
1222 void test_st2_lane1(mfloat8_t *ptr, mfloat8x8x2_t a)
1223 {
1224 vst2_lane_mf8(ptr, a, 0);
1225 }
1226
1227 /*
1228 ** test_st2_lane2: { target lp64 }
1229 ** st2 {v0.b( - |, )v1.b}\[7\], \[x0\]
1230 ** ret
1231 */
1232 void test_st2_lane2(mfloat8_t *ptr, mfloat8x8x2_t a)
1233 {
1234 vst2_lane_mf8(ptr, a, 7);
1235 }
1236
1237 /*
1238 ** test_st2q_lane1: { target lp64 }
1239 ** st2 {v0.b( - |, )v1.b}\[0\], \[x0\]
1240 ** ret
1241 */
1242 void test_st2q_lane1(mfloat8_t *ptr, mfloat8x16x2_t a)
1243 {
1244 vst2q_lane_mf8(ptr, a, 0);
1245 }
1246
1247 /*
1248 ** test_st2q_lane2: { target lp64 }
1249 ** st2 {v0.b( - |, )v1.b}\[15\], \[x0\]
1250 ** ret
1251 */
1252 void test_st2q_lane2(mfloat8_t *ptr, mfloat8x16x2_t a)
1253 {
1254 vst2q_lane_mf8(ptr, a, 15);
1255 }
1256
1257 /*
1258 ** test_st3: { target lp64 }
1259 ** st3 {v0.8b - v2.8b}, \[x0\]
1260 ** ret
1261 */
1262 void test_st3(mfloat8_t *ptr, mfloat8x8x3_t a)
1263 {
1264 vst3_mf8(ptr, a);
1265 }
1266
1267 /*
1268 ** test_st3q: { target lp64 }
1269 ** st3 {v0.16b - v2.16b}, \[x0\]
1270 ** ret
1271 */
1272 void test_st3q(mfloat8_t *ptr, mfloat8x16x3_t a)
1273 {
1274 vst3q_mf8(ptr, a);
1275 }
1276
1277 /*
1278 ** test_st3_lane1: { target lp64 }
1279 ** st3 {v0.b - v2.b}\[0\], \[x0\]
1280 ** ret
1281 */
1282 void test_st3_lane1(mfloat8_t *ptr, mfloat8x8x3_t a)
1283 {
1284 vst3_lane_mf8(ptr, a, 0);
1285 }
1286
1287 /*
1288 ** test_st3_lane2: { target lp64 }
1289 ** st3 {v0.b - v2.b}\[7\], \[x0\]
1290 ** ret
1291 */
1292 void test_st3_lane2(mfloat8_t *ptr, mfloat8x8x3_t a)
1293 {
1294 vst3_lane_mf8(ptr, a, 7);
1295 }
1296
1297 /*
1298 ** test_st3q_lane1: { target lp64 }
1299 ** st3 {v0.b - v2.b}\[0\], \[x0\]
1300 ** ret
1301 */
1302 void test_st3q_lane1(mfloat8_t *ptr, mfloat8x16x3_t a)
1303 {
1304 vst3q_lane_mf8(ptr, a, 0);
1305 }
1306
1307 /*
1308 ** test_st3q_lane2: { target lp64 }
1309 ** st3 {v0.b - v2.b}\[15\], \[x0\]
1310 ** ret
1311 */
1312 void test_st3q_lane2(mfloat8_t *ptr, mfloat8x16x3_t a)
1313 {
1314 vst3q_lane_mf8(ptr, a, 15);
1315 }
1316
1317 /*
1318 ** test_st4: { target lp64 }
1319 ** st4 {v0.8b - v3.8b}, \[x0\]
1320 ** ret
1321 */
1322 void test_st4(mfloat8_t *ptr, mfloat8x8x4_t a)
1323 {
1324 vst4_mf8(ptr, a);
1325 }
1326
1327 /*
1328 ** test_st4q: { target lp64 }
1329 ** st4 {v0.16b - v3.16b}, \[x0\]
1330 ** ret
1331 */
1332 void test_st4q(mfloat8_t *ptr, mfloat8x16x4_t a)
1333 {
1334 vst4q_mf8(ptr, a);
1335 }
1336
1337 /*
1338 ** test_st4_lane1: { target lp64 }
1339 ** st4 {v0.b - v3.b}\[0\], \[x0\]
1340 ** ret
1341 */
1342 void test_st4_lane1(mfloat8_t *ptr, mfloat8x8x4_t a)
1343 {
1344 vst4_lane_mf8(ptr, a, 0);
1345 }
1346
1347 /*
1348 ** test_st4_lane2: { target lp64 }
1349 ** st4 {v0.b - v3.b}\[7\], \[x0\]
1350 ** ret
1351 */
1352 void test_st4_lane2(mfloat8_t *ptr, mfloat8x8x4_t a)
1353 {
1354 vst4_lane_mf8(ptr, a, 7);
1355 }
1356
1357 /*
1358 ** test_st4q_lane1: { target lp64 }
1359 ** st4 {v0.b - v3.b}\[0\], \[x0\]
1360 ** ret
1361 */
1362 void test_st4q_lane1(mfloat8_t *ptr, mfloat8x16x4_t a)
1363 {
1364 vst4q_lane_mf8(ptr, a, 0);
1365 }
1366
1367 /*
1368 ** test_st4q_lane2: { target lp64 }
1369 ** st4 {v0.b - v3.b}\[15\], \[x0\]
1370 ** ret
1371 */
1372 void test_st4q_lane2(mfloat8_t *ptr, mfloat8x16x4_t a)
1373 {
1374 vst4q_lane_mf8(ptr, a, 15);
1375 }
1376
1377 /*
1378 ** test_tbl1:
1379 ** fmov d([0-9]+), d0
1380 ** tbl v0.8b, {v\1.16b}, v1.8b
1381 ** ret
1382 */
1383 mfloat8x8_t test_tbl1(mfloat8x8_t a, uint8x8_t b)
1384 {
1385 return vtbl1_mf8(a, b);
1386 }
1387
1388 /*
1389 ** test_tbl2:
1390 ** uzp1 v([0-9]+).2d, v0.2d, v1.2d
1391 ** tbl v0.8b, {v\1.16b}, v2.8b
1392 ** ret
1393 */
1394 mfloat8x8_t test_tbl2(mfloat8x8x2_t a, uint8x8_t b)
1395 {
1396 return vtbl2_mf8(a, b);
1397 }
1398
1399 /*
1400 ** test_tbl3:
1401 ** uzp1 v([0-9]+).2d, v0.2d, v1.2d
1402 ** fmov d([0-9]+), d2
1403 ** tbl v0.8b, {v\1.16b( - |, )v\2.16b}, v3.8b
1404 ** ret
1405 */
1406 mfloat8x8_t test_tbl3(mfloat8x8x3_t a, uint8x8_t b)
1407 {
1408 return vtbl3_mf8(a, b);
1409 }
1410
1411 /*
1412 ** test_tbl4:
1413 ** uzp1 v([0-9]+).2d, v0.2d, v1.2d
1414 ** uzp1 v([0-9]+).2d, v2.2d, v3.2d
1415 ** tbl v0.8b, {v\1.16b( - |, )v\2.16b}, v4.8b
1416 ** ret
1417 */
1418 mfloat8x8_t test_tbl4(mfloat8x8x4_t a, uint8x8_t b)
1419 {
1420 return vtbl4_mf8(a, b);
1421 }
1422
1423 /*
1424 ** test_qtbl1:
1425 ** tbl v0.8b, {v0.16b}, v1.8b
1426 ** ret
1427 */
1428 mfloat8x8_t test_qtbl1(mfloat8x16_t a, uint8x8_t b)
1429 {
1430 return vqtbl1_mf8(a, b);
1431 }
1432
1433 /*
1434 ** test_qtbl1q:
1435 ** tbl v0.16b, {v0.16b}, v1.16b
1436 ** ret
1437 */
1438 mfloat8x16_t test_qtbl1q(mfloat8x16_t a, uint8x16_t b)
1439 {
1440 return vqtbl1q_mf8(a, b);
1441 }
1442
1443 /*
1444 ** test_qtbl2:
1445 ** tbl v0.8b, {v0.16b( - |, )v1.16b}, v2.8b
1446 ** ret
1447 */
1448 mfloat8x8_t test_qtbl2(mfloat8x16x2_t a, uint8x8_t b)
1449 {
1450 return vqtbl2_mf8(a, b);
1451 }
1452
1453 /*
1454 ** test_qtbl2q:
1455 ** tbl v0.16b, {v0.16b( - |, )v1.16b}, v2.16b
1456 ** ret
1457 */
1458 mfloat8x16_t test_qtbl2q(mfloat8x16x2_t a, uint8x16_t b)
1459 {
1460 return vqtbl2q_mf8(a, b);
1461 }
1462
1463 /*
1464 ** test_qtbl3:
1465 ** tbl v0.8b, {v0.16b - v2.16b}, v3.8b
1466 ** ret
1467 */
1468 mfloat8x8_t test_qtbl3(mfloat8x16x3_t a, uint8x8_t b)
1469 {
1470 return vqtbl3_mf8(a, b);
1471 }
1472
1473 /*
1474 ** test_qtbl3q:
1475 ** tbl v0.16b, {v0.16b - v2.16b}, v3.16b
1476 ** ret
1477 */
1478 mfloat8x16_t test_qtbl3q(mfloat8x16x3_t a, uint8x16_t b)
1479 {
1480 return vqtbl3q_mf8(a, b);
1481 }
1482
1483 /*
1484 ** test_qtbl4:
1485 ** tbl v0.8b, {v0.16b - v3.16b}, v4.8b
1486 ** ret
1487 */
1488 mfloat8x8_t test_qtbl4(mfloat8x16x4_t a, uint8x8_t b)
1489 {
1490 return vqtbl4_mf8(a, b);
1491 }
1492
1493 /*
1494 ** test_qtbl4q:
1495 ** tbl v0.16b, {v0.16b - v3.16b}, v4.16b
1496 ** ret
1497 */
1498 mfloat8x16_t test_qtbl4q(mfloat8x16x4_t a, uint8x16_t b)
1499 {
1500 return vqtbl4q_mf8(a, b);
1501 }
1502
1503 /*
1504 ** test_tbx1:
1505 ** fmov d([0-9]+), d1
1506 ** tbl v[0-9]+.8b, {v\1.16b}, v2.8b
1507 ** ...
1508 ** cmh[is] [^\n]+
1509 ** (bit|bif|bsl) [^\n]+
1510 ** ret
1511 */
1512 mfloat8x8_t test_tbx1(mfloat8x8_t a, mfloat8x8_t b, uint8x8_t c)
1513 {
1514 return vtbx1_mf8(a, b, c);
1515 }
1516
1517 /*
1518 ** test_tbx2:
1519 ** uzp1 v([0-9]+).2d, v1.2d, v2.2d
1520 ** tbx v[0-9]+.8b, {v\1.16b}, v3.8b
1521 ** ret
1522 */
1523 mfloat8x8_t test_tbx2(mfloat8x8_t a, mfloat8x8x2_t b, uint8x8_t c)
1524 {
1525 return vtbx2_mf8(a, b, c);
1526 }
1527
1528 /*
1529 ** test_tbx3:
1530 ** uzp1 v([0-9]+).2d, v1.2d, v2.2d
1531 ** fmov d([0-9]+), d3
1532 ** tbl v[0-9]+.8b, {v\1.16b( - |, )v\2.16b}, v4.8b
1533 ** ...
1534 ** cmh[is] [^\n]+
1535 ** (bit|bif|bsl) [^\n]+
1536 ** ret
1537 */
1538 mfloat8x8_t test_tbx3(mfloat8x8_t a, mfloat8x8x3_t b, uint8x8_t c)
1539 {
1540 return vtbx3_mf8(a, b, c);
1541 }
1542
1543 /*
1544 ** test_tbx4:
1545 ** uzp1 v([0-9]+).2d, v1.2d, v2.2d
1546 ** uzp1 v([0-9]+).2d, v3.2d, v4.2d
1547 ** tbx v0.8b, {v\1.16b( - |, )v\2.16b}, v5.8b
1548 ** ret
1549 */
1550 mfloat8x8_t test_tbx4(mfloat8x8_t a, mfloat8x8x4_t b, uint8x8_t c)
1551 {
1552 return vtbx4_mf8(a, b, c);
1553 }
1554
1555 /*
1556 ** test_qtbx1:
1557 ** tbx v0.8b, {v1.16b}, v2.8b
1558 ** ret
1559 */
1560 mfloat8x8_t test_qtbx1(mfloat8x8_t a, mfloat8x16_t b, uint8x8_t c)
1561 {
1562 return vqtbx1_mf8(a, b, c);
1563 }
1564
1565 /*
1566 ** test_qtbx1q:
1567 ** tbx v0.16b, {v1.16b}, v2.16b
1568 ** ret
1569 */
1570 mfloat8x16_t test_qtbx1q(mfloat8x16_t a, mfloat8x16_t b, uint8x16_t c)
1571 {
1572 return vqtbx1q_mf8(a, b, c);
1573 }
1574
1575 /*
1576 ** test_qtbx2:
1577 ** tbx v0.8b, {v1.16b( - |, )v2.16b}, v3.8b
1578 ** ret
1579 */
1580 mfloat8x8_t test_qtbx2(mfloat8x8_t a, mfloat8x16x2_t b, uint8x8_t c)
1581 {
1582 return vqtbx2_mf8(a, b, c);
1583 }
1584
1585 /*
1586 ** test_qtbx2q:
1587 ** tbx v0.16b, {v1.16b( - |, )v2.16b}, v3.16b
1588 ** ret
1589 */
1590 mfloat8x16_t test_qtbx2q(mfloat8x16_t a, mfloat8x16x2_t b, uint8x16_t c)
1591 {
1592 return vqtbx2q_mf8(a, b, c);
1593 }
1594
1595 /*
1596 ** test_qtbx3:
1597 ** tbx v0.8b, {v1.16b - v3.16b}, v4.8b
1598 ** ret
1599 */
1600 mfloat8x8_t test_qtbx3(mfloat8x8_t a, mfloat8x16x3_t b, uint8x8_t c)
1601 {
1602 return vqtbx3_mf8(a, b, c);
1603 }
1604
1605 /*
1606 ** test_qtbx3q:
1607 ** tbx v0.16b, {v1.16b - v3.16b}, v4.16b
1608 ** ret
1609 */
1610 mfloat8x16_t test_qtbx3q(mfloat8x16_t a, mfloat8x16x3_t b, uint8x16_t c)
1611 {
1612 return vqtbx3q_mf8(a, b, c);
1613 }
1614
1615 /*
1616 ** test_qtbx4:
1617 ** tbx v0.8b, {v1.16b - v4.16b}, v5.8b
1618 ** ret
1619 */
1620 mfloat8x8_t test_qtbx4(mfloat8x8_t a, mfloat8x16x4_t b, uint8x8_t c)
1621 {
1622 return vqtbx4_mf8(a, b, c);
1623 }
1624
1625 /*
1626 ** test_qtbx4q:
1627 ** tbx v0.16b, {v1.16b - v4.16b}, v5.16b
1628 ** ret
1629 */
1630 mfloat8x16_t test_qtbx4q(mfloat8x16_t a, mfloat8x16x4_t b, uint8x16_t c)
1631 {
1632 return vqtbx4q_mf8(a, b, c);
1633 }
1634
1635 /*
1636 ** test_trn:
1637 ** trn1 v0.8b, v2.8b, v3.8b
1638 ** trn2 v1.8b, v2.8b, v3.8b
1639 ** ret
1640 */
1641 mfloat8x8x2_t test_trn(mfloat8_t a, mfloat8_t b, mfloat8x8_t c, mfloat8x8_t d)
1642 {
1643 return vtrn_mf8(c, d);
1644 }
1645
1646 /*
1647 ** test_trnq:
1648 ** trn1 v0.16b, v2.16b, v3.16b
1649 ** trn2 v1.16b, v2.16b, v3.16b
1650 ** ret
1651 */
1652 mfloat8x16x2_t test_trnq(mfloat8_t a, mfloat8_t b,
1653 mfloat8x16_t c, mfloat8x16_t d)
1654 {
1655 return vtrnq_mf8(c, d);
1656 }
1657
1658 /*
1659 ** test_trn1:
1660 ** trn1 v0.8b, v1.8b, v2.8b
1661 ** ret
1662 */
1663 mfloat8x8_t test_trn1(mfloat8_t a, mfloat8x8_t b, mfloat8x8_t c)
1664 {
1665 return vtrn1_mf8(b, c);
1666 }
1667
1668 /*
1669 ** test_trn1q:
1670 ** trn1 v0.16b, v1.16b, v2.16b
1671 ** ret
1672 */
1673 mfloat8x16_t test_trn1q(mfloat8_t a, mfloat8x16_t b, mfloat8x16_t c)
1674 {
1675 return vtrn1q_mf8(b, c);
1676 }
1677
1678 /*
1679 ** test_trn2:
1680 ** trn2 v0.8b, v1.8b, v2.8b
1681 ** ret
1682 */
1683 mfloat8x8_t test_trn2(mfloat8_t a, mfloat8x8_t b, mfloat8x8_t c)
1684 {
1685 return vtrn2_mf8(b, c);
1686 }
1687
1688 /*
1689 ** test_trn2q:
1690 ** trn2 v0.16b, v1.16b, v2.16b
1691 ** ret
1692 */
1693 mfloat8x16_t test_trn2q(mfloat8_t a, mfloat8x16_t b, mfloat8x16_t c)
1694 {
1695 return vtrn2q_mf8(b, c);
1696 }
1697
1698 /*
1699 ** test_uzp:
1700 ** uzp1 v0.8b, v2.8b, v3.8b
1701 ** uzp2 v1.8b, v2.8b, v3.8b
1702 ** ret
1703 */
1704 mfloat8x8x2_t test_uzp(mfloat8_t a, mfloat8_t b, mfloat8x8_t c, mfloat8x8_t d)
1705 {
1706 return vuzp_mf8(c, d);
1707 }
1708
1709 /*
1710 ** test_uzpq:
1711 ** uzp1 v0.16b, v2.16b, v3.16b
1712 ** uzp2 v1.16b, v2.16b, v3.16b
1713 ** ret
1714 */
1715 mfloat8x16x2_t test_uzpq(mfloat8_t a, mfloat8_t b,
1716 mfloat8x16_t c, mfloat8x16_t d)
1717 {
1718 return vuzpq_mf8(c, d);
1719 }
1720
1721 /*
1722 ** test_uzp1:
1723 ** uzp1 v0.8b, v1.8b, v2.8b
1724 ** ret
1725 */
1726 mfloat8x8_t test_uzp1(mfloat8_t a, mfloat8x8_t b, mfloat8x8_t c)
1727 {
1728 return vuzp1_mf8(b, c);
1729 }
1730
1731 /*
1732 ** test_uzp1q:
1733 ** uzp1 v0.16b, v1.16b, v2.16b
1734 ** ret
1735 */
1736 mfloat8x16_t test_uzp1q(mfloat8_t a, mfloat8x16_t b, mfloat8x16_t c)
1737 {
1738 return vuzp1q_mf8(b, c);
1739 }
1740
1741 /*
1742 ** test_uzp2:
1743 ** uzp2 v0.8b, v1.8b, v2.8b
1744 ** ret
1745 */
1746 mfloat8x8_t test_uzp2(mfloat8_t a, mfloat8x8_t b, mfloat8x8_t c)
1747 {
1748 return vuzp2_mf8(b, c);
1749 }
1750
1751 /*
1752 ** test_uzp2q:
1753 ** uzp2 v0.16b, v1.16b, v2.16b
1754 ** ret
1755 */
1756 mfloat8x16_t test_uzp2q(mfloat8_t a, mfloat8x16_t b, mfloat8x16_t c)
1757 {
1758 return vuzp2q_mf8(b, c);
1759 }
1760
1761 /*
1762 ** test_zip:
1763 ** zip1 v0.8b, v2.8b, v3.8b
1764 ** zip2 v1.8b, v2.8b, v3.8b
1765 ** ret
1766 */
1767 mfloat8x8x2_t test_zip(mfloat8_t a, mfloat8_t b, mfloat8x8_t c, mfloat8x8_t d)
1768 {
1769 return vzip_mf8(c, d);
1770 }
1771
1772 /*
1773 ** test_zipq:
1774 ** zip1 v0.16b, v2.16b, v3.16b
1775 ** zip2 v1.16b, v2.16b, v3.16b
1776 ** ret
1777 */
1778 mfloat8x16x2_t test_zipq(mfloat8_t a, mfloat8_t b,
1779 mfloat8x16_t c, mfloat8x16_t d)
1780 {
1781 return vzipq_mf8(c, d);
1782 }
1783
1784 /*
1785 ** test_zip1:
1786 ** zip1 v0.8b, v1.8b, v2.8b
1787 ** ret
1788 */
1789 mfloat8x8_t test_zip1(mfloat8_t a, mfloat8x8_t b, mfloat8x8_t c)
1790 {
1791 return vzip1_mf8(b, c);
1792 }
1793
1794 /*
1795 ** test_zip1q:
1796 ** zip1 v0.16b, v1.16b, v2.16b
1797 ** ret
1798 */
1799 mfloat8x16_t test_zip1q(mfloat8_t a, mfloat8x16_t b, mfloat8x16_t c)
1800 {
1801 return vzip1q_mf8(b, c);
1802 }
1803
1804 /*
1805 ** test_zip2:
1806 ** zip2 v0.8b, v1.8b, v2.8b
1807 ** ret
1808 */
1809 mfloat8x8_t test_zip2(mfloat8_t a, mfloat8x8_t b, mfloat8x8_t c)
1810 {
1811 return vzip2_mf8(b, c);
1812 }
1813
1814 /*
1815 ** test_zip2q:
1816 ** zip2 v0.16b, v1.16b, v2.16b
1817 ** ret
1818 */
1819 mfloat8x16_t test_zip2q(mfloat8_t a, mfloat8x16_t b, mfloat8x16_t c)
1820 {
1821 return vzip2q_mf8(b, c);
1822 }