2 #include "arm-neon-ref.h"
3 #include "compute-ref-data.h"
5 /* We test vdup and vmov in the same place since they are aliases. */
7 /* Expected results. */
9 VECT_VAR_DECL(expected0,int,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
10 0xf0, 0xf0, 0xf0, 0xf0 };
11 VECT_VAR_DECL(expected0,int,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
12 VECT_VAR_DECL(expected0,int,32,2) [] = { 0xfffffff0, 0xfffffff0 };
13 VECT_VAR_DECL(expected0,int,64,1) [] = { 0xfffffffffffffff0 };
14 VECT_VAR_DECL(expected0,uint,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
15 0xf0, 0xf0, 0xf0, 0xf0 };
16 VECT_VAR_DECL(expected0,uint,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
17 VECT_VAR_DECL(expected0,uint,32,2) [] = { 0xfffffff0, 0xfffffff0 };
18 VECT_VAR_DECL(expected0,uint,64,1) [] = { 0xfffffffffffffff0 };
19 VECT_VAR_DECL(expected0,poly,8,8) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
20 0xf0, 0xf0, 0xf0, 0xf0 };
21 VECT_VAR_DECL(expected0,poly,16,4) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
22 VECT_VAR_DECL(expected0,hfloat,32,2) [] = { 0xc1800000, 0xc1800000 };
23 VECT_VAR_DECL(expected0,int,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
24 0xf0, 0xf0, 0xf0, 0xf0,
25 0xf0, 0xf0, 0xf0, 0xf0,
26 0xf0, 0xf0, 0xf0, 0xf0 };
27 VECT_VAR_DECL(expected0,int,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
28 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
29 VECT_VAR_DECL(expected0,int,32,4) [] = { 0xfffffff0, 0xfffffff0,
30 0xfffffff0, 0xfffffff0 };
31 VECT_VAR_DECL(expected0,int,64,2) [] = { 0xfffffffffffffff0,
33 VECT_VAR_DECL(expected0,uint,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
34 0xf0, 0xf0, 0xf0, 0xf0,
35 0xf0, 0xf0, 0xf0, 0xf0,
36 0xf0, 0xf0, 0xf0, 0xf0 };
37 VECT_VAR_DECL(expected0,uint,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
38 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
39 VECT_VAR_DECL(expected0,uint,32,4) [] = { 0xfffffff0, 0xfffffff0,
40 0xfffffff0, 0xfffffff0 };
41 VECT_VAR_DECL(expected0,uint,64,2) [] = { 0xfffffffffffffff0,
43 VECT_VAR_DECL(expected0,poly,8,16) [] = { 0xf0, 0xf0, 0xf0, 0xf0,
44 0xf0, 0xf0, 0xf0, 0xf0,
45 0xf0, 0xf0, 0xf0, 0xf0,
46 0xf0, 0xf0, 0xf0, 0xf0 };
47 VECT_VAR_DECL(expected0,poly,16,8) [] = { 0xfff0, 0xfff0, 0xfff0, 0xfff0,
48 0xfff0, 0xfff0, 0xfff0, 0xfff0 };
49 VECT_VAR_DECL(expected0,hfloat,32,4) [] = { 0xc1800000, 0xc1800000,
50 0xc1800000, 0xc1800000 };
53 VECT_VAR_DECL(expected1,int,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
54 0xf1, 0xf1, 0xf1, 0xf1 };
55 VECT_VAR_DECL(expected1,int,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
56 VECT_VAR_DECL(expected1,int,32,2) [] = { 0xfffffff1, 0xfffffff1 };
57 VECT_VAR_DECL(expected1,int,64,1) [] = { 0xfffffffffffffff1 };
58 VECT_VAR_DECL(expected1,uint,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
59 0xf1, 0xf1, 0xf1, 0xf1 };
60 VECT_VAR_DECL(expected1,uint,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
61 VECT_VAR_DECL(expected1,uint,32,2) [] = { 0xfffffff1, 0xfffffff1 };
62 VECT_VAR_DECL(expected1,uint,64,1) [] = { 0xfffffffffffffff1 };
63 VECT_VAR_DECL(expected1,poly,8,8) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
64 0xf1, 0xf1, 0xf1, 0xf1 };
65 VECT_VAR_DECL(expected1,poly,16,4) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
66 VECT_VAR_DECL(expected1,hfloat,32,2) [] = { 0xc1700000, 0xc1700000 };
67 VECT_VAR_DECL(expected1,int,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
68 0xf1, 0xf1, 0xf1, 0xf1,
69 0xf1, 0xf1, 0xf1, 0xf1,
70 0xf1, 0xf1, 0xf1, 0xf1 };
71 VECT_VAR_DECL(expected1,int,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
72 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
73 VECT_VAR_DECL(expected1,int,32,4) [] = { 0xfffffff1, 0xfffffff1,
74 0xfffffff1, 0xfffffff1 };
75 VECT_VAR_DECL(expected1,int,64,2) [] = { 0xfffffffffffffff1,
77 VECT_VAR_DECL(expected1,uint,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
78 0xf1, 0xf1, 0xf1, 0xf1,
79 0xf1, 0xf1, 0xf1, 0xf1,
80 0xf1, 0xf1, 0xf1, 0xf1 };
81 VECT_VAR_DECL(expected1,uint,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
82 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
83 VECT_VAR_DECL(expected1,uint,32,4) [] = { 0xfffffff1, 0xfffffff1,
84 0xfffffff1, 0xfffffff1 };
85 VECT_VAR_DECL(expected1,uint,64,2) [] = { 0xfffffffffffffff1,
87 VECT_VAR_DECL(expected1,poly,8,16) [] = { 0xf1, 0xf1, 0xf1, 0xf1,
88 0xf1, 0xf1, 0xf1, 0xf1,
89 0xf1, 0xf1, 0xf1, 0xf1,
90 0xf1, 0xf1, 0xf1, 0xf1 };
91 VECT_VAR_DECL(expected1,poly,16,8) [] = { 0xfff1, 0xfff1, 0xfff1, 0xfff1,
92 0xfff1, 0xfff1, 0xfff1, 0xfff1 };
93 VECT_VAR_DECL(expected1,hfloat,32,4) [] = { 0xc1700000, 0xc1700000,
94 0xc1700000, 0xc1700000 };
97 VECT_VAR_DECL(expected2,int,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
98 0xf2, 0xf2, 0xf2, 0xf2 };
99 VECT_VAR_DECL(expected2,int,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
100 VECT_VAR_DECL(expected2,int,32,2) [] = { 0xfffffff2, 0xfffffff2 };
101 VECT_VAR_DECL(expected2,int,64,1) [] = { 0xfffffffffffffff2 };
102 VECT_VAR_DECL(expected2,uint,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
103 0xf2, 0xf2, 0xf2, 0xf2 };
104 VECT_VAR_DECL(expected2,uint,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
105 VECT_VAR_DECL(expected2,uint,32,2) [] = { 0xfffffff2, 0xfffffff2 };
106 VECT_VAR_DECL(expected2,uint,64,1) [] = { 0xfffffffffffffff2 };
107 VECT_VAR_DECL(expected2,poly,8,8) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
108 0xf2, 0xf2, 0xf2, 0xf2 };
109 VECT_VAR_DECL(expected2,poly,16,4) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
110 VECT_VAR_DECL(expected2,hfloat,32,2) [] = { 0xc1600000, 0xc1600000 };
111 VECT_VAR_DECL(expected2,int,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
112 0xf2, 0xf2, 0xf2, 0xf2,
113 0xf2, 0xf2, 0xf2, 0xf2,
114 0xf2, 0xf2, 0xf2, 0xf2 };
115 VECT_VAR_DECL(expected2,int,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
116 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
117 VECT_VAR_DECL(expected2,int,32,4) [] = { 0xfffffff2, 0xfffffff2,
118 0xfffffff2, 0xfffffff2 };
119 VECT_VAR_DECL(expected2,int,64,2) [] = { 0xfffffffffffffff2,
120 0xfffffffffffffff2 };
121 VECT_VAR_DECL(expected2,uint,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
122 0xf2, 0xf2, 0xf2, 0xf2,
123 0xf2, 0xf2, 0xf2, 0xf2,
124 0xf2, 0xf2, 0xf2, 0xf2 };
125 VECT_VAR_DECL(expected2,uint,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
126 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
127 VECT_VAR_DECL(expected2,uint,32,4) [] = { 0xfffffff2, 0xfffffff2,
128 0xfffffff2, 0xfffffff2 };
129 VECT_VAR_DECL(expected2,uint,64,2) [] = { 0xfffffffffffffff2,
130 0xfffffffffffffff2 };
131 VECT_VAR_DECL(expected2,poly,8,16) [] = { 0xf2, 0xf2, 0xf2, 0xf2,
132 0xf2, 0xf2, 0xf2, 0xf2,
133 0xf2, 0xf2, 0xf2, 0xf2,
134 0xf2, 0xf2, 0xf2, 0xf2 };
135 VECT_VAR_DECL(expected2,poly,16,8) [] = { 0xfff2, 0xfff2, 0xfff2, 0xfff2,
136 0xfff2, 0xfff2, 0xfff2, 0xfff2 };
137 VECT_VAR_DECL(expected2,hfloat,32,4) [] = { 0xc1600000, 0xc1600000,
138 0xc1600000, 0xc1600000 };
140 #define TEST_MSG "VDUP/VDUPQ"
141 void exec_vdup_vmov (void)
145 /* Basic test: vec=vdup(x), then store the result. */
147 #define TEST_VDUP(Q, T1, T2, W, N) \
148 VECT_VAR(vector, T1, W, N) = \
149 vdup##Q##_n_##T2##W(VECT_VAR(buffer_dup, T1, W, N)[i]); \
150 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector, T1, W, N))
152 /* Basic test: vec=vmov(x), then store the result. */
153 #define TEST_VMOV(Q, T1, T2, W, N) \
154 VECT_VAR(vector, T1, W, N) = \
155 vmov##Q##_n_##T2##W(VECT_VAR(buffer_dup, T1, W, N)[i]); \
156 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector, T1, W, N))
158 DECL_VARIABLE_ALL_VARIANTS(vector);
160 /* Try to read different places from the input buffer. */
161 for (i=0; i< 3; i++) {
164 TEST_VDUP(, int, s, 8, 8);
165 TEST_VDUP(, int, s, 16, 4);
166 TEST_VDUP(, int, s, 32, 2);
167 TEST_VDUP(, int, s, 64, 1);
168 TEST_VDUP(, uint, u, 8, 8);
169 TEST_VDUP(, uint, u, 16, 4);
170 TEST_VDUP(, uint, u, 32, 2);
171 TEST_VDUP(, uint, u, 64, 1);
172 TEST_VDUP(, poly, p, 8, 8);
173 TEST_VDUP(, poly, p, 16, 4);
174 TEST_VDUP(, float, f, 32, 2);
176 TEST_VDUP(q, int, s, 8, 16);
177 TEST_VDUP(q, int, s, 16, 8);
178 TEST_VDUP(q, int, s, 32, 4);
179 TEST_VDUP(q, int, s, 64, 2);
180 TEST_VDUP(q, uint, u, 8, 16);
181 TEST_VDUP(q, uint, u, 16, 8);
182 TEST_VDUP(q, uint, u, 32, 4);
183 TEST_VDUP(q, uint, u, 64, 2);
184 TEST_VDUP(q, poly, p, 8, 16);
185 TEST_VDUP(q, poly, p, 16, 8);
186 TEST_VDUP(q, float, f, 32, 4);
190 CHECK_RESULTS_NAMED (TEST_MSG, expected0, "");
193 CHECK_RESULTS_NAMED (TEST_MSG, expected1, "");
196 CHECK_RESULTS_NAMED (TEST_MSG, expected2, "");
203 /* Do the same tests with vmov. Use the same expected results. */
205 #define TEST_MSG "VMOV/VMOVQ"
206 for (i=0; i< 3; i++) {
209 TEST_VMOV(, int, s, 8, 8);
210 TEST_VMOV(, int, s, 16, 4);
211 TEST_VMOV(, int, s, 32, 2);
212 TEST_VMOV(, int, s, 64, 1);
213 TEST_VMOV(, uint, u, 8, 8);
214 TEST_VMOV(, uint, u, 16, 4);
215 TEST_VMOV(, uint, u, 32, 2);
216 TEST_VMOV(, uint, u, 64, 1);
217 TEST_VMOV(, poly, p, 8, 8);
218 TEST_VMOV(, poly, p, 16, 4);
219 TEST_VMOV(, float, f, 32, 2);
221 TEST_VMOV(q, int, s, 8, 16);
222 TEST_VMOV(q, int, s, 16, 8);
223 TEST_VMOV(q, int, s, 32, 4);
224 TEST_VMOV(q, int, s, 64, 2);
225 TEST_VMOV(q, uint, u, 8, 16);
226 TEST_VMOV(q, uint, u, 16, 8);
227 TEST_VMOV(q, uint, u, 32, 4);
228 TEST_VMOV(q, uint, u, 64, 2);
229 TEST_VMOV(q, poly, p, 8, 16);
230 TEST_VMOV(q, poly, p, 16, 8);
231 TEST_VMOV(q, float, f, 32, 4);
235 CHECK_RESULTS_NAMED (TEST_MSG, expected0, "");
238 CHECK_RESULTS_NAMED (TEST_MSG, expected1, "");
241 CHECK_RESULTS_NAMED (TEST_MSG, expected2, "");