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