Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vld1_dup.c

raw
1 #include <arm_neon.h>
2 #include "arm-neon-ref.h"
3 #include "compute-ref-data.h"
4
5 /* Expected results. */
6 /* Chunk 0. */
7 VECT_VAR_DECL(expected0,int,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
8 0xf0, 0xf0, 0xf0, 0xf0 };
9 VECT_VAR_DECL(expected0,int,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
10 VECT_VAR_DECL(expected0,int,32,2) [] = { 0xfffffff0, 0xfffffff0 };
11 VECT_VAR_DECL(expected0,int,64,1) [] = { 0xfffffffffffffff0 };
12 VECT_VAR_DECL(expected0,uint,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
13 0xf0, 0xf0, 0xf0, 0xf0 };
14 VECT_VAR_DECL(expected0,uint,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
15 VECT_VAR_DECL(expected0,uint,32,2) [] = { 0xfffffff0, 0xfffffff0 };
16 VECT_VAR_DECL(expected0,uint,64,1) [] = { 0xfffffffffffffff0 };
17 VECT_VAR_DECL(expected0,poly,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
18 0xf0, 0xf0, 0xf0, 0xf0 };
19 VECT_VAR_DECL(expected0,poly,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
20 #if MFLOAT8_SUPPORTED
21 VECT_VAR_DECL(expected0,hmfloat,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
22 0xf0, 0xf0, 0xf0, 0xf0 };
23 #endif
24 VECT_VAR_DECL(expected0,hfloat,16,4) [] = { 0xcc00, 0xcc00, 0xcc00, 0xcc00 };
25 VECT_VAR_DECL(expected0,hfloat,32,2) [] = { 0xc1800000, 0xc1800000 };
26 VECT_VAR_DECL(expected0,int,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
27 0xf0, 0xf0, 0xf0, 0xf0,
28 0xf0, 0xf0, 0xf0, 0xf0,
29 0xf0, 0xf0, 0xf0, 0xf0 };
30 VECT_VAR_DECL(expected0,int,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
31 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
32 VECT_VAR_DECL(expected0,int,32,4) [] = { 0xfffffff0, 0xfffffff0,
33 0xfffffff0, 0xfffffff0 };
34 VECT_VAR_DECL(expected0,int,64,2) [] = { 0xfffffffffffffff0,
35 0xfffffffffffffff0 };
36 VECT_VAR_DECL(expected0,uint,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
37 0xf0, 0xf0, 0xf0, 0xf0,
38 0xf0, 0xf0, 0xf0, 0xf0,
39 0xf0, 0xf0, 0xf0, 0xf0 };
40 VECT_VAR_DECL(expected0,uint,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
41 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
42 VECT_VAR_DECL(expected0,uint,32,4) [] = { 0xfffffff0, 0xfffffff0,
43 0xfffffff0, 0xfffffff0 };
44 VECT_VAR_DECL(expected0,uint,64,2) [] = { 0xfffffffffffffff0,
45 0xfffffffffffffff0 };
46 VECT_VAR_DECL(expected0,poly,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
47 0xf0, 0xf0, 0xf0, 0xf0,
48 0xf0, 0xf0, 0xf0, 0xf0,
49 0xf0, 0xf0, 0xf0, 0xf0 };
50 VECT_VAR_DECL(expected0,poly,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
51 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
52 #if MFLOAT8_SUPPORTED
53 VECT_VAR_DECL(expected0,hmfloat,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
54 0xf0, 0xf0, 0xf0, 0xf0,
55 0xf0, 0xf0, 0xf0, 0xf0,
56 0xf0, 0xf0, 0xf0, 0xf0 };
57 #endif
58 VECT_VAR_DECL(expected0,hfloat,16,8) [] = { 0xcc00, 0xcc00, 0xcc00, 0xcc00,
59 0xcc00, 0xcc00, 0xcc00, 0xcc00 };
60 VECT_VAR_DECL(expected0,hfloat,32,4) [] = { 0xc1800000, 0xc1800000,
61 0xc1800000, 0xc1800000 };
62
63 /* Chunk 1. */
64 VECT_VAR_DECL(expected1,int,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
65 0xf1, 0xf1, 0xf1, 0xf1 };
66 VECT_VAR_DECL(expected1,int,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
67 VECT_VAR_DECL(expected1,int,32,2) [] = { 0xfffffff1, 0xfffffff1 };
68 VECT_VAR_DECL(expected1,int,64,1) [] = { 0xfffffffffffffff1 };
69 VECT_VAR_DECL(expected1,uint,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
70 0xf1, 0xf1, 0xf1, 0xf1 };
71 VECT_VAR_DECL(expected1,uint,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
72 VECT_VAR_DECL(expected1,uint,32,2) [] = { 0xfffffff1, 0xfffffff1 };
73 VECT_VAR_DECL(expected1,uint,64,1) [] = { 0xfffffffffffffff1 };
74 VECT_VAR_DECL(expected1,poly,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
75 0xf1, 0xf1, 0xf1, 0xf1 };
76 VECT_VAR_DECL(expected1,poly,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
77 #if MFLOAT8_SUPPORTED
78 VECT_VAR_DECL(expected1,hmfloat,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
79 0xf1, 0xf1, 0xf1, 0xf1 };
80 #endif
81 VECT_VAR_DECL(expected1,hfloat,16,4) [] = { 0xcb80, 0xcb80, 0xcb80, 0xcb80 };
82 VECT_VAR_DECL(expected1,hfloat,32,2) [] = { 0xc1700000, 0xc1700000 };
83 VECT_VAR_DECL(expected1,int,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
84 0xf1, 0xf1, 0xf1, 0xf1,
85 0xf1, 0xf1, 0xf1, 0xf1,
86 0xf1, 0xf1, 0xf1, 0xf1 };
87 VECT_VAR_DECL(expected1,int,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
88 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
89 VECT_VAR_DECL(expected1,int,32,4) [] = { 0xfffffff1, 0xfffffff1,
90 0xfffffff1, 0xfffffff1 };
91 VECT_VAR_DECL(expected1,int,64,2) [] = { 0xfffffffffffffff1,
92 0xfffffffffffffff1 };
93 VECT_VAR_DECL(expected1,uint,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
94 0xf1, 0xf1, 0xf1, 0xf1,
95 0xf1, 0xf1, 0xf1, 0xf1,
96 0xf1, 0xf1, 0xf1, 0xf1 };
97 VECT_VAR_DECL(expected1,uint,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
98 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
99 VECT_VAR_DECL(expected1,uint,32,4) [] = { 0xfffffff1, 0xfffffff1,
100 0xfffffff1, 0xfffffff1 };
101 VECT_VAR_DECL(expected1,uint,64,2) [] = { 0xfffffffffffffff1,
102 0xfffffffffffffff1 };
103 VECT_VAR_DECL(expected1,poly,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
104 0xf1, 0xf1, 0xf1, 0xf1,
105 0xf1, 0xf1, 0xf1, 0xf1,
106 0xf1, 0xf1, 0xf1, 0xf1 };
107 VECT_VAR_DECL(expected1,poly,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
108 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
109 #if MFLOAT8_SUPPORTED
110 VECT_VAR_DECL(expected1,hmfloat,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
111 0xf1, 0xf1, 0xf1, 0xf1,
112 0xf1, 0xf1, 0xf1, 0xf1,
113 0xf1, 0xf1, 0xf1, 0xf1 };
114 #endif
115 VECT_VAR_DECL(expected1,hfloat,16,8) [] = { 0xcb80, 0xcb80, 0xcb80, 0xcb80,
116 0xcb80, 0xcb80, 0xcb80, 0xcb80 };
117 VECT_VAR_DECL(expected1,hfloat,32,4) [] = { 0xc1700000, 0xc1700000,
118 0xc1700000, 0xc1700000 };
119
120 /* Chunk 2. */
121 VECT_VAR_DECL(expected2,int,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
122 0xf2, 0xf2, 0xf2, 0xf2 };
123 VECT_VAR_DECL(expected2,int,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
124 VECT_VAR_DECL(expected2,int,32,2) [] = { 0xfffffff2, 0xfffffff2 };
125 VECT_VAR_DECL(expected2,int,64,1) [] = { 0xfffffffffffffff2 };
126 VECT_VAR_DECL(expected2,uint,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
127 0xf2, 0xf2, 0xf2, 0xf2 };
128 VECT_VAR_DECL(expected2,uint,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
129 VECT_VAR_DECL(expected2,uint,32,2) [] = { 0xfffffff2, 0xfffffff2 };
130 VECT_VAR_DECL(expected2,uint,64,1) [] = { 0xfffffffffffffff2 };
131 VECT_VAR_DECL(expected2,poly,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
132 0xf2, 0xf2, 0xf2, 0xf2 };
133 VECT_VAR_DECL(expected2,poly,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
134 #if MFLOAT8_SUPPORTED
135 VECT_VAR_DECL(expected2,hmfloat,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
136 0xf2, 0xf2, 0xf2, 0xf2 };
137 #endif
138 VECT_VAR_DECL(expected2,hfloat,16,4) [] = { 0xcb00, 0xcb00, 0xcb00, 0xcb00 };
139 VECT_VAR_DECL(expected2,hfloat,32,2) [] = { 0xc1600000, 0xc1600000 };
140 VECT_VAR_DECL(expected2,int,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
141 0xf2, 0xf2, 0xf2, 0xf2,
142 0xf2, 0xf2, 0xf2, 0xf2,
143 0xf2, 0xf2, 0xf2, 0xf2 };
144 VECT_VAR_DECL(expected2,int,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
145 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
146 VECT_VAR_DECL(expected2,int,32,4) [] = { 0xfffffff2, 0xfffffff2,
147 0xfffffff2, 0xfffffff2 };
148 VECT_VAR_DECL(expected2,int,64,2) [] = { 0xfffffffffffffff2,
149 0xfffffffffffffff2 };
150 VECT_VAR_DECL(expected2,uint,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
151 0xf2, 0xf2, 0xf2, 0xf2,
152 0xf2, 0xf2, 0xf2, 0xf2,
153 0xf2, 0xf2, 0xf2, 0xf2 };
154 VECT_VAR_DECL(expected2,uint,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
155 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
156 VECT_VAR_DECL(expected2,uint,32,4) [] = { 0xfffffff2, 0xfffffff2,
157 0xfffffff2, 0xfffffff2 };
158 VECT_VAR_DECL(expected2,uint,64,2) [] = { 0xfffffffffffffff2,
159 0xfffffffffffffff2 };
160 VECT_VAR_DECL(expected2,poly,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
161 0xf2, 0xf2, 0xf2, 0xf2,
162 0xf2, 0xf2, 0xf2, 0xf2,
163 0xf2, 0xf2, 0xf2, 0xf2 };
164 VECT_VAR_DECL(expected2,poly,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
165 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
166 #if MFLOAT8_SUPPORTED
167 VECT_VAR_DECL(expected2,hmfloat,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
168 0xf2, 0xf2, 0xf2, 0xf2,
169 0xf2, 0xf2, 0xf2, 0xf2,
170 0xf2, 0xf2, 0xf2, 0xf2 };
171 #endif
172 VECT_VAR_DECL(expected2,hfloat,16,8) [] = { 0xcb00, 0xcb00, 0xcb00, 0xcb00,
173 0xcb00, 0xcb00, 0xcb00, 0xcb00 };
174 VECT_VAR_DECL(expected2,hfloat,32,4) [] = { 0xc1600000, 0xc1600000,
175 0xc1600000, 0xc1600000 };
176
177 #define TEST_MSG "VLD1_DUP/VLD1_DUPQ"
178 void exec_vld1_dup (void)
179 {
180 int i;
181
182 /* Fill vector with buffer item #i. */
183 #define TEST_VLD1_DUP(VAR, BUF, Q, T1, T2, W, N) \
184 VECT_VAR(VAR, T1, W, N) = \
185 vld1##Q##_dup_##T2##W(&VECT_VAR(BUF, T1, W, N)[i]); \
186 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(VAR, T1, W, N))
187
188 DECL_VARIABLE_ALL_VARIANTS(vector);
189
190 /* Try to read different places from the input buffer. */
191 for (i=0; i<3; i++) {
192 clean_results ();
193
194 TEST_MACRO_ALL_VARIANTS_2_5(TEST_VLD1_DUP, vector, buffer_dup);
195
196 #if MFLOAT8_SUPPORTED
197 TEST_VLD1_DUP(vector, buffer_dup, , mfloat, mf, 8, 8);
198 TEST_VLD1_DUP(vector, buffer_dup, q, mfloat, mf, 8, 16);
199 #endif
200 #if defined (__ARM_FP16_FORMAT_IEEE) || defined (__ARM_FP16_FORMAT_ALTERNATIVE)
201 TEST_VLD1_DUP(vector, buffer_dup, , float, f, 16, 4);
202 TEST_VLD1_DUP(vector, buffer_dup, q, float, f, 16, 8);
203 #endif
204 TEST_VLD1_DUP(vector, buffer_dup, , float, f, 32, 2);
205 TEST_VLD1_DUP(vector, buffer_dup, q, float, f, 32, 4);
206
207 switch (i) {
208 case 0:
209 CHECK_RESULTS_NAMED (TEST_MSG, expected0, "");
210 break;
211 case 1:
212 CHECK_RESULTS_NAMED (TEST_MSG, expected1, "");
213 break;
214 case 2:
215 CHECK_RESULTS_NAMED (TEST_MSG, expected2, "");
216 break;
217 default:
218 abort();
219 }
220 }
221 }
222
223 int main (void)
224 {
225 exec_vld1_dup ();
226 return 0;
227 }