1 // { dg-options "-Wno-psabi" }
2 // { dg-do run { target hw } }
3 import core.simd;
4 import core.stdc.string;
5 import std.stdio;
6
7 alias TypeTuple(T...) = T;
8
9 /*****************************************/
10 // https://issues.dlang.org/show_bug.cgi?id=16087
11
12 static assert(void8.sizeof == 8);
13 static assert(float2.sizeof == 8);
14 static assert(byte8.sizeof == 8);
15 static assert(ubyte8.sizeof == 8);
16 static assert(short4.sizeof == 8);
17 static assert(ushort4.sizeof == 8);
18 static assert(int2.sizeof == 8);
19 static assert(uint2.sizeof == 8);
20
21 static assert(void16.alignof == 16);
22 static assert(double2.alignof == 16);
23 static assert(float4.alignof == 16);
24 static assert(byte16.alignof == 16);
25 static assert(ubyte16.alignof == 16);
26 static assert(short8.alignof == 16);
27 static assert(ushort8.alignof == 16);
28 static assert(int4.alignof == 16);
29 static assert(uint4.alignof == 16);
30 static assert(long2.alignof == 16);
31 static assert(ulong2.alignof == 16);
32
33 static assert(void16.sizeof == 16);
34 static assert(double2.sizeof == 16);
35 static assert(float4.sizeof == 16);
36 static assert(byte16.sizeof == 16);
37 static assert(ubyte16.sizeof == 16);
38 static assert(short8.sizeof == 16);
39 static assert(ushort8.sizeof == 16);
40 static assert(int4.sizeof == 16);
41 static assert(uint4.sizeof == 16);
42 static assert(long2.sizeof == 16);
43 static assert(ulong2.sizeof == 16);
44
45 static assert(void32.alignof == 32);
46 static assert(double4.alignof == 32);
47 static assert(float8.alignof == 32);
48 static assert(byte32.alignof == 32);
49 static assert(ubyte32.alignof == 32);
50 static assert(short16.alignof == 32);
51 static assert(ushort16.alignof == 32);
52 static assert(int8.alignof == 32);
53 static assert(uint8.alignof == 32);
54 static assert(long4.alignof == 32);
55 static assert(ulong4.alignof == 32);
56
57 static assert(void32.sizeof == 32);
58 static assert(double4.sizeof == 32);
59 static assert(float8.sizeof == 32);
60 static assert(byte32.sizeof == 32);
61 static assert(ubyte32.sizeof == 32);
62 static assert(short16.sizeof == 32);
63 static assert(ushort16.sizeof == 32);
64 static assert(int8.sizeof == 32);
65 static assert(uint8.sizeof == 32);
66 static assert(long4.sizeof == 32);
67 static assert(ulong4.sizeof == 32);
68
69 /*****************************************/
70
test1()71 void test1()
72 {
73 void16 v1 = void,v2 = void;
74 byte16 b;
75 v2 = b;
76 v1 = v2;
77 static assert(!__traits(compiles, v1 + v2));
78 static assert(!__traits(compiles, v1 - v2));
79 static assert(!__traits(compiles, v1 * v2));
80 static assert(!__traits(compiles, v1 / v2));
81 static assert(!__traits(compiles, v1 % v2));
82 static assert(!__traits(compiles, v1 & v2));
83 static assert(!__traits(compiles, v1 | v2));
84 static assert(!__traits(compiles, v1 ^ v2));
85 static assert(!__traits(compiles, v1 ~ v2));
86 static assert(!__traits(compiles, v1 ^^ v2));
87 static assert(!__traits(compiles, v1 is v2));
88 static assert(!__traits(compiles, v1 !is v2));
89 static assert(!__traits(compiles, v1 == v2));
90 static assert(!__traits(compiles, v1 != v2));
91 static assert(!__traits(compiles, v1 < v2));
92 static assert(!__traits(compiles, v1 > v2));
93 static assert(!__traits(compiles, v1 <= v2));
94 static assert(!__traits(compiles, v1 >= v2));
95 static assert(!__traits(compiles, v1 <> v2));
96 static assert(!__traits(compiles, v1 !< v2));
97 static assert(!__traits(compiles, v1 !> v2));
98 static assert(!__traits(compiles, v1 !<> v2));
99 static assert(!__traits(compiles, v1 <>= v2));
100 static assert(!__traits(compiles, v1 !<= v2));
101 static assert(!__traits(compiles, v1 !>= v2));
102 static assert(!__traits(compiles, v1 !<>= v2));
103 static assert(!__traits(compiles, v1 << 1));
104 static assert(!__traits(compiles, v1 >> 1));
105 static assert(!__traits(compiles, v1 >>> 1));
106 static assert(!__traits(compiles, v1 && v2));
107 static assert(!__traits(compiles, v1 || v2));
108 static assert(!__traits(compiles, ~v1));
109 static assert(!__traits(compiles, -v1));
110 static assert(!__traits(compiles, +v1));
111 static assert(!__traits(compiles, !v1));
112
113 static assert(!__traits(compiles, v1 += v2));
114 static assert(!__traits(compiles, v1 -= v2));
115 static assert(!__traits(compiles, v1 *= v2));
116 static assert(!__traits(compiles, v1 /= v2));
117 static assert(!__traits(compiles, v1 %= v2));
118 static assert(!__traits(compiles, v1 &= v2));
119 static assert(!__traits(compiles, v1 |= v2));
120 static assert(!__traits(compiles, v1 ^= v2));
121 static assert(!__traits(compiles, v1 ~= v2));
122 static assert(!__traits(compiles, v1 ^^= v2));
123 static assert(!__traits(compiles, v1 <<= 1));
124 static assert(!__traits(compiles, v1 >>= 1));
125 static assert(!__traits(compiles, v1 >>>= 1));
126
127 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
128 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
129 static assert(!__traits(compiles, cast(short)v1)); // 2byte
130 static assert(!__traits(compiles, cast(int)v1)); // 4byte
131 static assert(!__traits(compiles, cast(long)v1)); // 8byte
132 static assert(!__traits(compiles, cast(float)v1)); // 4byte
133 static assert(!__traits(compiles, cast(double)v1)); // 8byte
134 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
135 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
136 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
137 }
138
139 /*****************************************/
140
test2()141 void test2()
142 {
143 byte16 v1, v2 = 1, v3 = 1;
144 v1 = v2;
145 v1 = v2 + v3;
146 v1 = v2 - v3;
147 v1 = v2 * v3;
148 v1 = v2 / v3;
149 v1 = v2 % v3;
150 v1 = v2 & v3;
151 v1 = v2 | v3;
152 v1 = v2 ^ v3;
153 static assert(!__traits(compiles, v1 ~ v2));
154 static assert(!__traits(compiles, v1 ^^ v2));
155 static assert(!__traits(compiles, v1 is v2));
156 static assert(!__traits(compiles, v1 !is v2));
157 static assert(!__traits(compiles, v1 == v2));
158 static assert(!__traits(compiles, v1 != v2));
159 static assert(!__traits(compiles, v1 < v2));
160 static assert(!__traits(compiles, v1 > v2));
161 static assert(!__traits(compiles, v1 <= v2));
162 static assert(!__traits(compiles, v1 >= v2));
163 static assert(!__traits(compiles, v1 <> v2));
164 static assert(!__traits(compiles, v1 !< v2));
165 static assert(!__traits(compiles, v1 !> v2));
166 static assert(!__traits(compiles, v1 !<> v2));
167 static assert(!__traits(compiles, v1 <>= v2));
168 static assert(!__traits(compiles, v1 !<= v2));
169 static assert(!__traits(compiles, v1 !>= v2));
170 static assert(!__traits(compiles, v1 !<>= v2));
171 v1 = v2 << 1;
172 v1 = v2 >> 1;
173 v1 = v2 >>> 1;
174 static assert(!__traits(compiles, v1 && v2));
175 static assert(!__traits(compiles, v1 || v2));
176 v1 = ~v2;
177 v1 = -v2;
178 v1 = +v2;
179 static assert(!__traits(compiles, !v1));
180
181 v1 += v2;
182 v1 -= v2;
183 v1 *= v2;
184 v1 /= v2;
185 v1 %= v2;
186 v1 &= v2;
187 v1 |= v2;
188 v1 ^= v2;
189 static assert(!__traits(compiles, v1 ~= v2));
190 static assert(!__traits(compiles, v1 ^^= v2));
191 v1 <<= 1;
192 v1 >>= 1;
193 v1 >>>= 1;
194
195 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
196 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
197 static assert(!__traits(compiles, cast(short)v1)); // 2byte
198 static assert(!__traits(compiles, cast(int)v1)); // 4byte
199 static assert(!__traits(compiles, cast(long)v1)); // 8byte
200 static assert(!__traits(compiles, cast(float)v1)); // 4byte
201 static assert(!__traits(compiles, cast(double)v1)); // 8byte
202 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
203 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
204 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
205 }
206
207 /*****************************************/
208
test2b()209 void test2b()
210 {
211 ubyte16 v1, v2 = 1, v3 = 1;
212 v1 = v2;
213 v1 = v2 + v3;
214 v1 = v2 - v3;
215 v1 = v2 * v3;
216 v1 = v2 / v3;
217 v1 = v2 % v3;
218 v1 = v2 & v3;
219 v1 = v2 | v3;
220 v1 = v2 ^ v3;
221 static assert(!__traits(compiles, v1 ~ v2));
222 static assert(!__traits(compiles, v1 ^^ v2));
223 static assert(!__traits(compiles, v1 is v2));
224 static assert(!__traits(compiles, v1 !is v2));
225 static assert(!__traits(compiles, v1 == v2));
226 static assert(!__traits(compiles, v1 != v2));
227 static assert(!__traits(compiles, v1 < v2));
228 static assert(!__traits(compiles, v1 > v2));
229 static assert(!__traits(compiles, v1 <= v2));
230 static assert(!__traits(compiles, v1 >= v2));
231 static assert(!__traits(compiles, v1 <> v2));
232 static assert(!__traits(compiles, v1 !< v2));
233 static assert(!__traits(compiles, v1 !> v2));
234 static assert(!__traits(compiles, v1 !<> v2));
235 static assert(!__traits(compiles, v1 <>= v2));
236 static assert(!__traits(compiles, v1 !<= v2));
237 static assert(!__traits(compiles, v1 !>= v2));
238 static assert(!__traits(compiles, v1 !<>= v2));
239 v1 = v2 << 1;
240 v1 = v2 >> 1;
241 v1 = v2 >>> 1;
242 static assert(!__traits(compiles, v1 && v2));
243 static assert(!__traits(compiles, v1 || v2));
244 v1 = ~v2;
245 v1 = -v2;
246 v1 = +v2;
247 static assert(!__traits(compiles, !v1));
248
249 v1 += v2;
250 v1 -= v2;
251 v1 *= v2;
252 v1 /= v2;
253 v1 %= v2;
254 v1 &= v2;
255 v1 |= v2;
256 v1 ^= v2;
257 static assert(!__traits(compiles, v1 ~= v2));
258 static assert(!__traits(compiles, v1 ^^= v2));
259 v1 <<= 1;
260 v1 >>= 1;
261 v1 >>>= 1;
262
263 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
264 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
265 static assert(!__traits(compiles, cast(short)v1)); // 2byte
266 static assert(!__traits(compiles, cast(int)v1)); // 4byte
267 static assert(!__traits(compiles, cast(long)v1)); // 8byte
268 static assert(!__traits(compiles, cast(float)v1)); // 4byte
269 static assert(!__traits(compiles, cast(double)v1)); // 8byte
270 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
271 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
272 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
273 }
274
275 /*****************************************/
276
test2c()277 void test2c()
278 {
279 short8 v1, v2 = 1, v3 = 1;
280 v1 = v2;
281 v1 = v2 + v3;
282 v1 = v2 - v3;
283 v1 = v2 * v3;
284 v1 = v2 / v3;
285 v1 = v2 % v3;
286 v1 = v2 & v3;
287 v1 = v2 | v3;
288 v1 = v2 ^ v3;
289 static assert(!__traits(compiles, v1 ~ v2));
290 static assert(!__traits(compiles, v1 ^^ v2));
291 static assert(!__traits(compiles, v1 is v2));
292 static assert(!__traits(compiles, v1 !is v2));
293 static assert(!__traits(compiles, v1 == v2));
294 static assert(!__traits(compiles, v1 != v2));
295 static assert(!__traits(compiles, v1 < v2));
296 static assert(!__traits(compiles, v1 > v2));
297 static assert(!__traits(compiles, v1 <= v2));
298 static assert(!__traits(compiles, v1 >= v2));
299 static assert(!__traits(compiles, v1 <> v2));
300 static assert(!__traits(compiles, v1 !< v2));
301 static assert(!__traits(compiles, v1 !> v2));
302 static assert(!__traits(compiles, v1 !<> v2));
303 static assert(!__traits(compiles, v1 <>= v2));
304 static assert(!__traits(compiles, v1 !<= v2));
305 static assert(!__traits(compiles, v1 !>= v2));
306 static assert(!__traits(compiles, v1 !<>= v2));
307 v1 = v2 << 1;
308 v1 = v2 >> 1;
309 v1 = v2 >>> 1;
310 static assert(!__traits(compiles, v1 && v2));
311 static assert(!__traits(compiles, v1 || v2));
312 v1 = ~v2;
313 v1 = -v2;
314 v1 = +v2;
315 static assert(!__traits(compiles, !v1));
316
317 v1 += v2;
318 v1 -= v2;
319 v1 *= v2;
320 v1 /= v2;
321 v1 %= v2;
322 v1 &= v2;
323 v1 |= v2;
324 v1 ^= v2;
325 static assert(!__traits(compiles, v1 ~= v2));
326 static assert(!__traits(compiles, v1 ^^= v2));
327 v1 <<= 1;
328 v1 >>= 1;
329 v1 >>>= 1;
330 v1 = v1 * 3;
331
332 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
333 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
334 static assert(!__traits(compiles, cast(short)v1)); // 2byte
335 static assert(!__traits(compiles, cast(int)v1)); // 4byte
336 static assert(!__traits(compiles, cast(long)v1)); // 8byte
337 static assert(!__traits(compiles, cast(float)v1)); // 4byte
338 static assert(!__traits(compiles, cast(double)v1)); // 8byte
339 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
340 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
341 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
342 }
343
344 /*****************************************/
345
test2d()346 void test2d()
347 {
348 ushort8 v1, v2 = 1, v3 = 1;
349 v1 = v2;
350 v1 = v2 + v3;
351 v1 = v2 - v3;
352 v1 = v2 * v3;
353 v1 = v2 / v3;
354 v1 = v2 % v3;
355 v1 = v2 & v3;
356 v1 = v2 | v3;
357 v1 = v2 ^ v3;
358 static assert(!__traits(compiles, v1 ~ v2));
359 static assert(!__traits(compiles, v1 ^^ v2));
360 static assert(!__traits(compiles, v1 is v2));
361 static assert(!__traits(compiles, v1 !is v2));
362 static assert(!__traits(compiles, v1 == v2));
363 static assert(!__traits(compiles, v1 != v2));
364 static assert(!__traits(compiles, v1 < v2));
365 static assert(!__traits(compiles, v1 > v2));
366 static assert(!__traits(compiles, v1 <= v2));
367 static assert(!__traits(compiles, v1 >= v2));
368 static assert(!__traits(compiles, v1 <> v2));
369 static assert(!__traits(compiles, v1 !< v2));
370 static assert(!__traits(compiles, v1 !> v2));
371 static assert(!__traits(compiles, v1 !<> v2));
372 static assert(!__traits(compiles, v1 <>= v2));
373 static assert(!__traits(compiles, v1 !<= v2));
374 static assert(!__traits(compiles, v1 !>= v2));
375 static assert(!__traits(compiles, v1 !<>= v2));
376 v1 = v2 << 1;
377 v1 = v2 >> 1;
378 v1 = v2 >>> 1;
379 static assert(!__traits(compiles, v1 && v2));
380 static assert(!__traits(compiles, v1 || v2));
381 v1 = ~v2;
382 v1 = -v2;
383 v1 = +v2;
384 static assert(!__traits(compiles, !v1));
385
386 v1 += v2;
387 v1 -= v2;
388 v1 *= v2;
389 v1 /= v2;
390 v1 %= v2;
391 v1 &= v2;
392 v1 |= v2;
393 v1 ^= v2;
394 static assert(!__traits(compiles, v1 ~= v2));
395 static assert(!__traits(compiles, v1 ^^= v2));
396 v1 <<= 1;
397 v1 >>= 1;
398 v1 >>>= 1;
399
400 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
401 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
402 static assert(!__traits(compiles, cast(short)v1)); // 2byte
403 static assert(!__traits(compiles, cast(int)v1)); // 4byte
404 static assert(!__traits(compiles, cast(long)v1)); // 8byte
405 static assert(!__traits(compiles, cast(float)v1)); // 4byte
406 static assert(!__traits(compiles, cast(double)v1)); // 8byte
407 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
408 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
409 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
410 }
411
412 /*****************************************/
413
test2e()414 void test2e()
415 {
416 int4 v1, v2 = 1, v3 = 1;
417 v1 = v2;
418 v1 = v2 + v3;
419 v1 = v2 - v3;
420 v1 = v2 * v3;
421 v1 = v2 / v3;
422 v1 = v2 % v3;
423 v1 = v2 & v3;
424 v1 = v2 | v3;
425 v1 = v2 ^ v3;
426 static assert(!__traits(compiles, v1 ~ v2));
427 static assert(!__traits(compiles, v1 ^^ v2));
428 static assert(!__traits(compiles, v1 is v2));
429 static assert(!__traits(compiles, v1 !is v2));
430 static assert(!__traits(compiles, v1 == v2));
431 static assert(!__traits(compiles, v1 != v2));
432 static assert(!__traits(compiles, v1 < v2));
433 static assert(!__traits(compiles, v1 > v2));
434 static assert(!__traits(compiles, v1 <= v2));
435 static assert(!__traits(compiles, v1 >= v2));
436 static assert(!__traits(compiles, v1 <> v2));
437 static assert(!__traits(compiles, v1 !< v2));
438 static assert(!__traits(compiles, v1 !> v2));
439 static assert(!__traits(compiles, v1 !<> v2));
440 static assert(!__traits(compiles, v1 <>= v2));
441 static assert(!__traits(compiles, v1 !<= v2));
442 static assert(!__traits(compiles, v1 !>= v2));
443 static assert(!__traits(compiles, v1 !<>= v2));
444 v1 = v2 << 1;
445 v1 = v2 >> 1;
446 v1 = v2 >>> 1;
447 static assert(!__traits(compiles, v1 && v2));
448 static assert(!__traits(compiles, v1 || v2));
449 v1 = ~v2;
450 v1 = -v2;
451 v1 = +v2;
452 static assert(!__traits(compiles, !v1));
453
454 v1 += v2;
455 v1 -= v2;
456 v1 *= v2;
457 v1 /= v2;
458 v1 %= v2;
459 v1 &= v2;
460 v1 |= v2;
461 v1 ^= v2;
462 static assert(!__traits(compiles, v1 ~= v2));
463 static assert(!__traits(compiles, v1 ^^= v2));
464 v1 <<= 1;
465 v1 >>= 1;
466 v1 >>>= 1;
467
468 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
469 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
470 static assert(!__traits(compiles, cast(short)v1)); // 2byte
471 static assert(!__traits(compiles, cast(int)v1)); // 4byte
472 static assert(!__traits(compiles, cast(long)v1)); // 8byte
473 static assert(!__traits(compiles, cast(float)v1)); // 4byte
474 static assert(!__traits(compiles, cast(double)v1)); // 8byte
475 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
476 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
477 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
478 }
479
480 /*****************************************/
481
test2f()482 void test2f()
483 {
484 uint4 v1, v2 = 1, v3 = 1;
485 v1 = v2;
486 v1 = v2 + v3;
487 v1 = v2 - v3;
488 v1 = v2 * v3;
489 v1 = v2 / v3;
490 v1 = v2 % v3;
491 v1 = v2 & v3;
492 v1 = v2 | v3;
493 v1 = v2 ^ v3;
494 static assert(!__traits(compiles, v1 ~ v2));
495 static assert(!__traits(compiles, v1 ^^ v2));
496 static assert(!__traits(compiles, v1 is v2));
497 static assert(!__traits(compiles, v1 !is v2));
498 static assert(!__traits(compiles, v1 == v2));
499 static assert(!__traits(compiles, v1 != v2));
500 static assert(!__traits(compiles, v1 < v2));
501 static assert(!__traits(compiles, v1 > v2));
502 static assert(!__traits(compiles, v1 <= v2));
503 static assert(!__traits(compiles, v1 >= v2));
504 static assert(!__traits(compiles, v1 <> v2));
505 static assert(!__traits(compiles, v1 !< v2));
506 static assert(!__traits(compiles, v1 !> v2));
507 static assert(!__traits(compiles, v1 !<> v2));
508 static assert(!__traits(compiles, v1 <>= v2));
509 static assert(!__traits(compiles, v1 !<= v2));
510 static assert(!__traits(compiles, v1 !>= v2));
511 static assert(!__traits(compiles, v1 !<>= v2));
512 v1 = v2 << 1;
513 v1 = v2 >> 1;
514 v1 = v2 >>> 1;
515 static assert(!__traits(compiles, v1 && v2));
516 static assert(!__traits(compiles, v1 || v2));
517 v1 = ~v2;
518 v1 = -v2;
519 v1 = +v2;
520 static assert(!__traits(compiles, !v1));
521
522 v1 += v2;
523 v1 -= v2;
524 v1 *= v2;
525 v1 /= v2;
526 v1 %= v2;
527 v1 &= v2;
528 v1 |= v2;
529 v1 ^= v2;
530 static assert(!__traits(compiles, v1 ~= v2));
531 static assert(!__traits(compiles, v1 ^^= v2));
532 v1 <<= 1;
533 v1 >>= 1;
534 v1 >>>= 1;
535
536 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
537 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
538 static assert(!__traits(compiles, cast(short)v1)); // 2byte
539 static assert(!__traits(compiles, cast(int)v1)); // 4byte
540 static assert(!__traits(compiles, cast(long)v1)); // 8byte
541 static assert(!__traits(compiles, cast(float)v1)); // 4byte
542 static assert(!__traits(compiles, cast(double)v1)); // 8byte
543 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
544 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
545 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
546 }
547
548 /*****************************************/
549
test2g()550 void test2g()
551 {
552 long2 v1, v2 = 1, v3 = 1;
553 v1 = v2;
554 v1 = v2 + v3;
555 v1 = v2 - v3;
556 v1 = v2 * v3;
557 v1 = v2 / v3;
558 v1 = v2 % v3;
559 v1 = v2 & v3;
560 v1 = v2 | v3;
561 v1 = v2 ^ v3;
562 static assert(!__traits(compiles, v1 ~ v2));
563 static assert(!__traits(compiles, v1 ^^ v2));
564 static assert(!__traits(compiles, v1 is v2));
565 static assert(!__traits(compiles, v1 !is v2));
566 static assert(!__traits(compiles, v1 == v2));
567 static assert(!__traits(compiles, v1 != v2));
568 static assert(!__traits(compiles, v1 < v2));
569 static assert(!__traits(compiles, v1 > v2));
570 static assert(!__traits(compiles, v1 <= v2));
571 static assert(!__traits(compiles, v1 >= v2));
572 static assert(!__traits(compiles, v1 <> v2));
573 static assert(!__traits(compiles, v1 !< v2));
574 static assert(!__traits(compiles, v1 !> v2));
575 static assert(!__traits(compiles, v1 !<> v2));
576 static assert(!__traits(compiles, v1 <>= v2));
577 static assert(!__traits(compiles, v1 !<= v2));
578 static assert(!__traits(compiles, v1 !>= v2));
579 static assert(!__traits(compiles, v1 !<>= v2));
580 v1 = v2 << 1;
581 v1 = v2 >> 1;
582 v1 = v2 >>> 1;
583 static assert(!__traits(compiles, v1 && v2));
584 static assert(!__traits(compiles, v1 || v2));
585 v1 = ~v2;
586 v1 = -v2;
587 v1 = +v2;
588 static assert(!__traits(compiles, !v1));
589
590 v1 += v2;
591 v1 -= v2;
592 v1 *= v2;
593 v1 /= v2;
594 v1 %= v2;
595 v1 &= v2;
596 v1 |= v2;
597 v1 ^= v2;
598 static assert(!__traits(compiles, v1 ~= v2));
599 static assert(!__traits(compiles, v1 ^^= v2));
600 v1 <<= 1;
601 v1 >>= 1;
602 v1 >>>= 1;
603
604 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
605 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
606 static assert(!__traits(compiles, cast(short)v1)); // 2byte
607 static assert(!__traits(compiles, cast(int)v1)); // 4byte
608 static assert(!__traits(compiles, cast(long)v1)); // 8byte
609 static assert(!__traits(compiles, cast(float)v1)); // 4byte
610 static assert(!__traits(compiles, cast(double)v1)); // 8byte
611 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
612 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
613 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
614 }
615
616 /*****************************************/
617
test2h()618 void test2h()
619 {
620 ulong2 v1, v2 = 1, v3 = 1;
621 v1 = v2;
622 v1 = v2 + v3;
623 v1 = v2 - v3;
624 v1 = v2 * v3;
625 v1 = v2 / v3;
626 v1 = v2 % v3;
627 v1 = v2 & v3;
628 v1 = v2 | v3;
629 v1 = v2 ^ v3;
630 static assert(!__traits(compiles, v1 ~ v2));
631 static assert(!__traits(compiles, v1 ^^ v2));
632 static assert(!__traits(compiles, v1 is v2));
633 static assert(!__traits(compiles, v1 !is v2));
634 static assert(!__traits(compiles, v1 == v2));
635 static assert(!__traits(compiles, v1 != v2));
636 static assert(!__traits(compiles, v1 < v2));
637 static assert(!__traits(compiles, v1 > v2));
638 static assert(!__traits(compiles, v1 <= v2));
639 static assert(!__traits(compiles, v1 >= v2));
640 static assert(!__traits(compiles, v1 <> v2));
641 static assert(!__traits(compiles, v1 !< v2));
642 static assert(!__traits(compiles, v1 !> v2));
643 static assert(!__traits(compiles, v1 !<> v2));
644 static assert(!__traits(compiles, v1 <>= v2));
645 static assert(!__traits(compiles, v1 !<= v2));
646 static assert(!__traits(compiles, v1 !>= v2));
647 static assert(!__traits(compiles, v1 !<>= v2));
648 v1 = v2 << 1;
649 v1 = v2 >> 1;
650 v1 = v2 >>> 1;
651 static assert(!__traits(compiles, v1 && v2));
652 static assert(!__traits(compiles, v1 || v2));
653 v1 = ~v2;
654 v1 = -v2;
655 v1 = +v2;
656 static assert(!__traits(compiles, !v1));
657
658 v1 += v2;
659 v1 -= v2;
660 v1 *= v2;
661 v1 /= v2;
662 v1 %= v2;
663 v1 &= v2;
664 v1 |= v2;
665 v1 ^= v2;
666 static assert(!__traits(compiles, v1 ~= v2));
667 static assert(!__traits(compiles, v1 ^^= v2));
668 v1 <<= 1;
669 v1 >>= 1;
670 v1 >>>= 1;
671
672 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
673 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
674 static assert(!__traits(compiles, cast(short)v1)); // 2byte
675 static assert(!__traits(compiles, cast(int)v1)); // 4byte
676 static assert(!__traits(compiles, cast(long)v1)); // 8byte
677 static assert(!__traits(compiles, cast(float)v1)); // 4byte
678 static assert(!__traits(compiles, cast(double)v1)); // 8byte
679 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
680 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
681 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
682 }
683
684 /*****************************************/
685
test2i()686 void test2i()
687 {
688 float4 v1, v2 = 1, v3 = 1;
689 v1 = v2;
690 v1 = v2 + v3;
691 v1 = v2 - v3;
692 v1 = v2 * v3;
693 v1 = v2 / v3;
694 static assert(!__traits(compiles, v1 % v2));
695 static assert(!__traits(compiles, v1 & v2));
696 static assert(!__traits(compiles, v1 | v2));
697 static assert(!__traits(compiles, v1 ^ v2));
698 static assert(!__traits(compiles, v1 ~ v2));
699 static assert(!__traits(compiles, v1 ^^ v2));
700 static assert(!__traits(compiles, v1 is v2));
701 static assert(!__traits(compiles, v1 !is v2));
702 static assert(!__traits(compiles, v1 == v2));
703 static assert(!__traits(compiles, v1 != v2));
704 static assert(!__traits(compiles, v1 < v2));
705 static assert(!__traits(compiles, v1 > v2));
706 static assert(!__traits(compiles, v1 <= v2));
707 static assert(!__traits(compiles, v1 >= v2));
708 static assert(!__traits(compiles, v1 <> v2));
709 static assert(!__traits(compiles, v1 !< v2));
710 static assert(!__traits(compiles, v1 !> v2));
711 static assert(!__traits(compiles, v1 !<> v2));
712 static assert(!__traits(compiles, v1 <>= v2));
713 static assert(!__traits(compiles, v1 !<= v2));
714 static assert(!__traits(compiles, v1 !>= v2));
715 static assert(!__traits(compiles, v1 !<>= v2));
716 static assert(!__traits(compiles, v1 << 1));
717 static assert(!__traits(compiles, v1 >> 1));
718 static assert(!__traits(compiles, v1 >>> 1));
719 static assert(!__traits(compiles, v1 && v2));
720 static assert(!__traits(compiles, v1 || v2));
721 static assert(!__traits(compiles, ~v1));
722 v1 = -v2;
723 v1 = +v2;
724 static assert(!__traits(compiles, !v1));
725
726 v1 += v2;
727 v1 -= v2;
728 v1 *= v2;
729 v1 /= v2;
730 static assert(!__traits(compiles, v1 %= v2));
731 static assert(!__traits(compiles, v1 &= v2));
732 static assert(!__traits(compiles, v1 |= v2));
733 static assert(!__traits(compiles, v1 ^= v2));
734 static assert(!__traits(compiles, v1 ~= v2));
735 static assert(!__traits(compiles, v1 ^^= v2));
736 static assert(!__traits(compiles, v1 <<= 1));
737 static assert(!__traits(compiles, v1 >>= 1));
738 static assert(!__traits(compiles, v1 >>>= 1));
739
740 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
741 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
742 static assert(!__traits(compiles, cast(short)v1)); // 2byte
743 static assert(!__traits(compiles, cast(int)v1)); // 4byte
744 static assert(!__traits(compiles, cast(long)v1)); // 8byte
745 static assert(!__traits(compiles, cast(float)v1)); // 4byte
746 static assert(!__traits(compiles, cast(double)v1)); // 8byte
747 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
748 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
749 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
750 }
751
752 /*****************************************/
753
test2j()754 void test2j()
755 {
756 double2 v1, v2 = 1, v3 = 1;
757 v1 = v2;
758 v1 = v2 + v3;
759 v1 = v2 - v3;
760 v1 = v2 * v3;
761 v1 = v2 / v3;
762 static assert(!__traits(compiles, v1 % v2));
763 static assert(!__traits(compiles, v1 & v2));
764 static assert(!__traits(compiles, v1 | v2));
765 static assert(!__traits(compiles, v1 ^ v2));
766 static assert(!__traits(compiles, v1 ~ v2));
767 static assert(!__traits(compiles, v1 ^^ v2));
768 static assert(!__traits(compiles, v1 is v2));
769 static assert(!__traits(compiles, v1 !is v2));
770 static assert(!__traits(compiles, v1 == v2));
771 static assert(!__traits(compiles, v1 != v2));
772 static assert(!__traits(compiles, v1 < v2));
773 static assert(!__traits(compiles, v1 > v2));
774 static assert(!__traits(compiles, v1 <= v2));
775 static assert(!__traits(compiles, v1 >= v2));
776 static assert(!__traits(compiles, v1 <> v2));
777 static assert(!__traits(compiles, v1 !< v2));
778 static assert(!__traits(compiles, v1 !> v2));
779 static assert(!__traits(compiles, v1 !<> v2));
780 static assert(!__traits(compiles, v1 <>= v2));
781 static assert(!__traits(compiles, v1 !<= v2));
782 static assert(!__traits(compiles, v1 !>= v2));
783 static assert(!__traits(compiles, v1 !<>= v2));
784 static assert(!__traits(compiles, v1 << 1));
785 static assert(!__traits(compiles, v1 >> 1));
786 static assert(!__traits(compiles, v1 >>> 1));
787 static assert(!__traits(compiles, v1 && v2));
788 static assert(!__traits(compiles, v1 || v2));
789 static assert(!__traits(compiles, ~v1));
790 v1 = -v2;
791 v1 = +v2;
792 static assert(!__traits(compiles, !v1));
793
794 v1 += v2;
795 v1 -= v2;
796 v1 *= v2;
797 v1 /= v2;
798 static assert(!__traits(compiles, v1 %= v2));
799 static assert(!__traits(compiles, v1 &= v2));
800 static assert(!__traits(compiles, v1 |= v2));
801 static assert(!__traits(compiles, v1 ^= v2));
802 static assert(!__traits(compiles, v1 ~= v2));
803 static assert(!__traits(compiles, v1 ^^= v2));
804 static assert(!__traits(compiles, v1 <<= 1));
805 static assert(!__traits(compiles, v1 >>= 1));
806 static assert(!__traits(compiles, v1 >>>= 1));
807
808 // A cast from vector to non-vector is allowed only when the target is same size Tsarray.
809 static assert(!__traits(compiles, cast(byte)v1)); // 1byte
810 static assert(!__traits(compiles, cast(short)v1)); // 2byte
811 static assert(!__traits(compiles, cast(int)v1)); // 4byte
812 static assert(!__traits(compiles, cast(long)v1)); // 8byte
813 static assert(!__traits(compiles, cast(float)v1)); // 4byte
814 static assert(!__traits(compiles, cast(double)v1)); // 8byte
815 static assert(!__traits(compiles, cast(int[2])v1)); // 8byte Tsarray
816 static assert( __traits(compiles, cast(int[4])v1)); // 16byte Tsarray, OK
817 static assert( __traits(compiles, cast(long[2])v1)); // 16byte Tsarray, OK
818 }
819
820 /*****************************************/
821
test4()822 void test4()
823 {
824 int4 c = 7;
825 (cast(int[4])c)[3] = 4;
826 (cast(int*)&c)[2] = 4;
827 c.array[1] = 4;
828 c.ptr[3] = 4;
829 assert(c.length == 4);
830 }
831
832 /*****************************************/
833
834 void BaseTypeOfVector(T : __vector(T[N]), size_t N)(int i)
835 {
836 assert(is(T == int));
837 assert(N == 4);
838 }
839
840
test7411()841 void test7411()
842 {
843 BaseTypeOfVector!(__vector(int[4]))(3);
844 }
845
846 /*****************************************/
847 // https://issues.dlang.org/show_bug.cgi?id=7951
848
test7951()849 float[4] test7951()
850 {
851 float4 v1;
852 float4 v2;
853
854 return cast(float[4])(v1+v2);
855 }
856
857 /*****************************************/
858
test7951_2()859 void test7951_2()
860 {
861 float[4] v1 = [1,2,3,4];
862 float[4] v2 = [1,2,3,4];
863 float4 f1, f2, f3;
864 f1.array = v1;
865 f2.array = v2;
866 f3 = f1 + f2;
867 }
868
869 /*****************************************/
870
871 immutable ulong2 gulong2 = 0x8000_0000_0000_0000;
872 immutable uint4 guint4 = 0x8000_0000;
873 immutable ushort8 gushort8 = 0x8000;
874 immutable ubyte16 gubyte16 = 0x80;
875
876 immutable long2 glong2 = 0x7000_0000_0000_0000;
877 immutable int4 gint4 = 0x7000_0000;
878 immutable short8 gshort8 = 0x7000;
879 immutable byte16 gbyte16 = 0x70;
880
881 immutable float4 gfloat4 = 4.0;
882 immutable double2 gdouble2 = 8.0;
883
test7414()884 void test7414()
885 {
886 immutable ulong2 lulong2 = 0x8000_0000_0000_0000;
887 assert(memcmp(&lulong2, &gulong2, gulong2.sizeof) == 0);
888
889 immutable uint4 luint4 = 0x8000_0000;
890 assert(memcmp(&luint4, &guint4, guint4.sizeof) == 0);
891
892 immutable ushort8 lushort8 = 0x8000;
893 assert(memcmp(&lushort8, &gushort8, gushort8.sizeof) == 0);
894
895 immutable ubyte16 lubyte16 = 0x80;
896 assert(memcmp(&lubyte16, &gubyte16, gubyte16.sizeof) == 0);
897
898
899 immutable long2 llong2 = 0x7000_0000_0000_0000;
900 assert(memcmp(&llong2, &glong2, glong2.sizeof) == 0);
901
902 immutable int4 lint4 = 0x7000_0000;
903 assert(memcmp(&lint4, &gint4, gint4.sizeof) == 0);
904
905 immutable short8 lshort8 = 0x7000;
906 assert(memcmp(&lshort8, &gshort8, gshort8.sizeof) == 0);
907
908 immutable byte16 lbyte16 = 0x70;
909 assert(memcmp(&lbyte16, &gbyte16, gbyte16.sizeof) == 0);
910
911
912 immutable float4 lfloat4 = 4.0;
913 assert(memcmp(&lfloat4, &gfloat4, gfloat4.sizeof) == 0);
914
915 immutable double2 ldouble2 = 8.0;
916 assert(memcmp(&ldouble2, &gdouble2, gdouble2.sizeof) == 0);
917 }
918
919 /*****************************************/
920
test7413()921 void test7413()
922 {
923 byte16 b = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
924 assert(b.array[0] == 1);
925 assert(b.array[1] == 2);
926 assert(b.array[2] == 3);
927 assert(b.array[3] == 4);
928 assert(b.array[4] == 5);
929 assert(b.array[5] == 6);
930 assert(b.array[6] == 7);
931 assert(b.array[7] == 8);
932 assert(b.array[8] == 9);
933 assert(b.array[9] == 10);
934 assert(b.array[10] == 11);
935 assert(b.array[11] == 12);
936 assert(b.array[12] == 13);
937 assert(b.array[13] == 14);
938 assert(b.array[14] == 15);
939 assert(b.array[15] == 16);
940
941 ubyte16 ub = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
942 assert(ub.array[0] == 1);
943 assert(ub.array[1] == 2);
944 assert(ub.array[2] == 3);
945 assert(ub.array[3] == 4);
946 assert(ub.array[4] == 5);
947 assert(ub.array[5] == 6);
948 assert(ub.array[6] == 7);
949 assert(ub.array[7] == 8);
950 assert(ub.array[8] == 9);
951 assert(ub.array[9] == 10);
952 assert(ub.array[10] == 11);
953 assert(ub.array[11] == 12);
954 assert(ub.array[12] == 13);
955 assert(ub.array[13] == 14);
956 assert(ub.array[14] == 15);
957 assert(ub.array[15] == 16);
958
959 short8 s = [1,2,3,4,5,6,7,8];
960 assert(s.array[0] == 1);
961 assert(s.array[1] == 2);
962 assert(s.array[2] == 3);
963 assert(s.array[3] == 4);
964 assert(s.array[4] == 5);
965 assert(s.array[5] == 6);
966 assert(s.array[6] == 7);
967 assert(s.array[7] == 8);
968
969 ushort8 us = [1,2,3,4,5,6,7,8];
970 assert(us.array[0] == 1);
971 assert(us.array[1] == 2);
972 assert(us.array[2] == 3);
973 assert(us.array[3] == 4);
974 assert(us.array[4] == 5);
975 assert(us.array[5] == 6);
976 assert(us.array[6] == 7);
977 assert(us.array[7] == 8);
978
979 int4 i = [1,2,3,4];
980 assert(i.array[0] == 1);
981 assert(i.array[1] == 2);
982 assert(i.array[2] == 3);
983 assert(i.array[3] == 4);
984
985 uint4 ui = [1,2,3,4];
986 assert(ui.array[0] == 1);
987 assert(ui.array[1] == 2);
988 assert(ui.array[2] == 3);
989 assert(ui.array[3] == 4);
990
991 long2 l = [1,2];
992 assert(l.array[0] == 1);
993 assert(l.array[1] == 2);
994
995 ulong2 ul = [1,2];
996 assert(ul.array[0] == 1);
997 assert(ul.array[1] == 2);
998
999 float4 f = [1,2,3,4];
1000 assert(f.array[0] == 1);
1001 assert(f.array[1] == 2);
1002 assert(f.array[2] == 3);
1003 assert(f.array[3] == 4);
1004
1005 double2 d = [1,2];
1006 assert(d.array[0] == 1);
1007 assert(d.array[1] == 2);
1008 }
1009
1010 /*****************************************/
1011
1012 byte16 b = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
1013 ubyte16 ub = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
1014 short8 s = [1,2,3,4,5,6,7,8];
1015 ushort8 us = [1,2,3,4,5,6,7,8];
1016 int4 i = [1,2,3,4];
1017 uint4 ui = [1,2,3,4];
1018 long2 l = [1,2];
1019 ulong2 ul = [1,2];
1020 float4 f = [1,2,3,4];
1021 double2 d = [1,2];
1022
test7413_2()1023 void test7413_2()
1024 {
1025 assert(b.array[0] == 1);
1026 assert(b.array[1] == 2);
1027 assert(b.array[2] == 3);
1028 assert(b.array[3] == 4);
1029 assert(b.array[4] == 5);
1030 assert(b.array[5] == 6);
1031 assert(b.array[6] == 7);
1032 assert(b.array[7] == 8);
1033 assert(b.array[8] == 9);
1034 assert(b.array[9] == 10);
1035 assert(b.array[10] == 11);
1036 assert(b.array[11] == 12);
1037 assert(b.array[12] == 13);
1038 assert(b.array[13] == 14);
1039 assert(b.array[14] == 15);
1040 assert(b.array[15] == 16);
1041
1042 assert(ub.array[0] == 1);
1043 assert(ub.array[1] == 2);
1044 assert(ub.array[2] == 3);
1045 assert(ub.array[3] == 4);
1046 assert(ub.array[4] == 5);
1047 assert(ub.array[5] == 6);
1048 assert(ub.array[6] == 7);
1049 assert(ub.array[7] == 8);
1050 assert(ub.array[8] == 9);
1051 assert(ub.array[9] == 10);
1052 assert(ub.array[10] == 11);
1053 assert(ub.array[11] == 12);
1054 assert(ub.array[12] == 13);
1055 assert(ub.array[13] == 14);
1056 assert(ub.array[14] == 15);
1057 assert(ub.array[15] == 16);
1058
1059 assert(s.array[0] == 1);
1060 assert(s.array[1] == 2);
1061 assert(s.array[2] == 3);
1062 assert(s.array[3] == 4);
1063 assert(s.array[4] == 5);
1064 assert(s.array[5] == 6);
1065 assert(s.array[6] == 7);
1066 assert(s.array[7] == 8);
1067
1068 assert(us.array[0] == 1);
1069 assert(us.array[1] == 2);
1070 assert(us.array[2] == 3);
1071 assert(us.array[3] == 4);
1072 assert(us.array[4] == 5);
1073 assert(us.array[5] == 6);
1074 assert(us.array[6] == 7);
1075 assert(us.array[7] == 8);
1076
1077 assert(i.array[0] == 1);
1078 assert(i.array[1] == 2);
1079 assert(i.array[2] == 3);
1080 assert(i.array[3] == 4);
1081
1082 assert(ui.array[0] == 1);
1083 assert(ui.array[1] == 2);
1084 assert(ui.array[2] == 3);
1085 assert(ui.array[3] == 4);
1086
1087 assert(l.array[0] == 1);
1088 assert(l.array[1] == 2);
1089
1090 assert(ul.array[0] == 1);
1091 assert(ul.array[1] == 2);
1092
1093 assert(f.array[0] == 1);
1094 assert(f.array[1] == 2);
1095 assert(f.array[2] == 3);
1096 assert(f.array[3] == 4);
1097
1098 assert(d.array[0] == 1);
1099 assert(d.array[1] == 2);
1100 }
1101
1102 /*****************************************/
1103
bug8060(float x)1104 float bug8060(float x) {
1105 int i = *cast(int*)&x;
1106 ++i;
1107 return *cast(float*)&i;
1108 }
1109
1110 /*****************************************/
1111 // https://issues.dlang.org/show_bug.cgi?id=9200
1112
bar9200(double[2]a)1113 void bar9200(double[2] a)
1114 {
1115 assert(a[0] == 1);
1116 assert(a[1] == 2);
1117 }
1118
v9200(double2 * a)1119 double2 * v9200(double2* a)
1120 {
1121 return a;
1122 }
1123
test9200()1124 void test9200()
1125 {
1126 double2 a = [1, 2];
1127
1128 *v9200(&a) = a;
1129
1130 bar9200(a.array);
1131 }
1132
1133 /*****************************************/
1134 // https://issues.dlang.org/show_bug.cgi?id=9304
1135 // https://issues.dlang.org/show_bug.cgi?id=9322
1136
foo9304(float4 a)1137 float4 foo9304(float4 a)
1138 {
1139 return -a;
1140 }
1141
1142
test9304()1143 void test9304()
1144 {
1145 auto a = foo9304([0, 1, 2, 3]);
1146 //writeln(a.array);
1147 assert(a.array == [0,-1,-2,-3]);
1148 }
1149
1150 /*****************************************/
1151
test9910()1152 void test9910()
1153 {
1154 float4 f = [1, 1, 1, 1];
1155 auto works = f + 3;
1156 auto bug = 3 + f;
1157
1158 assert (works.array == [4,4,4,4]);
1159 assert (bug.array == [4,4,4,4]); // no property 'array' for type 'int'
1160 }
1161
1162 /*****************************************/
1163
1164 bool normalize(double[] range, double sum = 1)
1165 {
1166 double s = 0;
1167 const length = range.length;
foreach(e;range)1168 foreach (e; range)
1169 {
1170 s += e;
1171 }
1172 if (s == 0)
1173 {
1174 return false;
1175 }
1176 return true;
1177 }
1178
test12852()1179 void test12852()
1180 {
1181 double[3] range = [0.0, 0.0, 0.0];
1182 assert(normalize(range[]) == false);
1183 range[1] = 3.0;
1184 assert(normalize(range[]) == true);
1185 }
1186
1187 /*****************************************/
1188
test9449()1189 void test9449()
1190 {
1191 ubyte16[1] table;
1192 }
1193
1194 /*****************************************/
1195
test9449_2()1196 void test9449_2()
1197 {
1198 float[4][2] m = [[2.0, 1, 3, 4], [5.0, 6, 7, 8]]; // segfault
1199
1200 assert(m[0][0] == 2.0);
1201 assert(m[0][1] == 1);
1202 assert(m[0][2] == 3);
1203 assert(m[0][3] == 4);
1204
1205 assert(m[1][0] == 5.0);
1206 assert(m[1][1] == 6);
1207 assert(m[1][2] == 7);
1208 assert(m[1][3] == 8);
1209 }
1210
1211 /*****************************************/
1212 // https://issues.dlang.org/show_bug.cgi?id=13841
1213
test13841()1214 void test13841()
1215 {
1216 alias Vector16s = TypeTuple!(
1217 void16, byte16, short8, int4, long2,
1218 ubyte16, ushort8, uint4, ulong2, float4, double2);
1219 foreach (V1; Vector16s)
1220 {
1221 foreach (V2; Vector16s)
1222 {
1223 V1 v1 = void;
1224 V2 v2 = void;
1225 static if (is(V1 == V2))
1226 {
1227 static assert( is(typeof(true ? v1 : v2) == V1));
1228 }
1229 else
1230 {
1231 static assert(!is(typeof(true ? v1 : v2)));
1232 }
1233 }
1234 }
1235 }
1236
1237 /*****************************************/
1238 // https://issues.dlang.org/show_bug.cgi?id=12776
1239
test12776()1240 void test12776()
1241 {
1242 alias Vector16s = TypeTuple!(
1243 void16, byte16, short8, int4, long2,
1244 ubyte16, ushort8, uint4, ulong2, float4, double2);
1245 foreach (V; Vector16s)
1246 {
1247 static assert(is(typeof( V .init) == V ));
1248 static assert(is(typeof( const(V).init) == const(V)));
1249 static assert(is(typeof( inout( V).init) == inout( V)));
1250 static assert(is(typeof( inout(const V).init) == inout(const V)));
1251 static assert(is(typeof(shared( V).init) == shared( V)));
1252 static assert(is(typeof(shared( const V).init) == shared( const V)));
1253 static assert(is(typeof(shared(inout V).init) == shared(inout V)));
1254 static assert(is(typeof(shared(inout const V).init) == shared(inout const V)));
1255 static assert(is(typeof( immutable(V).init) == immutable(V)));
1256 }
1257 }
1258
1259 /*****************************************/
1260
foo13988(double[]arr)1261 void foo13988(double[] arr)
1262 {
1263 static ulong repr(double d) { return *cast(ulong*)&d; }
1264 foreach (x; arr)
1265 assert(repr(arr[0]) == *cast(ulong*)&(arr[0]));
1266 }
1267
1268
test13988()1269 void test13988()
1270 {
1271 double[] arr = [3.0];
1272 foo13988(arr);
1273 }
1274
1275 /*****************************************/
1276 // https://issues.dlang.org/show_bug.cgi?id=15123
1277
test15123()1278 void test15123()
1279 {
1280 alias Vector16s = TypeTuple!(
1281 void16, byte16, short8, int4, long2,
1282 ubyte16, ushort8, uint4, ulong2, float4, double2);
1283 foreach (V; Vector16s)
1284 {
1285 auto x = V.init;
1286 }
1287 }
1288
1289 /*****************************************/
1290 // https://issues.dlang.org/show_bug.cgi?id=15144
1291
test15144()1292 void test15144()
1293 {
1294 enum ubyte16 csXMM1 = ['a','b','c',0,0,0,0,0];
1295 __gshared ubyte16 csXMM2 = ['a','b','c',0,0,0,0,0];
1296 immutable ubyte16 csXMM3 = ['a','b','c',0,0,0,0,0];
1297 }
1298
1299 /*****************************************/
1300 // https://issues.dlang.org/show_bug.cgi?id=13927
1301
test13927(ulong2 a)1302 void test13927(ulong2 a)
1303 {
1304 ulong2 b = [long.min, long.min];
1305 auto tmp = a - b;
1306 }
1307
1308 /*****************************************/
1309 // https://issues.dlang.org/show_bug.cgi?id=16488
1310
foo_byte16(byte t,byte s)1311 void foo_byte16(byte t, byte s)
1312 {
1313 byte16 f = s;
1314 auto p = cast(byte*)&f;
1315 foreach (i; 0 .. 16)
1316 assert(p[i] == s);
1317 }
1318
foo_ubyte16(ubyte t,ubyte s)1319 void foo_ubyte16(ubyte t, ubyte s)
1320 {
1321 ubyte16 f = s;
1322 auto p = cast(ubyte*)&f;
1323 foreach (i; 0 .. 16)
1324 assert(p[i] == s);
1325 }
1326
1327
foo_short8(short t,short s)1328 void foo_short8(short t, short s)
1329 {
1330 short8 f = s;
1331 auto p = cast(short*)&f;
1332 foreach (i; 0 .. 8)
1333 assert(p[i] == s);
1334 }
1335
foo_ushort8(ushort t,ushort s)1336 void foo_ushort8(ushort t, ushort s)
1337 {
1338 ushort8 f = s;
1339 auto p = cast(ushort*)&f;
1340 foreach (i; 0 .. 8)
1341 assert(p[i] == s);
1342 }
1343
1344
foo_int4(int t,int s)1345 void foo_int4(int t, int s)
1346 {
1347 int4 f = s;
1348 auto p = cast(int*)&f;
1349 foreach (i; 0 .. 4)
1350 assert(p[i] == s);
1351 }
1352
foo_uint4(uint t,uint s,uint u)1353 void foo_uint4(uint t, uint s, uint u)
1354 {
1355 uint4 f = s;
1356 auto p = cast(uint*)&f;
1357 foreach (i; 0 .. 4)
1358 assert(p[i] == s);
1359 }
1360
1361
foo_long2(long t,long s,long u)1362 void foo_long2(long t, long s, long u)
1363 {
1364 long2 f = s;
1365 auto p = cast(long*)&f;
1366 foreach (i; 0 .. 2)
1367 assert(p[i] == s);
1368 }
1369
foo_ulong2(ulong t,ulong s)1370 void foo_ulong2(ulong t, ulong s)
1371 {
1372 ulong2 f = s;
1373 auto p = cast(ulong*)&f;
1374 foreach (i; 0 .. 2)
1375 assert(p[i] == s);
1376 }
1377
foo_float4(float t,float s)1378 void foo_float4(float t, float s)
1379 {
1380 float4 f = s;
1381 auto p = cast(float*)&f;
1382 foreach (i; 0 .. 4)
1383 assert(p[i] == s);
1384 }
1385
foo_double2(double t,double s,double u)1386 void foo_double2(double t, double s, double u)
1387 {
1388 double2 f = s;
1389 auto p = cast(double*)&f;
1390 foreach (i; 0 .. 2)
1391 assert(p[i] == s);
1392 }
1393
1394
test16448()1395 void test16448()
1396 {
1397 foo_byte16(5, -10);
1398 foo_ubyte16(5, 11);
1399
1400 foo_short8(5, -6);
1401 foo_short8(5, 7);
1402
1403 foo_int4(5, -6);
1404 foo_uint4(5, 0x12345678, 22);
1405
1406 foo_long2(5, -6, 1);
1407 foo_ulong2(5, 0x12345678_87654321L);
1408
1409 foo_float4(5, -6);
1410 foo_double2(5, -6, 2);
1411 }
1412
1413 /*****************************************/
1414
foo_byte32(byte t,byte s)1415 void foo_byte32(byte t, byte s)
1416 {
1417 byte32 f = s;
1418 auto p = cast(byte*)&f;
1419 foreach (i; 0 .. 32)
1420 assert(p[i] == s);
1421 }
1422
foo_ubyte32(ubyte t,ubyte s)1423 void foo_ubyte32(ubyte t, ubyte s)
1424 {
1425 ubyte32 f = s;
1426 auto p = cast(ubyte*)&f;
1427 foreach (i; 0 .. 32)
1428 assert(p[i] == s);
1429 }
1430
foo_short16(short t,short s)1431 void foo_short16(short t, short s)
1432 {
1433 short16 f = s;
1434 auto p = cast(short*)&f;
1435 foreach (i; 0 .. 16)
1436 assert(p[i] == s);
1437 }
1438
foo_ushort16(ushort t,ushort s)1439 void foo_ushort16(ushort t, ushort s)
1440 {
1441 ushort16 f = s;
1442 auto p = cast(ushort*)&f;
1443 foreach (i; 0 .. 16)
1444 assert(p[i] == s);
1445 }
1446
foo_int8(int t,int s)1447 void foo_int8(int t, int s)
1448 {
1449 int8 f = s;
1450 auto p = cast(int*)&f;
1451 foreach (i; 0 .. 8)
1452 assert(p[i] == s);
1453 }
1454
foo_uint8(uint t,uint s,uint u)1455 void foo_uint8(uint t, uint s, uint u)
1456 {
1457 uint8 f = s;
1458 auto p = cast(uint*)&f;
1459 foreach (i; 0 .. 8)
1460 assert(p[i] == s);
1461 }
1462
foo_long4(long t,long s,long u)1463 void foo_long4(long t, long s, long u)
1464 {
1465 long4 f = s;
1466 auto p = cast(long*)&f;
1467 foreach (i; 0 .. 4)
1468 assert(p[i] == s);
1469 }
1470
foo_ulong4(ulong t,ulong s)1471 void foo_ulong4(ulong t, ulong s)
1472 {
1473 ulong4 f = s;
1474 auto p = cast(ulong*)&f;
1475 foreach (i; 0 .. 4)
1476 assert(p[i] == s);
1477 }
1478
foo_float8(float t,float s)1479 void foo_float8(float t, float s)
1480 {
1481 float8 f = s;
1482 auto p = cast(float*)&f;
1483 foreach (i; 0 .. 8)
1484 assert(p[i] == s);
1485 }
1486
foo_double4(double t,double s,double u)1487 void foo_double4(double t, double s, double u)
1488 {
1489 double4 f = s;
1490 auto p = cast(double*)&f;
1491 foreach (i; 0 .. 4)
1492 assert(p[i] == s);
1493 }
1494
test16448_32()1495 void test16448_32()
1496 {
1497 import core.cpuid;
1498 if (!core.cpuid.avx)
1499 return;
1500
1501 foo_byte32(5, -10);
1502 foo_ubyte32(5, 11);
1503
1504 foo_short16(5, -6);
1505 foo_short16(5, 7);
1506
1507 foo_int8(5, -6);
1508 foo_uint8(5, 0x12345678, 22);
1509
1510 foo_long4(5, -6, 1);
1511 foo_ulong4(5, 0x12345678_87654321L);
1512
1513 foo_float8(5, -6);
1514 foo_double4(5, -6, 2);
1515 }
1516
1517
1518 /*****************************************/
1519 // https://issues.dlang.org/show_bug.cgi?id=16703
1520
index(float4 f4,size_t i)1521 float index(float4 f4, size_t i)
1522 {
1523 return f4[i];
1524 //return (*cast(float[4]*)&f4)[2];
1525 }
1526
slice(float4 f4)1527 float[4] slice(float4 f4)
1528 {
1529 return f4[];
1530 }
1531
slice2(float4 f4,size_t lwr,size_t upr,size_t i)1532 float slice2(float4 f4, size_t lwr, size_t upr, size_t i)
1533 {
1534 float[] fa = f4[lwr .. upr];
1535 return fa[i];
1536 }
1537
test16703()1538 void test16703()
1539 {
1540 float4 f4 = [1,2,3,4];
1541 assert(index(f4, 0) == 1);
1542 assert(index(f4, 1) == 2);
1543 assert(index(f4, 2) == 3);
1544 assert(index(f4, 3) == 4);
1545
1546 float[4] fsa = slice(f4);
1547 assert(fsa == [1.0f,2,3,4]);
1548
1549 assert(slice2(f4, 1, 3, 0) == 2);
1550 assert(slice2(f4, 1, 3, 1) == 3);
1551 }
1552
1553 /*****************************************/
1554
1555 struct Sunsto
1556 {
1557 align (1): // make sure f4 is misaligned
1558 byte b;
1559 union
1560 {
1561 float4 f4;
1562 ubyte[16] a;
1563 }
1564 }
1565
1566 ubyte[16] foounsto()
1567 {
1568 float4 vf = 6;
1569 Sunsto s;
1570 s.f4 = vf * 2;
1571 vf = s.f4;
1572
1573 return s.a;
1574 }
1575
1576 void testOPvecunsto()
1577 {
1578 auto a = foounsto();
1579 version (LittleEndian)
1580 assert(a == [0, 0, 64, 65, 0, 0, 64, 65, 0, 0, 64, 65, 0, 0, 64, 65]);
1581 version (BigEndian)
1582 assert(a == [65, 64, 0, 0, 65, 64, 0, 0, 65, 64, 0, 0, 65, 64, 0, 0]);
1583 }
1584
1585 /*****************************************/
1586 // https://issues.dlang.org/show_bug.cgi?id=10447
1587
1588 void test10447()
1589 {
1590 immutable __vector(double[2]) a = [1.0, 2.0];
1591 __vector(double[2]) r;
1592 r += a;
1593 r = r * a;
1594 }
1595
1596 /*****************************************/
1597 // https://issues.dlang.org/show_bug.cgi?id=17237
1598
1599 struct S17237
1600 {
1601 bool a;
1602 struct
1603 {
1604 bool b;
1605 int8 c;
1606 }
1607 }
1608
1609 static assert(S17237.a.offsetof == 0);
1610 static assert(S17237.b.offsetof == 32);
1611 static assert(S17237.c.offsetof == 64);
1612
1613 /*****************************************/
1614 // https://issues.dlang.org/show_bug.cgi?id=16697
1615
1616 static assert(!is(float == __vector));
1617 static assert(!is(float[1] == __vector));
1618 static assert(!is(float[4] == __vector));
1619 static assert( is(__vector(float[4]) == __vector));
1620 static assert(!is(__vector(float[3]) == __vector));
1621 static assert(!is(__vector(float[5]) == __vector));
1622 static assert( is(__vector(float[4]) X == __vector) && is(X == float[4]));
1623 static assert( is(__vector(byte[16]) X == __vector) && is(X == byte[16]));
1624
1625 /*****************************************/
1626 // https://issues.dlang.org/show_bug.cgi?id=17720
1627
1628 void test17720()
1629 {
1630 alias Vector16s = TypeTuple!(
1631 void16, byte16, short8, int4, long2,
1632 ubyte16, ushort8, uint4, ulong2, float4, double2);
1633 alias Vector32s = TypeTuple!(
1634 void32, byte32, short16, int8, long4,
1635 ubyte32, ushort16, uint8, ulong4, float8, double4);
1636
1637 // OK: __vector(T) -> __vector(void[]) of same size.
1638 // NG: __vector(T) -> __vector(void[]) of different size.
1639 // NG: explicit cast __vector(T) -> __vector(void[]) of different size.
1640 foreach (V; Vector16s)
1641 {
1642 static assert( __traits(compiles, { void16 v = V.init; }));
1643 static assert(!__traits(compiles, { void32 v = V.init; }));
1644 static assert(!__traits(compiles, { void32 v = cast(void32)V.init; }));
1645 }
1646 foreach (V; Vector32s)
1647 {
1648 static assert( __traits(compiles, { void32 v = V.init; }));
1649 static assert(!__traits(compiles, { void16 v = V.init; }));
1650 static assert(!__traits(compiles, { void16 v = cast(void16)V.init; }));
1651 }
1652
1653 // NG: __vector(T) -> __vector(T) of same size.
1654 // OK: explicit cast __vector(T) -> __vector(T) of same size.
1655 // NG: __vector(T) -> __vector(T) of different size.
1656 // NG: explicit cast __vector(T) -> __vector(T) of different size.
1657 foreach (V; Vector16s)
1658 {
1659 static if (is(V == double2))
1660 {
1661 static assert(!__traits(compiles, { long2 v = V.init; }));
1662 static assert( __traits(compiles, { long2 v = cast(long2)V.init; }));
1663 }
1664 else
1665 {
1666 static assert(!__traits(compiles, { double2 v = V.init; }));
1667 static assert( __traits(compiles, { double2 v = cast(double2)V.init; }));
1668 }
1669 static assert(!__traits(compiles, { double4 v = V.init; }));
1670 static assert(!__traits(compiles, { double4 v = cast(double4)V.init; }));
1671 }
1672 foreach (V; Vector32s)
1673 {
1674 static if (is(V == double4))
1675 {
1676 static assert(!__traits(compiles, { long4 v = V.init; }));
1677 static assert( __traits(compiles, { long4 v = cast(long4)V.init; }));
1678 }
1679 else
1680 {
1681 static assert(!__traits(compiles, { double4 v = V.init; }));
1682 static assert( __traits(compiles, { double4 v = cast(double4)V.init; }));
1683 }
1684 static assert(!__traits(compiles, { double2 v = V.init; }));
1685 static assert(!__traits(compiles, { double2 v = cast(double2)V.init; }));
1686 }
1687 }
1688
1689 /*****************************************/
1690 // https://issues.dlang.org/show_bug.cgi?id=17695
1691
1692 void test17695(__vector(ubyte[16]) a)
1693 {
1694 auto b = -a;
1695 }
1696
1697 /*****************************************/
1698 // https://issues.dlang.org/show_bug.cgi?id=19223
1699
1700 int test19223a(const int[4] x)
1701 {
1702 int sum = 0;
1703 foreach (i; x) sum += i;
1704 return sum;
1705 }
1706
1707 void test19223()
1708 {
1709 int4 v1 = int4.init;
1710 assert(test19223a(v1.array) == 0);
1711 assert(test19223a(int4.init.array) == 0);
1712 }
1713
1714 /*****************************************/
1715 // https://issues.dlang.org/show_bug.cgi?id=19224
1716
1717 float test19224(const float[4] val)
1718 {
1719 float sum = 0;
1720 foreach (x; val) sum += x;
1721 return sum;
1722 }
1723
1724 enum x19224 = test19224(float4.init.array);
1725 static assert(x19224 is float.nan);
1726
1727 enum y19224 = test19224(float4(1).array);
1728 static assert(y19224 == 4);
1729
1730 /*****************************************/
1731 // https://issues.dlang.org/show_bug.cgi?id=19607
1732
1733 int test19607a(const int[4] x)
1734 {
1735 int sum = 0;
1736 foreach (i; x) sum += i;
1737 return sum;
1738 }
1739
1740 void test19607()
1741 {
1742 int4 v1 = 1;
1743 assert(test19607a(v1.array) == 4);
1744 assert(test19607a(int4(2).array) == 8);
1745 }
1746
1747 /*****************************************/
1748 // https://issues.dlang.org/show_bug.cgi?id=19627
1749
1750 enum int[4] fail19627 = cast(int[4])int4(0);
1751
1752 /*****************************************/
1753 // https://issues.dlang.org/show_bug.cgi?id=19628
1754
1755 enum ice19628a = int4.init[0];
1756 enum ice19628b = int4.init.array[0];
1757 enum ice19628c = (cast(int[4])int4.init.array)[0];
1758 enum ice19628d = (cast(int[4])int4.init)[0];
1759
1760 enum int4 v19628a = int4.init;
1761 enum idx19628a = v19628a[0];
1762 static assert(idx19628a == 0);
1763
1764 enum int[4] v19628b = int4.init.array;
1765 enum idx19628b = v19628b[0];
1766 static assert(idx19628b == 0);
1767
1768 enum int[4] v19628c = cast(int[4])int4.init.array;
1769 enum idx19628c = v19628c[0];
1770 static assert(idx19628c == 0);
1771
1772 enum int[4] v19628d = cast(int[4])int4.init;
1773 enum idx19628d = v19628d[0];
1774 static assert(idx19628d == 0);
1775
1776 immutable int4 v19628e = int4.init;
1777 immutable idx19628e = v19628e[0];
1778 static assert(idx19628e == 0);
1779
1780 immutable int[4] v19628f = int4.init.array;
1781 immutable idx19628f = v19628f[0];
1782 static assert(idx19628f == 0);
1783
1784 immutable int[4] v19628g = cast(int[4])int4.init.array;
1785 immutable idx19628g = v19628g[0];
1786 static assert(idx19628g == 0);
1787
1788 immutable idx19628h = v19628h[0];
1789 immutable int[4] v19628h = cast(int[4])int4.init;
1790 static assert(idx19628h == 0);
1791
1792 /*****************************************/
1793 // https://issues.dlang.org/show_bug.cgi?id=19629
1794
1795 enum fail19629a = int4(0)[0];
1796 enum fail19629b = int4(0).array[0];
1797 enum fail19629c = (cast(int[4])int4(0).array)[0];
1798 enum fail19628d = (cast(int[4])int4(0))[0];
1799
1800 enum int4 v19629a = int4(0);
1801 enum idx19629a = v19629a[0];
1802 static assert(idx19629a == 0);
1803
1804 enum int[4] v19629b = int4(0).array;
1805 enum idx19629b = v19629b[0];
1806 static assert(idx19629b == 0);
1807
1808 enum int[4] v19629c = cast(int[4])int4(0).array;
1809 enum idx19629c = v19629c[0];
1810 static assert(idx19629c == 0);
1811
1812 enum int[4] v19629d = cast(int[4])int4(0);
1813 enum idx19629d = v19629d[0];
1814 static assert(idx19629d == 0);
1815
1816 immutable int4 v19629e = int4(0);
1817 immutable idx19629e = v19629e[0];
1818 static assert(idx19629e == 0);
1819
1820 immutable int[4] v19629f = int4(0).array;
1821 immutable idx19629f = v19629f[0];
1822 static assert(idx19629f == 0);
1823
1824 immutable int[4] v19629g = cast(int[4])int4(0).array;
1825 immutable idx19629g = v19629g[0];
1826 static assert(idx19629g == 0);
1827
1828 immutable int[4] v19629h = cast(int[4])int4(0);
1829 immutable idx19629h = v19629h[0];
1830 static assert(idx19629h == 0);
1831
1832 /*****************************************/
1833 // https://issues.dlang.org/show_bug.cgi?id=19630
1834
1835 enum fail19630a = int4.init[1..2];
1836 enum fail19630b = int4.init.array[1..2];
1837 enum fail19630c = (cast(int[4])int4.init.array)[1..2];
1838 enum fail19630d = (cast(int[4])int4.init)[1..2];
1839 enum fail19630e = int4(0)[1..2];
1840 enum fail19630f = int4(0).array[1..2];
1841 enum fail19630g = (cast(int[4])int4(0).array)[1..2];
1842 enum fail19630h = (cast(int[4])int4(0))[1..2];
1843
1844 enum int4 v19630a = int4.init;
1845 enum slice19630a = v19630a[1..2];
1846 static assert(slice19630a == [0]);
1847
1848 enum int[4] v19630b = int4.init.array;
1849 enum slice19630b = v19630b[1..2];
1850 static assert(slice19630b == [0]);
1851
1852 enum int[4] v19630c = cast(int[4])int4.init.array;
1853 enum slice19630c = v19630c[1..2];
1854 static assert(slice19630c == [0]);
1855
1856 enum int[4] v19630d = cast(int[4])int4.init;
1857 enum slice19630d = v19630d[1..2];
1858 static assert(slice19630d == [0]);
1859
1860 enum int4 v19630e = int4(0);
1861 enum slice19630e = v19630e[1..2];
1862 static assert(slice19630e == [0]);
1863
1864 enum int[4] v19630f = int4(0).array;
1865 enum slice19630f = v19630f[1..2];
1866 static assert(slice19630f == [0]);
1867
1868 enum int[4] v19630g = cast(int[4])int4(0).array;
1869 enum slice19630g = v19630g[1..2];
1870 static assert(slice19630g == [0]);
1871
1872 enum int[4] v19630h = cast(int[4])int4(0);
1873 enum slice19630h = v19630h[1..2];
1874 static assert(slice19630h == [0]);
1875
1876 immutable int4 v19630i = int4.init;
1877 immutable slice19630i = v19630i[1..2];
1878 static assert(slice19630i == [0]);
1879
1880 immutable int[4] v19630j = int4.init.array;
1881 immutable slice19630j = v19630j[1..2];
1882 static assert(slice19630j == [0]);
1883
1884 immutable int[4] v19630k = cast(int[4])int4.init.array;
1885 immutable slice19630k = v19630k[1..2];
1886 static assert(slice19630k == [0]);
1887
1888 immutable int[4] v19630l = cast(int[4])int4.init;
1889 immutable slice19630l = v19630l[1..2];
1890 static assert(slice19630l == [0]);
1891
1892 immutable int4 v19630m = int4(0);
1893 immutable slice19630m = v19630m[1..2];
1894 static assert(slice19630m == [0]);
1895
1896 immutable int[4] v19630n = int4(0).array;
1897 immutable slice19630n = v19630n[1..2];
1898 static assert(slice19630n == [0]);
1899
1900 immutable int[4] v19630o = cast(int[4])int4(0).array;
1901 immutable slice19630o = v19630o[1..2];
1902 static assert(slice19630o == [0]);
1903
1904 immutable int[4] v19630p = cast(int[4])int4(0);
1905 immutable slice19630p = v19630p[1..2];
1906 static assert(slice19630p == [0]);
1907
1908 /*****************************************/
1909
1910 int main()
1911 {
1912 test1();
1913 test2();
1914 test2b();
1915 test2c();
1916 test2d();
1917 test2e();
1918 test2f();
1919 test2g();
1920 test2h();
1921 test2i();
1922 test2j();
1923
1924 test4();
1925 test7411();
1926
1927 test7951();
1928 test7951_2();
1929 test7414();
1930 test7413();
1931 test7413_2();
1932 test9200();
1933 test9304();
1934 test9910();
1935 test12852();
1936 test9449();
1937 test9449_2();
1938 test13988();
1939 test16448();
1940 test16448_32();
1941 test16703();
1942 testOPvecunsto();
1943 test10447();
1944
1945 test19223();
1946 test19607();
1947
1948 return 0;
1949 }
1950