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 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
