|
173
|
1 // RUN: %clang_cc1 -triple thumbv8.1m.main-none-none-eabi -fallow-half-arguments-and-returns -target-feature +mve.fp -verify -fsyntax-only %s
|
|
150
|
2
|
|
|
3 #include <arm_mve.h>
|
|
|
4
|
|
|
5 void test_load_offsets(uint32x4_t addr32, uint64x2_t addr64)
|
|
|
6 {
|
|
|
7 // Offsets that should be a multiple of 8 times 0,1,...,127
|
|
|
8 vldrdq_gather_base_s64(addr64, 0);
|
|
|
9 vldrdq_gather_base_s64(addr64, 8);
|
|
|
10 vldrdq_gather_base_s64(addr64, 2*8);
|
|
|
11 vldrdq_gather_base_s64(addr64, 125*8);
|
|
|
12 vldrdq_gather_base_s64(addr64, 126*8);
|
|
|
13 vldrdq_gather_base_s64(addr64, 127*8);
|
|
|
14 vldrdq_gather_base_s64(addr64, -125*8);
|
|
|
15 vldrdq_gather_base_s64(addr64, -126*8);
|
|
|
16 vldrdq_gather_base_s64(addr64, -127*8);
|
|
|
17 vldrdq_gather_base_s64(addr64, 128*8); // expected-error {{argument value 1024 is outside the valid range [-1016, 1016]}}
|
|
|
18 vldrdq_gather_base_s64(addr64, -128*8); // expected-error {{argument value -1024 is outside the valid range [-1016, 1016]}}
|
|
|
19 vldrdq_gather_base_s64(addr64, 4); // expected-error {{argument should be a multiple of 8}}
|
|
|
20 vldrdq_gather_base_s64(addr64, 1); // expected-error {{argument should be a multiple of 8}}
|
|
|
21
|
|
|
22 // Offsets that should be a multiple of 4 times 0,1,...,127
|
|
|
23 vldrwq_gather_base_s32(addr32, 0);
|
|
|
24 vldrwq_gather_base_s32(addr32, 4);
|
|
|
25 vldrwq_gather_base_s32(addr32, 2*4);
|
|
|
26 vldrwq_gather_base_s32(addr32, 125*4);
|
|
|
27 vldrwq_gather_base_s32(addr32, 126*4);
|
|
|
28 vldrwq_gather_base_s32(addr32, 127*4);
|
|
|
29 vldrwq_gather_base_s32(addr32, -125*4);
|
|
|
30 vldrwq_gather_base_s32(addr32, -126*4);
|
|
|
31 vldrwq_gather_base_s32(addr32, -127*4);
|
|
|
32 vldrwq_gather_base_s32(addr32, 128*4); // expected-error {{argument value 512 is outside the valid range [-508, 508]}}
|
|
|
33 vldrwq_gather_base_s32(addr32, -128*4); // expected-error {{argument value -512 is outside the valid range [-508, 508]}}
|
|
|
34 vldrwq_gather_base_s32(addr32, 2); // expected-error {{argument should be a multiple of 4}}
|
|
|
35 vldrwq_gather_base_s32(addr32, 1); // expected-error {{argument should be a multiple of 4}}
|
|
|
36
|
|
|
37 // Show that the polymorphic store intrinsics get the right set of
|
|
|
38 // error checks after overload resolution. These ones expand to the
|
|
|
39 // 8-byte granular versions...
|
|
|
40 vstrdq_scatter_base(addr64, 0, addr64);
|
|
|
41 vstrdq_scatter_base(addr64, 8, addr64);
|
|
|
42 vstrdq_scatter_base(addr64, 2*8, addr64);
|
|
|
43 vstrdq_scatter_base(addr64, 125*8, addr64);
|
|
|
44 vstrdq_scatter_base(addr64, 126*8, addr64);
|
|
|
45 vstrdq_scatter_base(addr64, 127*8, addr64);
|
|
|
46 vstrdq_scatter_base(addr64, -125*8, addr64);
|
|
|
47 vstrdq_scatter_base(addr64, -126*8, addr64);
|
|
|
48 vstrdq_scatter_base(addr64, -127*8, addr64);
|
|
|
49 vstrdq_scatter_base(addr64, 128*8, addr64); // expected-error {{argument value 1024 is outside the valid range [-1016, 1016]}}
|
|
|
50 vstrdq_scatter_base(addr64, -128*8, addr64); // expected-error {{argument value -1024 is outside the valid range [-1016, 1016]}}
|
|
|
51 vstrdq_scatter_base(addr64, 4, addr64); // expected-error {{argument should be a multiple of 8}}
|
|
|
52 vstrdq_scatter_base(addr64, 1, addr64); // expected-error {{argument should be a multiple of 8}}
|
|
|
53
|
|
|
54 /// ... and these ones to the 4-byte.
|
|
|
55 vstrwq_scatter_base(addr32, 0, addr32);
|
|
|
56 vstrwq_scatter_base(addr32, 4, addr32);
|
|
|
57 vstrwq_scatter_base(addr32, 2*4, addr32);
|
|
|
58 vstrwq_scatter_base(addr32, 125*4, addr32);
|
|
|
59 vstrwq_scatter_base(addr32, 126*4, addr32);
|
|
|
60 vstrwq_scatter_base(addr32, 127*4, addr32);
|
|
|
61 vstrwq_scatter_base(addr32, -125*4, addr32);
|
|
|
62 vstrwq_scatter_base(addr32, -126*4, addr32);
|
|
|
63 vstrwq_scatter_base(addr32, -127*4, addr32);
|
|
|
64 vstrwq_scatter_base(addr32, 128*4, addr32); // expected-error {{argument value 512 is outside the valid range [-508, 508]}}
|
|
|
65 vstrwq_scatter_base(addr32, -128*4, addr32); // expected-error {{argument value -512 is outside the valid range [-508, 508]}}
|
|
|
66 vstrwq_scatter_base(addr32, 2, addr32); // expected-error {{argument should be a multiple of 4}}
|
|
|
67 vstrwq_scatter_base(addr32, 1, addr32); // expected-error {{argument should be a multiple of 4}}
|
|
|
68 }
|
|
|
69
|
|
|
70 void test_lane_indices(uint8x16_t v16, uint16x8_t v8,
|
|
|
71 uint32x4_t v4, uint64x2_t v2)
|
|
|
72 {
|
|
|
73 vgetq_lane_u8(v16, -1); // expected-error {{argument value -1 is outside the valid range [0, 15]}}
|
|
|
74 vgetq_lane_u8(v16, 0);
|
|
|
75 vgetq_lane_u8(v16, 15);
|
|
|
76 vgetq_lane_u8(v16, 16); // expected-error {{argument value 16 is outside the valid range [0, 15]}}
|
|
|
77
|
|
|
78 vgetq_lane_u16(v8, -1); // expected-error {{argument value -1 is outside the valid range [0, 7]}}
|
|
|
79 vgetq_lane_u16(v8, 0);
|
|
|
80 vgetq_lane_u16(v8, 7);
|
|
|
81 vgetq_lane_u16(v8, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
|
|
|
82
|
|
|
83 vgetq_lane_u32(v4, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
|
|
|
84 vgetq_lane_u32(v4, 0);
|
|
|
85 vgetq_lane_u32(v4, 3);
|
|
|
86 vgetq_lane_u32(v4, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
|
|
|
87
|
|
|
88 vgetq_lane_u64(v2, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
|
|
|
89 vgetq_lane_u64(v2, 0);
|
|
|
90 vgetq_lane_u64(v2, 1);
|
|
|
91 vgetq_lane_u64(v2, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
|
|
|
92
|
|
|
93 vsetq_lane_u8(23, v16, -1); // expected-error {{argument value -1 is outside the valid range [0, 15]}}
|
|
|
94 vsetq_lane_u8(23, v16, 0);
|
|
|
95 vsetq_lane_u8(23, v16, 15);
|
|
|
96 vsetq_lane_u8(23, v16, 16); // expected-error {{argument value 16 is outside the valid range [0, 15]}}
|
|
|
97
|
|
|
98 vsetq_lane_u16(23, v8, -1); // expected-error {{argument value -1 is outside the valid range [0, 7]}}
|
|
|
99 vsetq_lane_u16(23, v8, 0);
|
|
|
100 vsetq_lane_u16(23, v8, 7);
|
|
|
101 vsetq_lane_u16(23, v8, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
|
|
|
102
|
|
|
103 vsetq_lane_u32(23, v4, -1); // expected-error {{argument value -1 is outside the valid range [0, 3]}}
|
|
|
104 vsetq_lane_u32(23, v4, 0);
|
|
|
105 vsetq_lane_u32(23, v4, 3);
|
|
|
106 vsetq_lane_u32(23, v4, 4); // expected-error {{argument value 4 is outside the valid range [0, 3]}}
|
|
|
107
|
|
|
108 vsetq_lane_u64(23, v2, -1); // expected-error {{argument value -1 is outside the valid range [0, 1]}}
|
|
|
109 vsetq_lane_u64(23, v2, 0);
|
|
|
110 vsetq_lane_u64(23, v2, 1);
|
|
|
111 vsetq_lane_u64(23, v2, 2); // expected-error {{argument value 2 is outside the valid range [0, 1]}}
|
|
|
112 }
|
|
|
113
|
|
|
114 void test_immediate_shifts(uint8x16_t vb, uint16x8_t vh, uint32x4_t vw)
|
|
|
115 {
|
|
|
116 vshlq_n(vb, 0);
|
|
|
117 vshlq_n(vb, 7);
|
|
|
118 vshlq_n(vh, 0);
|
|
|
119 vshlq_n(vh, 15);
|
|
|
120 vshlq_n(vw, 0);
|
|
|
121 vshlq_n(vw, 31);
|
|
|
122
|
|
|
123 vshlq_n(vb, -1); // expected-error {{argument value -1 is outside the valid range [0, 7]}}
|
|
|
124 vshlq_n(vb, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
|
|
|
125 vshlq_n(vh, -1); // expected-error {{argument value -1 is outside the valid range [0, 15]}}
|
|
|
126 vshlq_n(vh, 16); // expected-error {{argument value 16 is outside the valid range [0, 15]}}
|
|
|
127 vshlq_n(vw, -1); // expected-error {{argument value -1 is outside the valid range [0, 31]}}
|
|
|
128 vshlq_n(vw, 32); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
|
|
|
129
|
|
|
130 vqshlq_n(vb, 0);
|
|
|
131 vqshlq_n(vb, 7);
|
|
|
132 vqshlq_n(vh, 0);
|
|
|
133 vqshlq_n(vh, 15);
|
|
|
134 vqshlq_n(vw, 0);
|
|
|
135 vqshlq_n(vw, 31);
|
|
|
136
|
|
|
137 vqshlq_n(vb, -1); // expected-error {{argument value -1 is outside the valid range [0, 7]}}
|
|
|
138 vqshlq_n(vb, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
|
|
|
139 vqshlq_n(vh, -1); // expected-error {{argument value -1 is outside the valid range [0, 15]}}
|
|
|
140 vqshlq_n(vh, 16); // expected-error {{argument value 16 is outside the valid range [0, 15]}}
|
|
|
141 vqshlq_n(vw, -1); // expected-error {{argument value -1 is outside the valid range [0, 31]}}
|
|
|
142 vqshlq_n(vw, 32); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
|
|
|
143
|
|
|
144 vsliq(vb, vb, 0);
|
|
|
145 vsliq(vb, vb, 7);
|
|
|
146 vsliq(vh, vh, 0);
|
|
|
147 vsliq(vh, vh, 15);
|
|
|
148 vsliq(vw, vw, 0);
|
|
|
149 vsliq(vw, vw, 31);
|
|
|
150
|
|
|
151 vsliq(vb, vb, -1); // expected-error {{argument value -1 is outside the valid range [0, 7]}}
|
|
|
152 vsliq(vb, vb, 8); // expected-error {{argument value 8 is outside the valid range [0, 7]}}
|
|
|
153 vsliq(vh, vh, -1); // expected-error {{argument value -1 is outside the valid range [0, 15]}}
|
|
|
154 vsliq(vh, vh, 16); // expected-error {{argument value 16 is outside the valid range [0, 15]}}
|
|
|
155 vsliq(vw, vw, -1); // expected-error {{argument value -1 is outside the valid range [0, 31]}}
|
|
|
156 vsliq(vw, vw, 32); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
|
|
|
157
|
|
|
158 vshllbq(vb, 1);
|
|
|
159 vshllbq(vb, 8);
|
|
|
160 vshllbq(vh, 1);
|
|
|
161 vshllbq(vh, 16);
|
|
|
162
|
|
|
163 vshllbq(vb, 0); // expected-error {{argument value 0 is outside the valid range [1, 8]}}
|
|
|
164 vshllbq(vb, 9); // expected-error {{argument value 9 is outside the valid range [1, 8]}}
|
|
|
165 vshllbq(vh, 0); // expected-error {{argument value 0 is outside the valid range [1, 16]}}
|
|
|
166 vshllbq(vh, 17); // expected-error {{argument value 17 is outside the valid range [1, 16]}}
|
|
|
167
|
|
|
168 vshrq(vb, 1);
|
|
|
169 vshrq(vb, 8);
|
|
|
170 vshrq(vh, 1);
|
|
|
171 vshrq(vh, 16);
|
|
|
172 vshrq(vw, 1);
|
|
|
173 vshrq(vw, 32);
|
|
|
174
|
|
|
175 vshrq(vb, 0); // expected-error {{argument value 0 is outside the valid range [1, 8]}}
|
|
|
176 vshrq(vb, 9); // expected-error {{argument value 9 is outside the valid range [1, 8]}}
|
|
|
177 vshrq(vh, 0); // expected-error {{argument value 0 is outside the valid range [1, 16]}}
|
|
|
178 vshrq(vh, 17); // expected-error {{argument value 17 is outside the valid range [1, 16]}}
|
|
|
179 vshrq(vw, 0); // expected-error {{argument value 0 is outside the valid range [1, 32]}}
|
|
|
180 vshrq(vw, 33); // expected-error {{argument value 33 is outside the valid range [1, 32]}}
|
|
|
181
|
|
|
182 vshrntq(vb, vh, 1);
|
|
|
183 vshrntq(vb, vh, 8);
|
|
|
184 vshrntq(vh, vw, 1);
|
|
|
185 vshrntq(vh, vw, 16);
|
|
|
186
|
|
|
187 vshrntq(vb, vh, 0); // expected-error {{argument value 0 is outside the valid range [1, 8]}}
|
|
|
188 vshrntq(vb, vh, 9); // expected-error {{argument value 9 is outside the valid range [1, 8]}}
|
|
|
189 vshrntq(vh, vw, 0); // expected-error {{argument value 0 is outside the valid range [1, 16]}}
|
|
|
190 vshrntq(vh, vw, 17); // expected-error {{argument value 17 is outside the valid range [1, 16]}}
|
|
|
191
|
|
|
192 vsriq(vb, vb, 1);
|
|
|
193 vsriq(vb, vb, 8);
|
|
|
194 vsriq(vh, vh, 1);
|
|
|
195 vsriq(vh, vh, 16);
|
|
|
196 vsriq(vw, vw, 1);
|
|
|
197 vsriq(vw, vw, 32);
|
|
|
198
|
|
|
199 vsriq(vb, vb, 0); // expected-error {{argument value 0 is outside the valid range [1, 8]}}
|
|
|
200 vsriq(vb, vb, 9); // expected-error {{argument value 9 is outside the valid range [1, 8]}}
|
|
|
201 vsriq(vh, vh, 0); // expected-error {{argument value 0 is outside the valid range [1, 16]}}
|
|
|
202 vsriq(vh, vh, 17); // expected-error {{argument value 17 is outside the valid range [1, 16]}}
|
|
|
203 vsriq(vw, vw, 0); // expected-error {{argument value 0 is outside the valid range [1, 32]}}
|
|
|
204 vsriq(vw, vw, 33); // expected-error {{argument value 33 is outside the valid range [1, 32]}}
|
|
|
205 }
|
|
|
206
|
|
|
207 void test_simd_bic_orr(int16x8_t h, int32x4_t w)
|
|
|
208 {
|
|
|
209 h = vbicq(h, 0x0000);
|
|
|
210 h = vbicq(h, 0x0001);
|
|
|
211 h = vbicq(h, 0x00FF);
|
|
|
212 h = vbicq(h, 0x0100);
|
|
|
213 h = vbicq(h, 0x0101); // expected-error-re {{argument should be an 8-bit value shifted by a multiple of 8 bits{{$}}}}
|
|
|
214 h = vbicq(h, 0x01FF); // expected-error-re {{argument should be an 8-bit value shifted by a multiple of 8 bits{{$}}}}
|
|
|
215 h = vbicq(h, 0xFF00);
|
|
|
216
|
|
|
217 w = vbicq(w, 0x00000000);
|
|
|
218 w = vbicq(w, 0x00000001);
|
|
|
219 w = vbicq(w, 0x000000FF);
|
|
|
220 w = vbicq(w, 0x00000100);
|
|
|
221 w = vbicq(w, 0x0000FF00);
|
|
|
222 w = vbicq(w, 0x00010000);
|
|
|
223 w = vbicq(w, 0x00FF0000);
|
|
|
224 w = vbicq(w, 0x01000000);
|
|
|
225 w = vbicq(w, 0xFF000000);
|
|
|
226 w = vbicq(w, 0x01000001); // expected-error-re {{argument should be an 8-bit value shifted by a multiple of 8 bits{{$}}}}
|
|
|
227 w = vbicq(w, 0x01FFFFFF); // expected-error-re {{argument should be an 8-bit value shifted by a multiple of 8 bits{{$}}}}
|
|
|
228
|
|
|
229 h = vorrq(h, 0x0000);
|
|
|
230 h = vorrq(h, 0x0001);
|
|
|
231 h = vorrq(h, 0x00FF);
|
|
|
232 h = vorrq(h, 0x0100);
|
|
|
233 h = vorrq(h, 0x0101); // expected-error-re {{argument should be an 8-bit value shifted by a multiple of 8 bits{{$}}}}
|
|
|
234 h = vorrq(h, 0x01FF); // expected-error-re {{argument should be an 8-bit value shifted by a multiple of 8 bits{{$}}}}
|
|
|
235 h = vorrq(h, 0xFF00);
|
|
|
236
|
|
|
237 w = vorrq(w, 0x00000000);
|
|
|
238 w = vorrq(w, 0x00000001);
|
|
|
239 w = vorrq(w, 0x000000FF);
|
|
|
240 w = vorrq(w, 0x00000100);
|
|
|
241 w = vorrq(w, 0x0000FF00);
|
|
|
242 w = vorrq(w, 0x00010000);
|
|
|
243 w = vorrq(w, 0x00FF0000);
|
|
|
244 w = vorrq(w, 0x01000000);
|
|
|
245 w = vorrq(w, 0xFF000000);
|
|
|
246 w = vorrq(w, 0x01000001); // expected-error-re {{argument should be an 8-bit value shifted by a multiple of 8 bits{{$}}}}
|
|
|
247 w = vorrq(w, 0x01FFFFFF); // expected-error-re {{argument should be an 8-bit value shifted by a multiple of 8 bits{{$}}}}
|
|
|
248 }
|
|
|
249
|
|
|
250 void test_simd_vmvn(void)
|
|
|
251 {
|
|
|
252 uint16x8_t h;
|
|
|
253 h = vmvnq_n_u16(0x0000);
|
|
|
254 h = vmvnq_n_u16(0x0001);
|
|
|
255 h = vmvnq_n_u16(0x00FF);
|
|
|
256 h = vmvnq_n_u16(0x0100);
|
|
|
257 h = vmvnq_n_u16(0x0101); // expected-error {{argument should be an 8-bit value shifted by a multiple of 8 bits, or in the form 0x??FF}}
|
|
|
258 h = vmvnq_n_u16(0x01FF);
|
|
|
259 h = vmvnq_n_u16(0xFF00);
|
|
|
260
|
|
|
261 uint32x4_t w;
|
|
|
262 w = vmvnq_n_u32(0x00000000);
|
|
|
263 w = vmvnq_n_u32(0x00000001);
|
|
|
264 w = vmvnq_n_u32(0x000000FF);
|
|
|
265 w = vmvnq_n_u32(0x00000100);
|
|
|
266 w = vmvnq_n_u32(0x0000FF00);
|
|
|
267 w = vmvnq_n_u32(0x00010000);
|
|
|
268 w = vmvnq_n_u32(0x00FF0000);
|
|
|
269 w = vmvnq_n_u32(0x01000000);
|
|
|
270 w = vmvnq_n_u32(0xFF000000);
|
|
|
271 w = vmvnq_n_u32(0x01000001); // expected-error {{argument should be an 8-bit value shifted by a multiple of 8 bits, or in the form 0x??FF}}
|
|
|
272 w = vmvnq_n_u32(0x01FFFFFF); // expected-error {{argument should be an 8-bit value shifted by a multiple of 8 bits, or in the form 0x??FF}}
|
|
|
273 w = vmvnq_n_u32(0x0001FFFF); // expected-error {{argument should be an 8-bit value shifted by a multiple of 8 bits, or in the form 0x??FF}}
|
|
|
274 w = vmvnq_n_u32(0x000001FF);
|
|
|
275 }
|
|
|
276
|
|
|
277 void test_vidup(void)
|
|
|
278 {
|
|
|
279 vidupq_n_u16(0x12345678, 1);
|
|
|
280 vidupq_n_u16(0x12345678, 2);
|
|
|
281 vidupq_n_u16(0x12345678, 4);
|
|
|
282 vidupq_n_u16(0x12345678, 8);
|
|
|
283
|
|
|
284 vidupq_n_u16(0x12345678, 0); // expected-error {{argument value 0 is outside the valid range [1, 8]}}
|
|
|
285 vidupq_n_u16(0x12345678, 16); // expected-error {{argument value 16 is outside the valid range [1, 8]}}
|
|
|
286 vidupq_n_u16(0x12345678, -1); // expected-error {{argument value -1 is outside the valid range [1, 8]}}
|
|
|
287 vidupq_n_u16(0x12345678, -2); // expected-error {{argument value -2 is outside the valid range [1, 8]}}
|
|
|
288 vidupq_n_u16(0x12345678, -4); // expected-error {{argument value -4 is outside the valid range [1, 8]}}
|
|
|
289 vidupq_n_u16(0x12345678, -8); // expected-error {{argument value -8 is outside the valid range [1, 8]}}
|
|
|
290 vidupq_n_u16(0x12345678, 3); // expected-error {{argument should be a power of 2}}
|
|
|
291 vidupq_n_u16(0x12345678, 7); // expected-error {{argument should be a power of 2}}
|
|
|
292 }
|
|
|
293
|
|
|
294 void test_vcvtq(void)
|
|
|
295 {
|
|
|
296 uint16x8_t vec_u16;
|
|
|
297 float16x8_t vec_f16;
|
|
|
298 vcvtq_n_f16_u16(vec_u16, 0); // expected-error {{argument value 0 is outside the valid range [1, 16]}}
|
|
|
299 vcvtq_n_f16_u16(vec_u16, 1);
|
|
|
300 vcvtq_n_f16_u16(vec_u16, 16);
|
|
|
301 vcvtq_n_f16_u16(vec_u16, 17); // expected-error {{argument value 17 is outside the valid range [1, 16]}}
|
|
|
302
|
|
|
303 int32x4_t vec_s32;
|
|
|
304 float32x4_t vec_f32;
|
|
|
305 vcvtq_n_s32_f32(vec_s32, -1); // expected-error {{argument value -1 is outside the valid range [1, 32]}}
|
|
|
306 vcvtq_n_s32_f32(vec_s32, 1);
|
|
|
307 vcvtq_n_s32_f32(vec_s32, 32);
|
|
|
308 vcvtq_n_s32_f32(vec_s32, 33); // expected-error {{argument value 33 is outside the valid range [1, 32]}}
|
|
|
309 }
|
