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