1 // RUN: %clang_cc1 -triple s390x-linux-gnu -fzvector \
2 // RUN: -flax-vector-conversions=none -W -Wall -Wconversion \
3 // RUN: -Werror -fsyntax-only -verify %s
4
5 vector signed char sc, sc2;
6 vector unsigned char uc, uc2;
7 vector bool char bc, bc2;
8
9 vector signed short ss, ss2;
10 vector unsigned short us, us2;
11 vector bool short bs, bs2;
12
13 vector signed int si, si2;
14 vector unsigned int ui, ui2;
15 vector bool int bi, bi2;
16
17 vector signed long long sl, sl2;
18 vector unsigned long long ul, ul2;
19 vector bool long long bl, bl2;
20
21 vector double fd, fd2;
22
23 vector long ll; // expected-error {{cannot use 'long' with '__vector'}}
24 vector float ff; // expected-error {{cannot use 'float' with '__vector'}}
25
26 signed char sc_scalar;
27 unsigned char uc_scalar;
28
29 signed short ss_scalar;
30 unsigned short us_scalar;
31
32 signed int si_scalar;
33 unsigned int ui_scalar;
34
35 signed long sl_scalar;
36 unsigned long ul_scalar;
37
38 double fd_scalar;
39
40 // Verify that __vector is also recognized
41 __vector signed char sc3;
42 __vector unsigned char uc3;
43 __vector bool char bc3;
44 __vector signed short ss3;
45 __vector unsigned short us3;
46 __vector bool short bs3;
47 __vector signed int si3;
48 __vector unsigned int ui3;
49 __vector bool int bi3;
50 __vector signed long long sl3;
51 __vector unsigned long long ul3;
52 __vector bool long long bl3;
53 __vector double fd3;
54 __vector long ll3; // expected-error {{cannot use 'long' with '__vector'}}
55 __vector float ff3; // expected-error {{cannot use 'float' with '__vector'}}
56
57 // Likewise for __bool
58 vector __bool char bc4;
59 vector __bool short bs4;
60 vector __bool int bi4;
61 vector __bool long long bl4;
62 __vector __bool char bc5;
63 __vector __bool short bs5;
64 __vector __bool int bi5;
65 __vector __bool long long bl5;
66
67 // Verify operation of vec_step
68 int res_sc[vec_step(sc) == 16 ? 1 : -1];
69 int res_uc[vec_step(uc) == 16 ? 1 : -1];
70 int res_bc[vec_step(bc) == 16 ? 1 : -1];
71 int res_ss[vec_step(ss) == 8 ? 1 : -1];
72 int res_us[vec_step(us) == 8 ? 1 : -1];
73 int res_bs[vec_step(bs) == 8 ? 1 : -1];
74 int res_si[vec_step(si) == 4 ? 1 : -1];
75 int res_ui[vec_step(ui) == 4 ? 1 : -1];
76 int res_bi[vec_step(bi) == 4 ? 1 : -1];
77 int res_sl[vec_step(sl) == 2 ? 1 : -1];
78 int res_ul[vec_step(ul) == 2 ? 1 : -1];
79 int res_bl[vec_step(bl) == 2 ? 1 : -1];
80 int res_fd[vec_step(fd) == 2 ? 1 : -1];
81
82
foo(void)83 void foo(void)
84 {
85 // -------------------------------------------------------------------------
86 // Test assignment.
87 // -------------------------------------------------------------------------
88
89 sc = sc2;
90 uc = uc2;
91 bc = bc2;
92
93 ss = ss2;
94 us = us2;
95 bs = bs2;
96
97 si = si2;
98 ui = ui2;
99 bi = bi2;
100
101 sl = sl2;
102 ul = ul2;
103 bl = bl2;
104 fd = fd2;
105
106 sc = uc2; // expected-error {{incompatible type}}
107 sc = bc2; // expected-error {{incompatible type}}
108 uc = sc2; // expected-error {{incompatible type}}
109 uc = bc2; // expected-error {{incompatible type}}
110 bc = sc2; // expected-error {{incompatible type}}
111 bc = uc2; // expected-error {{incompatible type}}
112
113 sc = sc_scalar; // expected-error {{incompatible type}}
114 sc = uc_scalar; // expected-error {{incompatible type}}
115 uc = sc_scalar; // expected-error {{incompatible type}}
116 uc = uc_scalar; // expected-error {{incompatible type}}
117 bc = sc_scalar; // expected-error {{incompatible type}}
118 bc = uc_scalar; // expected-error {{incompatible type}}
119
120 sc = ss2; // expected-error {{incompatible type}}
121 sc = si2; // expected-error {{incompatible type}}
122 sc = sl2; // expected-error {{incompatible type}}
123 sc = fd2; // expected-error {{incompatible type}}
124
125 ss = sc2; // expected-error {{incompatible type}}
126 si = sc2; // expected-error {{incompatible type}}
127 sl = sc2; // expected-error {{incompatible type}}
128 fd = sc2; // expected-error {{incompatible type}}
129
130 uc = us2; // expected-error {{incompatible type}}
131 uc = ui2; // expected-error {{incompatible type}}
132 uc = ul2; // expected-error {{incompatible type}}
133 uc = fd2; // expected-error {{incompatible type}}
134
135 us = uc2; // expected-error {{incompatible type}}
136 ui = uc2; // expected-error {{incompatible type}}
137 ul = uc2; // expected-error {{incompatible type}}
138 fd = uc2; // expected-error {{incompatible type}}
139
140 bc = us2; // expected-error {{incompatible type}}
141 bc = ui2; // expected-error {{incompatible type}}
142 bc = ul2; // expected-error {{incompatible type}}
143 bc = fd2; // expected-error {{incompatible type}}
144
145 bs = bc2; // expected-error {{incompatible type}}
146 bi = bc2; // expected-error {{incompatible type}}
147 bl = bc2; // expected-error {{incompatible type}}
148 fd = bc2; // expected-error {{incompatible type}}
149
150 // -------------------------------------------------------------------------
151 // Test casts to same element width.
152 // -------------------------------------------------------------------------
153
154 sc = (vector signed char)bc2;
155 bc = (vector bool char)uc2;
156 uc = (vector unsigned char)sc2;
157
158 ss = (vector signed short)bs2;
159 bs = (vector bool short)us2;
160 us = (vector unsigned short)ss2;
161
162 si = (vector signed int)bi2;
163 bi = (vector bool int)ui2;
164 ui = (vector unsigned int)si2;
165
166 sl = (vector signed long long)bl2;
167 bl = (vector bool long long)ul2;
168 ul = (vector unsigned long long)fd2;
169 fd = (vector double)sl2;
170
171 // -------------------------------------------------------------------------
172 // Test casts to different element width.
173 // -------------------------------------------------------------------------
174
175 sc = (vector signed char)bs2;
176 bc = (vector bool char)us2;
177 uc = (vector unsigned char)fd2;
178
179 ss = (vector signed short)bi2;
180 bs = (vector bool short)ui2;
181 us = (vector unsigned short)fd2;
182
183 si = (vector signed int)bl2;
184 bi = (vector bool int)ul2;
185 ui = (vector unsigned int)fd2;
186
187 sl = (vector signed long long)bc2;
188 bl = (vector bool long long)uc2;
189 ul = (vector unsigned long long)sc2;
190 fd = (vector double)sc2;
191
192 // -------------------------------------------------------------------------
193 // Test ++.
194 // -------------------------------------------------------------------------
195
196 ++sc2;
197 ++uc2;
198 ++bc2; // expected-error {{cannot increment}}
199
200 ++ss2;
201 ++us2;
202 ++bs2; // expected-error {{cannot increment}}
203
204 ++si2;
205 ++ui2;
206 ++bi2; // expected-error {{cannot increment}}
207
208 ++sl2;
209 ++ul2;
210 ++bl2; // expected-error {{cannot increment}}
211
212 ++fd2;
213
214 sc++;
215 uc++;
216 bc++; // expected-error {{cannot increment}}
217
218 ss++;
219 us++;
220 bs++; // expected-error {{cannot increment}}
221
222 si++;
223 ui++;
224 bi++; // expected-error {{cannot increment}}
225
226 sl++;
227 ul++;
228 bl++; // expected-error {{cannot increment}}
229
230 fd++;
231
232 // -------------------------------------------------------------------------
233 // Test --.
234 // -------------------------------------------------------------------------
235
236 --sc2;
237 --uc2;
238 --bc2; // expected-error {{cannot decrement}}
239
240 --ss2;
241 --us2;
242 --bs2; // expected-error {{cannot decrement}}
243
244 --si2;
245 --ui2;
246 --bi2; // expected-error {{cannot decrement}}
247
248 --sl2;
249 --ul2;
250 --bl2; // expected-error {{cannot decrement}}
251
252 --fd2;
253
254 sc--;
255 uc--;
256 bc--; // expected-error {{cannot decrement}}
257
258 ss--;
259 us--;
260 bs--; // expected-error {{cannot decrement}}
261
262 si--;
263 ui--;
264 bi--; // expected-error {{cannot decrement}}
265
266 sl--;
267 ul--;
268 bl--; // expected-error {{cannot decrement}}
269
270 fd--;
271
272 // -------------------------------------------------------------------------
273 // Test unary +.
274 // -------------------------------------------------------------------------
275
276 sc = +sc2;
277 uc = +uc2;
278 bc = +bc2; // expected-error {{invalid argument type}}
279
280 ss = +ss2;
281 us = +us2;
282 bs = +bs2; // expected-error {{invalid argument type}}
283
284 si = +si2;
285 ui = +ui2;
286 bi = +bi2; // expected-error {{invalid argument type}}
287
288 sl = +sl2;
289 ul = +ul2;
290 bl = +bl2; // expected-error {{invalid argument type}}
291
292 fd = +fd2;
293
294 sc = +si2; // expected-error {{assigning to}}
295 ui = +si2; // expected-error {{assigning to}}
296 ui = +bi2; // expected-error {{invalid argument type}}
297
298 // -------------------------------------------------------------------------
299 // Test unary -.
300 // -------------------------------------------------------------------------
301
302 sc = -sc2;
303 uc = -uc2;
304 bc = -bc2; // expected-error {{invalid argument type}}
305
306 ss = -ss2;
307 us = -us2;
308 bs = -bs2; // expected-error {{invalid argument type}}
309
310 si = -si2;
311 ui = -ui2;
312 bi = -bi2; // expected-error {{invalid argument type}}
313
314 sl = -sl2;
315 ul = -ul2;
316 bl = -bl2; // expected-error {{invalid argument type}}
317
318 fd = -fd2;
319
320 sc = -si2; // expected-error {{assigning to}}
321 ui = -si2; // expected-error {{assigning to}}
322 ui = -bi2; // expected-error {{invalid argument type}}
323
324 // -------------------------------------------------------------------------
325 // Test ~.
326 // -------------------------------------------------------------------------
327
328 sc = ~sc2;
329 uc = ~uc2;
330 bc = ~bc2;
331
332 ss = ~ss2;
333 us = ~us2;
334 bs = ~bs2;
335
336 si = ~si2;
337 ui = ~ui2;
338 bi = ~bi2;
339
340 sl = ~sl2;
341 ul = ~ul2;
342 bl = ~bl2;
343
344 fd = ~fd2; // expected-error {{invalid argument}}
345
346 sc = ~si2; // expected-error {{assigning to}}
347 ui = ~si2; // expected-error {{assigning to}}
348 ui = ~bi2; // expected-error {{assigning to}}
349
350 // -------------------------------------------------------------------------
351 // Test binary +.
352 // -------------------------------------------------------------------------
353
354 sc = sc + sc2;
355 sc = sc + uc2; // expected-error {{cannot convert}}
356 sc = uc + sc2; // expected-error {{cannot convert}}
357 sc = sc + bc2;
358 sc = bc + sc2;
359
360 uc = uc + uc2;
361 uc = sc + uc2; // expected-error {{cannot convert}}
362 uc = uc + sc2; // expected-error {{cannot convert}}
363 uc = bc + uc2;
364 uc = uc + bc2;
365
366 bc = bc + bc2; // expected-error {{invalid operands}}
367 bc = bc + uc2; // expected-error {{incompatible type}}
368 bc = uc + bc2; // expected-error {{incompatible type}}
369 bc = bc + sc2; // expected-error {{incompatible type}}
370 bc = sc + bc2; // expected-error {{incompatible type}}
371
372 sc = sc + sc_scalar;
373 sc = sc + uc_scalar; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation}}
374 sc = sc_scalar + sc;
375 sc = uc_scalar + sc; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation}}
376 uc = uc + sc_scalar; // expected-error {{implicit conversion changes signedness: 'signed char' to '__vector unsigned char' (vector of 16 'unsigned char' values)}}
377 uc = uc + uc_scalar;
378 uc = sc_scalar + uc; // expected-error {{implicit conversion changes signedness: 'signed char' to '__vector unsigned char' (vector of 16 'unsigned char' values)}}
379 uc = uc_scalar + uc;
380
381 ss = ss + ss2;
382 us = us + us2;
383 bs = bs + bs2; // expected-error {{invalid operands}}
384
385 si = si + si2;
386 ui = ui + ui2;
387 bi = bi + bi2; // expected-error {{invalid operands}}
388
389 sl = sl + sl2;
390 ul = ul + ul2;
391 bl = bl + bl2; // expected-error {{invalid operands}}
392
393 fd = fd + fd2;
394 fd = fd + ul2; // expected-error {{cannot convert}}
395 fd = sl + fd2; // expected-error {{cannot convert}}
396
397 sc += sc2;
398 sc += uc2; // expected-error {{cannot convert}}
399 sc += bc2;
400
401 uc += uc2;
402 uc += sc2; // expected-error {{cannot convert}}
403 uc += bc2;
404
405 bc += bc2; // expected-error {{invalid operands}}
406 bc += sc2; // expected-error {{cannot convert}}
407 bc += uc2; // expected-error {{cannot convert}}
408
409 sc += ss2; // expected-error {{cannot convert}}
410 sc += si2; // expected-error {{cannot convert}}
411 sc += sl2; // expected-error {{cannot convert}}
412 sc += fd2; // expected-error {{cannot convert}}
413
414 sc += sc_scalar;
415 sc += uc_scalar; // expected-error {{cannot convert between scalar type 'unsigned char' and vector type '__vector signed char' (vector of 16 'signed char' values) as implicit conversion would cause truncation}}
416 uc += sc_scalar; // expected-error {{implicit conversion changes signedness: 'signed char' to '__vector unsigned char' (vector of 16 'unsigned char' values)}}
417 uc += uc_scalar;
418
419 ss += ss2;
420 us += us2;
421 bs += bs2; // expected-error {{invalid operands}}
422
423 si += si2;
424 ui += ui2;
425 bi += bi2; // expected-error {{invalid operands}}
426
427 sl += sl2;
428 ul += ul2;
429 bl += bl2; // expected-error {{invalid operands}}
430
431 fd += fd2;
432
433 // -------------------------------------------------------------------------
434 // Test that binary + rules apply to binary - too.
435 // -------------------------------------------------------------------------
436
437 sc = sc - sc2;
438 uc = uc - uc2;
439 bc = bc - bc2; // expected-error {{invalid operands}}
440
441 sc = uc - sc2; // expected-error {{cannot convert}}
442 sc = sc - bc2;
443 uc = bc - uc2;
444
445 sc -= sc2;
446 uc -= uc2;
447 bc -= bc2; // expected-error {{invalid operands}}
448
449 sc -= uc2; // expected-error {{cannot convert}}
450 uc -= bc2;
451 bc -= sc2; // expected-error {{cannot convert}}
452
453 ss -= ss2;
454 us -= us2;
455 bs -= bs2; // expected-error {{invalid operands}}
456
457 si -= si2;
458 ui -= ui2;
459 bi -= bi2; // expected-error {{invalid operands}}
460
461 sl -= sl2;
462 ul -= ul2;
463 bl -= bl2; // expected-error {{invalid operands}}
464
465 fd -= fd2;
466
467 // -------------------------------------------------------------------------
468 // Test that binary + rules apply to * too. 64-bit integer multiplication
469 // is not required by the spec and so isn't tested here.
470 // -------------------------------------------------------------------------
471
472 sc = sc * sc2;
473 uc = uc * uc2;
474 bc = bc * bc2; // expected-error {{invalid operands}}
475
476 sc = uc * sc2; // expected-error {{cannot convert}}
477 sc = sc * bc2; // expected-error {{cannot convert}}
478 uc = bc * uc2; // expected-error {{cannot convert}}
479
480 sc *= sc2;
481 uc *= uc2;
482 bc *= bc2; // expected-error {{invalid operands}}
483
484 sc *= uc2; // expected-error {{cannot convert}}
485 uc *= bc2; // expected-error {{cannot convert}}
486 bc *= sc2; // expected-error {{cannot convert}}
487
488 ss *= ss2;
489 us *= us2;
490 bs *= bs2; // expected-error {{invalid operands}}
491
492 si *= si2;
493 ui *= ui2;
494 bi *= bi2; // expected-error {{invalid operands}}
495
496 sl *= sl2;
497 ul *= ul2;
498 bl *= bl2; // expected-error {{invalid operands}}
499
500 fd *= fd2;
501
502 // -------------------------------------------------------------------------
503 // Test that * rules apply to / too.
504 // -------------------------------------------------------------------------
505
506 sc = sc / sc2;
507 uc = uc / uc2;
508 bc = bc / bc2; // expected-error {{invalid operands}}
509
510 sc = uc / sc2; // expected-error {{cannot convert}}
511 sc = sc / bc2; // expected-error {{cannot convert}}
512 uc = bc / uc2; // expected-error {{cannot convert}}
513
514 sc /= sc2;
515 uc /= uc2;
516 bc /= bc2; // expected-error {{invalid operands}}
517
518 sc /= uc2; // expected-error {{cannot convert}}
519 uc /= bc2; // expected-error {{cannot convert}}
520 bc /= sc2; // expected-error {{cannot convert}}
521
522 ss /= ss2;
523 us /= us2;
524 bs /= bs2; // expected-error {{invalid operands}}
525
526 si /= si2;
527 ui /= ui2;
528 bi /= bi2; // expected-error {{invalid operands}}
529
530 sl /= sl2;
531 ul /= ul2;
532 bl /= bl2; // expected-error {{invalid operands}}
533
534 fd /= fd2;
535
536 // -------------------------------------------------------------------------
537 // Test that / rules apply to % too, except that doubles are not allowed.
538 // -------------------------------------------------------------------------
539
540 sc = sc % sc2;
541 uc = uc % uc2;
542 bc = bc % bc2; // expected-error {{invalid operands}}
543
544 sc = uc % sc2; // expected-error {{cannot convert}}
545 sc = sc % bc2; // expected-error {{cannot convert}}
546 uc = bc % uc2; // expected-error {{cannot convert}}
547
548 sc %= sc2;
549 uc %= uc2;
550 bc %= bc2; // expected-error {{invalid operands}}
551
552 sc %= uc2; // expected-error {{cannot convert}}
553 uc %= bc2; // expected-error {{cannot convert}}
554 bc %= sc2; // expected-error {{cannot convert}}
555
556 ss %= ss2;
557 us %= us2;
558 bs %= bs2; // expected-error {{invalid operands}}
559
560 si %= si2;
561 ui %= ui2;
562 bi %= bi2; // expected-error {{invalid operands}}
563
564 sl %= sl2;
565 ul %= ul2;
566 bl %= bl2; // expected-error {{invalid operands}}
567
568 fd %= fd2; // expected-error {{invalid operands}}
569
570 // -------------------------------------------------------------------------
571 // Test &.
572 // -------------------------------------------------------------------------
573
574 sc = sc & sc2;
575 sc = sc & uc2; // expected-error {{cannot convert}}
576 sc = uc & sc2; // expected-error {{cannot convert}}
577 sc = sc & bc2;
578 sc = bc & sc2;
579
580 uc = uc & uc2;
581 uc = sc & uc2; // expected-error {{cannot convert}}
582 uc = uc & sc2; // expected-error {{cannot convert}}
583 uc = bc & uc2;
584 uc = uc & bc2;
585
586 bc = bc & bc2;
587 bc = bc & uc2; // expected-error {{incompatible type}}
588 bc = uc & bc2; // expected-error {{incompatible type}}
589 bc = bc & sc2; // expected-error {{incompatible type}}
590 bc = sc & bc2; // expected-error {{incompatible type}}
591
592 fd = fd & fd2; // expected-error {{invalid operands}}
593 fd = bl & fd2; // expected-error {{invalid operands}}
594 fd = fd & bl2; // expected-error {{invalid operands}}
595 fd = fd & sl2; // expected-error {{invalid operands}}
596 fd = fd & ul2; // expected-error {{invalid operands}}
597
598 sc &= sc2;
599 sc &= uc2; // expected-error {{cannot convert}}
600 sc &= bc2;
601
602 uc &= uc2;
603 uc &= sc2; // expected-error {{cannot convert}}
604 uc &= bc2;
605
606 bc &= bc2;
607 bc &= sc2; // expected-error {{cannot convert}}
608 bc &= uc2; // expected-error {{cannot convert}}
609
610 sc &= ss2; // expected-error {{cannot convert}}
611 sc &= si2; // expected-error {{cannot convert}}
612 sc &= sl2; // expected-error {{cannot convert}}
613 sc &= fd2; // expected-error {{invalid operands}}
614
615 us &= bc2; // expected-error {{cannot convert}}
616 ui &= bc2; // expected-error {{cannot convert}}
617 ul &= bc2; // expected-error {{cannot convert}}
618 fd &= bc2; // expected-error {{invalid operands}}
619
620 ss &= ss2;
621 us &= us2;
622 bs &= bs2;
623
624 si &= si2;
625 ui &= ui2;
626 bi &= bi2;
627
628 sl &= sl2;
629 ul &= ul2;
630 bl &= bl2;
631
632 // -------------------------------------------------------------------------
633 // Test that & rules apply to | too.
634 // -------------------------------------------------------------------------
635
636 sc = sc | sc2;
637 sc = sc | uc2; // expected-error {{cannot convert}}
638 sc = sc | bc2;
639
640 uc = uc | uc2;
641 uc = sc | uc2; // expected-error {{cannot convert}}
642 uc = bc | uc2;
643
644 bc = bc | bc2;
645 bc = uc | bc2; // expected-error {{incompatible type}}
646 bc = bc | sc2; // expected-error {{incompatible type}}
647
648 fd = fd | fd2; // expected-error {{invalid operands}}
649 fd = bl | fd2; // expected-error {{invalid operands}}
650
651 ss |= ss2;
652 us |= us2;
653 bs |= bs2;
654
655 si |= si2;
656 ui |= ui2;
657 bi |= bi2;
658
659 sl |= sl2;
660 ul |= ul2;
661 bl |= bl2;
662
663 fd |= bl2; // expected-error {{invalid operands}}
664 fd |= fd2; // expected-error {{invalid operands}}
665
666 // -------------------------------------------------------------------------
667 // Test that & rules apply to ^ too.
668 // -------------------------------------------------------------------------
669
670 sc = sc ^ sc2;
671 sc = sc ^ uc2; // expected-error {{cannot convert}}
672 sc = sc ^ bc2;
673
674 uc = uc ^ uc2;
675 uc = sc ^ uc2; // expected-error {{cannot convert}}
676 uc = bc ^ uc2;
677
678 bc = bc ^ bc2;
679 bc = uc ^ bc2; // expected-error {{incompatible type}}
680 bc = bc ^ sc2; // expected-error {{incompatible type}}
681
682 fd = fd ^ fd2; // expected-error {{invalid operands}}
683 fd = bl ^ fd2; // expected-error {{invalid operands}}
684
685 ss ^= ss2;
686 us ^= us2;
687 bs ^= bs2;
688
689 si ^= si2;
690 ui ^= ui2;
691 bi ^= bi2;
692
693 sl ^= sl2;
694 ul ^= ul2;
695 bl ^= bl2;
696
697 fd ^= bl2; // expected-error {{invalid operands}}
698 fd ^= fd2; // expected-error {{invalid operands}}
699
700 // -------------------------------------------------------------------------
701 // Test <<.
702 // -------------------------------------------------------------------------
703
704 sc = sc << sc2;
705 sc = sc << uc2;
706 sc = uc << sc2; // expected-error {{incompatible type}}
707 sc = sc << bc2; // expected-error {{invalid operands}}
708 sc = bc << sc2; // expected-error {{invalid operands}}
709
710 uc = uc << uc2;
711 uc = sc << uc2; // expected-error {{assigning to}}
712 uc = uc << sc2;
713 uc = bc << uc2; // expected-error {{invalid operands}}
714 uc = uc << bc2; // expected-error {{invalid operands}}
715
716 bc = bc << bc2; // expected-error {{invalid operands}}
717 bc = bc << uc2; // expected-error {{invalid operands}}
718 bc = uc << bc2; // expected-error {{invalid operands}}
719 bc = bc << sc2; // expected-error {{invalid operands}}
720 bc = sc << bc2; // expected-error {{invalid operands}}
721
722 sc = sc << 1;
723 sc = sc << 1.0f; // expected-error {{integer is required}}
724 sc = sc << sc_scalar;
725 sc = sc << uc_scalar;
726 sc = sc << ss_scalar;
727 sc = sc << us_scalar;
728 sc = sc << si_scalar;
729 sc = sc << ui_scalar;
730 sc = sc << sl_scalar;
731 sc = sc << ul_scalar;
732 sc = sc_scalar << sc; // expected-error {{first operand is not a vector}}
733 sc = uc_scalar << sc; // expected-error {{first operand is not a vector}}
734 uc = uc << sc_scalar;
735 uc = uc << uc_scalar;
736 uc = sc_scalar << uc; // expected-error {{first operand is not a vector}}
737 uc = uc_scalar << uc; // expected-error {{first operand is not a vector}}
738
739 ss = ss << ss2;
740 ss = ss << ss_scalar;
741 us = us << us2;
742 us = us << us_scalar;
743 bs = bs << bs2; // expected-error {{invalid operands}}
744
745 si = si << si2;
746 si = si << si_scalar;
747 ui = ui << ui2;
748 ui = ui << ui_scalar;
749 bi = bi << bi2; // expected-error {{invalid operands}}
750
751 sl = sl << sl2;
752 sl = sl << sl_scalar;
753 ul = ul << ul2;
754 ul = ul << ul_scalar;
755 bl = bl << bl2; // expected-error {{invalid operands}}
756
757 fd = fd << fd2; // expected-error {{integer is required}}
758 fd = fd << ul2; // expected-error {{integer is required}}
759 fd = sl << fd2; // expected-error {{integer is required}}
760
761 sc <<= sc2;
762 sc <<= uc2;
763 sc <<= bc2; // expected-error {{invalid operands}}
764 sc <<= sc_scalar;
765
766 uc <<= uc2;
767 uc <<= sc2;
768 uc <<= bc2; // expected-error {{invalid operands}}
769 uc <<= uc_scalar;
770
771 bc <<= bc2; // expected-error {{invalid operands}}
772 bc <<= sc2; // expected-error {{invalid operands}}
773 bc <<= uc2; // expected-error {{invalid operands}}
774
775 sc <<= ss2; // expected-error {{vector operands do not have the same number of elements}}
776 sc <<= si2; // expected-error {{vector operands do not have the same number of elements}}
777 sc <<= sl2; // expected-error {{vector operands do not have the same number of elements}}
778 sc <<= fd2; // expected-error {{integer is required}}
779
780 ss <<= ss2;
781 ss <<= ss_scalar;
782 us <<= us2;
783 us <<= us_scalar;
784 bs <<= bs2; // expected-error {{invalid operands}}
785
786 si <<= si2;
787 si <<= si_scalar;
788 ui <<= ui2;
789 ui <<= ui_scalar;
790 bi <<= bi2; // expected-error {{invalid operands}}
791
792 sl <<= sl2;
793 sl <<= sl_scalar;
794 ul <<= ul2;
795 ul <<= ul_scalar;
796 bl <<= bl2; // expected-error {{invalid operands}}
797
798 fd <<= fd2; // expected-error {{integer is required}}
799
800 // -------------------------------------------------------------------------
801 // Test >>.
802 // -------------------------------------------------------------------------
803
804 sc = sc >> sc2;
805 sc = sc >> uc2;
806 sc = uc >> sc2; // expected-error {{incompatible type}}
807 sc = sc >> bc2; // expected-error {{invalid operands}}
808 sc = bc >> sc2; // expected-error {{invalid operands}}
809
810 uc = uc >> uc2;
811 uc = sc >> uc2; // expected-error {{assigning to}}
812 uc = uc >> sc2;
813 uc = bc >> uc2; // expected-error {{invalid operands}}
814 uc = uc >> bc2; // expected-error {{invalid operands}}
815
816 bc = bc >> bc2; // expected-error {{invalid operands}}
817 bc = bc >> uc2; // expected-error {{invalid operands}}
818 bc = uc >> bc2; // expected-error {{invalid operands}}
819 bc = bc >> sc2; // expected-error {{invalid operands}}
820 bc = sc >> bc2; // expected-error {{invalid operands}}
821
822 sc = sc >> 1;
823 sc = sc >> 1.0f; // expected-error {{integer is required}}
824 sc = sc >> sc_scalar;
825 sc = sc >> uc_scalar;
826 sc = sc >> ss_scalar;
827 sc = sc >> us_scalar;
828 sc = sc >> si_scalar;
829 sc = sc >> ui_scalar;
830 sc = sc >> sl_scalar;
831 sc = sc >> ul_scalar;
832 sc = sc_scalar >> sc; // expected-error {{first operand is not a vector}}
833 sc = uc_scalar >> sc; // expected-error {{first operand is not a vector}}
834 uc = uc >> sc_scalar;
835 uc = uc >> uc_scalar;
836 uc = sc_scalar >> uc; // expected-error {{first operand is not a vector}}
837 uc = uc_scalar >> uc; // expected-error {{first operand is not a vector}}
838
839 ss = ss >> ss2;
840 ss = ss >> ss_scalar;
841 us = us >> us2;
842 us = us >> us_scalar;
843 bs = bs >> bs2; // expected-error {{invalid operands}}
844
845 si = si >> si2;
846 si = si >> si_scalar;
847 ui = ui >> ui2;
848 ui = ui >> ui_scalar;
849 bi = bi >> bi2; // expected-error {{invalid operands}}
850
851 sl = sl >> sl2;
852 sl = sl >> sl_scalar;
853 ul = ul >> ul2;
854 ul = ul >> ul_scalar;
855 bl = bl >> bl2; // expected-error {{invalid operands}}
856
857 fd = fd >> fd2; // expected-error {{integer is required}}
858 fd = fd >> ul2; // expected-error {{integer is required}}
859 fd = sl >> fd2; // expected-error {{integer is required}}
860
861 sc >>= sc2;
862 sc >>= uc2;
863 sc >>= bc2; // expected-error {{invalid operands}}
864 sc >>= sc_scalar;
865
866 uc >>= uc2;
867 uc >>= sc2;
868 uc >>= bc2; // expected-error {{invalid operands}}
869 uc >>= uc_scalar;
870
871 bc >>= bc2; // expected-error {{invalid operands}}
872 bc >>= sc2; // expected-error {{invalid operands}}
873 bc >>= uc2; // expected-error {{invalid operands}}
874
875 sc >>= ss2; // expected-error {{vector operands do not have the same number of elements}}
876 sc >>= si2; // expected-error {{vector operands do not have the same number of elements}}
877 sc >>= sl2; // expected-error {{vector operands do not have the same number of elements}}
878 sc >>= fd2; // expected-error {{integer is required}}
879
880 ss >>= ss2;
881 ss >>= ss_scalar;
882 us >>= us2;
883 us >>= us_scalar;
884 bs >>= bs2; // expected-error {{invalid operands}}
885
886 si >>= si2;
887 si >>= si_scalar;
888 ui >>= ui2;
889 ui >>= ui_scalar;
890 bi >>= bi2; // expected-error {{invalid operands}}
891
892 sl >>= sl2;
893 sl >>= sl_scalar;
894 ul >>= ul2;
895 ul >>= ul_scalar;
896 bl >>= bl2; // expected-error {{invalid operands}}
897
898 fd >>= fd2; // expected-error {{integer is required}}
899
900 // -------------------------------------------------------------------------
901 // Test ==.
902 // -------------------------------------------------------------------------
903
904 (void)(sc == sc2);
905 (void)(uc == uc2);
906 (void)(bc == bc2);
907
908 (void)(sc == uc); // expected-error {{cannot convert}}
909 (void)(sc == bc);
910
911 (void)(uc == sc); // expected-error {{cannot convert}}
912 (void)(uc == bc);
913
914 (void)(bc == sc);
915 (void)(bc == uc);
916
917 (void)(ss == ss2);
918 (void)(us == us2);
919 (void)(bs == bs2);
920
921 (void)(si == si2);
922 (void)(ui == ui2);
923 (void)(bi == bi2);
924
925 (void)(sl == sl2);
926 (void)(ul == ul2);
927 (void)(bl == bl2);
928 (void)(fd == fd2);
929
930 (void)(fd == ul); // expected-error {{cannot convert}}
931 (void)(ul == fd); // expected-error {{cannot convert}}
932
933 // -------------------------------------------------------------------------
934 // Test that == rules apply to != too.
935 // -------------------------------------------------------------------------
936
937 (void)(sc != sc2);
938 (void)(uc != uc2);
939 (void)(bc != bc2);
940
941 (void)(sc != uc); // expected-error {{cannot convert}}
942 (void)(sc != bc);
943
944 (void)(ss != ss2);
945 (void)(us != us2);
946 (void)(bs != bs2);
947
948 (void)(si != si2);
949 (void)(ui != ui2);
950 (void)(bi != bi2);
951
952 (void)(sl != sl2);
953 (void)(ul != ul2);
954 (void)(bl != bl2);
955 (void)(fd != fd2);
956
957 // -------------------------------------------------------------------------
958 // Test that == rules apply to <= too.
959 // -------------------------------------------------------------------------
960
961 (void)(sc <= sc2);
962 (void)(uc <= uc2);
963 (void)(bc <= bc2);
964
965 (void)(sc <= uc); // expected-error {{cannot convert}}
966 (void)(sc <= bc);
967
968 (void)(ss <= ss2);
969 (void)(us <= us2);
970 (void)(bs <= bs2);
971
972 (void)(si <= si2);
973 (void)(ui <= ui2);
974 (void)(bi <= bi2);
975
976 (void)(sl <= sl2);
977 (void)(ul <= ul2);
978 (void)(bl <= bl2);
979 (void)(fd <= fd2);
980
981 // -------------------------------------------------------------------------
982 // Test that == rules apply to >= too.
983 // -------------------------------------------------------------------------
984
985 (void)(sc >= sc2);
986 (void)(uc >= uc2);
987 (void)(bc >= bc2);
988
989 (void)(sc >= uc); // expected-error {{cannot convert}}
990 (void)(sc >= bc);
991
992 (void)(ss >= ss2);
993 (void)(us >= us2);
994 (void)(bs >= bs2);
995
996 (void)(si >= si2);
997 (void)(ui >= ui2);
998 (void)(bi >= bi2);
999
1000 (void)(sl >= sl2);
1001 (void)(ul >= ul2);
1002 (void)(bl >= bl2);
1003 (void)(fd >= fd2);
1004
1005 // -------------------------------------------------------------------------
1006 // Test that == rules apply to < too.
1007 // -------------------------------------------------------------------------
1008
1009 (void)(sc < sc2);
1010 (void)(uc < uc2);
1011 (void)(bc < bc2);
1012
1013 (void)(sc < uc); // expected-error {{cannot convert}}
1014 (void)(sc < bc);
1015
1016 (void)(ss < ss2);
1017 (void)(us < us2);
1018 (void)(bs < bs2);
1019
1020 (void)(si < si2);
1021 (void)(ui < ui2);
1022 (void)(bi < bi2);
1023
1024 (void)(sl < sl2);
1025 (void)(ul < ul2);
1026 (void)(bl < bl2);
1027 (void)(fd < fd2);
1028
1029 // -------------------------------------------------------------------------
1030 // Test that == rules apply to > too.
1031 // -------------------------------------------------------------------------
1032
1033 (void)(sc > sc2);
1034 (void)(uc > uc2);
1035 (void)(bc > bc2);
1036
1037 (void)(sc > uc); // expected-error {{cannot convert}}
1038 (void)(sc > bc);
1039
1040 (void)(ss > ss2);
1041 (void)(us > us2);
1042 (void)(bs > bs2);
1043
1044 (void)(si > si2);
1045 (void)(ui > ui2);
1046 (void)(bi > bi2);
1047
1048 (void)(sl > sl2);
1049 (void)(ul > ul2);
1050 (void)(bl > bl2);
1051 (void)(fd > fd2);
1052 }
1053