clang/test/Sema/tautological-constant-compare.c

   1 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wtautological-constant-in-range-compare -DTEST=2 -verify %s
   2 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wtautological-constant-in-range-compare -DTEST=2 -verify -x c++ %s
   3 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wtautological-type-limit-compare -DTEST -verify %s
   4 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wtautological-type-limit-compare -DTEST -verify -x c++ %s
   5 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wtype-limits -DTEST -verify %s
   6 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wtype-limits -DTEST -verify -x c++ %s
   7 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wextra -Wno-sign-compare -verify=silent %s
   8 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wextra -Wno-sign-compare -verify=silent -x c++ %s
   9 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wall -verify=silent %s
  10 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wall -verify=silent -x c++ %s
  11 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -verify=silent %s
  12 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -verify=silent -x c++ %s
  13
  14 #ifndef TEST
  15 // silent-no-diagnostics
  16 #endif
  17
  18 int value(void);
  19
  20 #define macro(val) val
  21
  22 #ifdef __cplusplus
  23 template<typename T>
  24 void TFunc() {
  25   // Make sure that we do warn for normal variables in template functions !
  26   unsigned char c = value();
  27 #ifdef TEST
  28   if (c > 255) // expected-warning {{comparison 'unsigned char' > 255 is always false}}
  29       return;
  30 #else
  31   if (c > 255)
  32       return;
  33 #endif
  34
  35   if (c > macro(255))
  36       return;
  37
  38   T v = value();
  39   if (v > 255)
  40       return;
  41   if (v > 32767)
  42       return;
  43 }
  44 #endif
  45
  46 int main(void)
  47 {
  48 #ifdef __cplusplus
  49   TFunc<unsigned char>();
  50   TFunc<signed short>();
  51 #endif
  52
  53   short s = value();
  54
  55 #ifdef TEST
  56   if (s == 32767)
  57       return 0;
  58   if (s != 32767)
  59       return 0;
  60   if (s < 32767)
  61       return 0;
  62   if (s <= 32767) // expected-warning {{comparison 'short' <= 32767 is always true}}
  63       return 0;
  64   if (s > 32767) // expected-warning {{comparison 'short' > 32767 is always false}}
  65       return 0;
  66   if (s >= 32767)
  67       return 0;
  68
  69   if (32767 == s)
  70       return 0;
  71   if (32767 != s)
  72       return 0;
  73   if (32767 < s) // expected-warning {{comparison 32767 < 'short' is always false}}
  74       return 0;
  75   if (32767 <= s)
  76       return 0;
  77   if (32767 > s)
  78       return 0;
  79   if (32767 >= s) // expected-warning {{comparison 32767 >= 'short' is always true}}
  80       return 0;
  81
  82   // FIXME: assumes two's complement
  83   if (s == -32768)
  84       return 0;
  85   if (s != -32768)
  86       return 0;
  87   if (s < -32768) // expected-warning {{comparison 'short' < -32768 is always false}}
  88       return 0;
  89   if (s <= -32768)
  90       return 0;
  91   if (s > -32768)
  92       return 0;
  93   if (s >= -32768) // expected-warning {{comparison 'short' >= -32768 is always true}}
  94       return 0;
  95
  96   if (-32768 == s)
  97       return 0;
  98   if (-32768 != s)
  99       return 0;
 100   if (-32768 < s)
 101       return 0;
 102   if (-32768 <= s) // expected-warning {{comparison -32768 <= 'short' is always true}}
 103       return 0;
 104   if (-32768 > s) // expected-warning {{comparison -32768 > 'short' is always false}}
 105       return 0;
 106   if (-32768 >= s)
 107       return 0;
 108
 109   // Note: both sides are promoted to unsigned long prior to the comparison, so
 110   // it is perfectly possible for a short to compare greater than 32767UL.
 111   if (s == 32767UL)
 112       return 0;
 113   if (s != 32767UL)
 114       return 0;
 115   if (s < 32767UL)
 116       return 0;
 117   if (s <= 32767UL)
 118       return 0;
 119   if (s > 32767UL)
 120       return 0;
 121   if (s >= 32767UL)
 122       return 0;
 123
 124   if (32767UL == s)
 125       return 0;
 126   if (32767UL != s)
 127       return 0;
 128   if (32767UL < s)
 129       return 0;
 130   if (32767UL <= s)
 131       return 0;
 132   if (32767UL > s)
 133       return 0;
 134   if (32767UL >= s)
 135       return 0;
 136
 137   enum { ULONG_MAX = (2UL * (unsigned long)__LONG_MAX__ + 1UL) };
 138   if (s == 2UL * (unsigned long)__LONG_MAX__ + 1UL)
 139       return 0;
 140   if (s != 2UL * (unsigned long)__LONG_MAX__ + 1UL)
 141       return 0;
 142   if (s < 2UL * (unsigned long)__LONG_MAX__ + 1UL)
 143       return 0;
 144   if (s <= 2UL * (unsigned long)__LONG_MAX__ + 1UL) // expected-warning-re {{comparison 'short' <= {{.*}} is always true}}
 145       return 0;
 146   if (s > 2UL * (unsigned long)__LONG_MAX__ + 1UL) // expected-warning-re {{comparison 'short' > {{.*}} is always false}}
 147       return 0;
 148   if (s >= 2UL * (unsigned long)__LONG_MAX__ + 1UL)
 149       return 0;
 150
 151   if (2UL * (unsigned long)__LONG_MAX__ + 1UL == s)
 152       return 0;
 153   if (2UL * (unsigned long)__LONG_MAX__ + 1UL != s)
 154       return 0;
 155   if (2UL * (unsigned long)__LONG_MAX__ + 1UL < s) // expected-warning-re {{comparison {{.*}} < 'short' is always false}}
 156       return 0;
 157   if (2UL * (unsigned long)__LONG_MAX__ + 1UL <= s)
 158       return 0;
 159   if (2UL * (unsigned long)__LONG_MAX__ + 1UL > s)
 160       return 0;
 161   if (2UL * (unsigned long)__LONG_MAX__ + 1UL >= s) // expected-warning-re {{comparison {{.*}} >= 'short' is always true}}
 162       return 0;
 163
 164   // FIXME: assumes two's complement
 165   if (s == -32768L)
 166       return 0;
 167   if (s != -32768L)
 168       return 0;
 169   if (s < -32768L) // expected-warning {{comparison 'short' < -32768 is always false}}
 170       return 0;
 171   if (s <= -32768L)
 172       return 0;
 173   if (s > -32768L)
 174       return 0;
 175   if (s >= -32768L) // expected-warning {{comparison 'short' >= -32768 is always true}}
 176       return 0;
 177
 178   if (-32768L == s)
 179       return 0;
 180   if (-32768L != s)
 181       return 0;
 182   if (-32768L < s)
 183       return 0;
 184   if (-32768L <= s) // expected-warning {{comparison -32768 <= 'short' is always true}}
 185       return 0;
 186   if (-32768L > s) // expected-warning {{comparison -32768 > 'short' is always false}}
 187       return 0;
 188   if (-32768L >= s)
 189       return 0;
 190 #else
 191   if (s == 32767)
 192     return 0;
 193   if (s != 32767)
 194     return 0;
 195   if (s < 32767)
 196     return 0;
 197   if (s <= 32767)
 198     return 0;
 199   if (s > 32767)
 200     return 0;
 201   if (s >= 32767)
 202     return 0;
 203
 204   if (32767 == s)
 205     return 0;
 206   if (32767 != s)
 207     return 0;
 208   if (32767 < s)
 209     return 0;
 210   if (32767 <= s)
 211     return 0;
 212   if (32767 > s)
 213     return 0;
 214   if (32767 >= s)
 215     return 0;
 216
 217   // FIXME: assumes two's complement
 218   if (s == -32768)
 219     return 0;
 220   if (s != -32768)
 221     return 0;
 222   if (s < -32768)
 223     return 0;
 224   if (s <= -32768)
 225     return 0;
 226   if (s > -32768)
 227     return 0;
 228   if (s >= -32768)
 229     return 0;
 230
 231   if (-32768 == s)
 232     return 0;
 233   if (-32768 != s)
 234     return 0;
 235   if (-32768 < s)
 236     return 0;
 237   if (-32768 <= s)
 238     return 0;
 239   if (-32768 > s)
 240     return 0;
 241   if (-32768 >= s)
 242     return 0;
 243
 244   if (s == 32767UL)
 245     return 0;
 246   if (s != 32767UL)
 247     return 0;
 248   if (s < 32767UL)
 249     return 0;
 250   if (s <= 32767UL)
 251     return 0;
 252   if (s > 32767UL)
 253     return 0;
 254   if (s >= 32767UL)
 255     return 0;
 256
 257   if (32767UL == s)
 258     return 0;
 259   if (32767UL != s)
 260     return 0;
 261   if (32767UL < s)
 262     return 0;
 263   if (32767UL <= s)
 264     return 0;
 265   if (32767UL > s)
 266     return 0;
 267   if (32767UL >= s)
 268     return 0;
 269
 270   // FIXME: assumes two's complement
 271   if (s == -32768L)
 272     return 0;
 273   if (s != -32768L)
 274     return 0;
 275   if (s < -32768L)
 276     return 0;
 277   if (s <= -32768L)
 278     return 0;
 279   if (s > -32768L)
 280     return 0;
 281   if (s >= -32768L)
 282     return 0;
 283
 284   if (-32768L == s)
 285     return 0;
 286   if (-32768L != s)
 287     return 0;
 288   if (-32768L < s)
 289     return 0;
 290   if (-32768L <= s)
 291     return 0;
 292   if (-32768L > s)
 293     return 0;
 294   if (-32768L >= s)
 295     return 0;
 296 #endif
 297
 298   if (s == 0)
 299     return 0;
 300   if (s != 0)
 301     return 0;
 302   if (s < 0)
 303     return 0;
 304   if (s <= 0)
 305     return 0;
 306   if (s > 0)
 307     return 0;
 308   if (s >= 0)
 309     return 0;
 310
 311   if (0 == s)
 312     return 0;
 313   if (0 != s)
 314     return 0;
 315   if (0 < s)
 316     return 0;
 317   if (0 <= s)
 318     return 0;
 319   if (0 > s)
 320     return 0;
 321   if (0 >= s)
 322     return 0;
 323
 324   unsigned short us = value();
 325
 326 #ifdef TEST
 327   if (us == 65535)
 328       return 0;
 329   if (us != 65535)
 330       return 0;
 331   if (us < 65535)
 332       return 0;
 333   if (us <= 65535) // expected-warning {{comparison 'unsigned short' <= 65535 is always true}}
 334       return 0;
 335   if (us > 65535) // expected-warning {{comparison 'unsigned short' > 65535 is always false}}
 336       return 0;
 337   if (us >= 65535)
 338       return 0;
 339
 340   if (65535 == us)
 341       return 0;
 342   if (65535 != us)
 343       return 0;
 344   if (65535 < us) // expected-warning {{comparison 65535 < 'unsigned short' is always false}}
 345       return 0;
 346   if (65535 <= us)
 347       return 0;
 348   if (65535 > us)
 349       return 0;
 350   if (65535 >= us) // expected-warning {{comparison 65535 >= 'unsigned short' is always true}}
 351       return 0;
 352
 353   if (us == 65535UL)
 354       return 0;
 355   if (us != 65535UL)
 356       return 0;
 357   if (us < 65535UL)
 358       return 0;
 359   if (us <= 65535UL) // expected-warning {{comparison 'unsigned short' <= 65535 is always true}}
 360       return 0;
 361   if (us > 65535UL) // expected-warning {{comparison 'unsigned short' > 65535 is always false}}
 362       return 0;
 363   if (us >= 65535UL)
 364       return 0;
 365
 366   if (65535UL == us)
 367       return 0;
 368   if (65535UL != us)
 369       return 0;
 370   if (65535UL < us) // expected-warning {{comparison 65535 < 'unsigned short' is always false}}
 371       return 0;
 372   if (65535UL <= us)
 373       return 0;
 374   if (65535UL > us)
 375       return 0;
 376   if (65535UL >= us) // expected-warning {{comparison 65535 >= 'unsigned short' is always true}}
 377       return 0;
 378 #else
 379   if (us == 65535)
 380       return 0;
 381   if (us != 65535)
 382       return 0;
 383   if (us < 65535)
 384       return 0;
 385   if (us <= 65535)
 386       return 0;
 387   if (us > 65535)
 388       return 0;
 389   if (us >= 65535)
 390       return 0;
 391
 392   if (65535 == us)
 393       return 0;
 394   if (65535 != us)
 395       return 0;
 396   if (65535 < us)
 397       return 0;
 398   if (65535 <= us)
 399       return 0;
 400   if (65535 > us)
 401       return 0;
 402   if (65535 >= us)
 403       return 0;
 404
 405   if (us == 65535UL)
 406       return 0;
 407   if (us != 65535UL)
 408       return 0;
 409   if (us < 65535UL)
 410       return 0;
 411   if (us <= 65535UL)
 412       return 0;
 413   if (us > 65535UL)
 414       return 0;
 415   if (us >= 65535UL)
 416       return 0;
 417
 418   if (65535UL == us)
 419       return 0;
 420   if (65535UL != us)
 421       return 0;
 422   if (65535UL < us)
 423       return 0;
 424   if (65535UL <= us)
 425       return 0;
 426   if (65535UL > us)
 427       return 0;
 428   if (65535UL >= us)
 429       return 0;
 430 #endif
 431
 432   if (us == 32767)
 433     return 0;
 434   if (us != 32767)
 435     return 0;
 436   if (us < 32767)
 437     return 0;
 438   if (us <= 32767)
 439     return 0;
 440   if (us > 32767)
 441     return 0;
 442   if (us >= 32767)
 443     return 0;
 444
 445   if (32767 == us)
 446     return 0;
 447   if (32767 != us)
 448     return 0;
 449   if (32767 < us)
 450     return 0;
 451   if (32767 <= us)
 452     return 0;
 453   if (32767 > us)
 454     return 0;
 455   if (32767 >= us)
 456     return 0;
 457
 458   if (us == 32767UL)
 459     return 0;
 460   if (us != 32767UL)
 461     return 0;
 462   if (us < 32767UL)
 463     return 0;
 464   if (us <= 32767UL)
 465     return 0;
 466   if (us > 32767UL)
 467     return 0;
 468   if (us >= 32767UL)
 469     return 0;
 470
 471   if (32767UL == us)
 472     return 0;
 473   if (32767UL != us)
 474     return 0;
 475   if (32767UL < us)
 476     return 0;
 477   if (32767UL <= us)
 478     return 0;
 479   if (32767UL > us)
 480     return 0;
 481   if (32767UL >= us)
 482     return 0;
 483
 484 #if __SIZEOF_INT128__
 485   __int128 i128 = value();
 486   if (i128 == -1) // used to crash
 487       return 0;
 488 #endif
 489
 490
 491   enum E {
 492   yes,
 493   no,
 494   maybe
 495   };
 496   enum E e = (enum E)value();
 497
 498   if (e == yes)
 499       return 0;
 500   if (e != yes)
 501       return 0;
 502   if (e < yes)
 503       return 0;
 504   if (e <= yes)
 505       return 0;
 506   if (e > yes)
 507       return 0;
 508   if (e >= yes)
 509       return 0;
 510
 511   if (yes == e)
 512       return 0;
 513   if (yes != e)
 514       return 0;
 515   if (yes < e)
 516       return 0;
 517   if (yes <= e)
 518       return 0;
 519   if (yes > e)
 520       return 0;
 521   if (yes >= e)
 522       return 0;
 523
 524   if (e == maybe)
 525       return 0;
 526   if (e != maybe)
 527       return 0;
 528   if (e < maybe)
 529       return 0;
 530   if (e <= maybe)
 531       return 0;
 532   if (e > maybe)
 533       return 0;
 534   if (e >= maybe)
 535       return 0;
 536
 537   if (maybe == e)
 538       return 0;
 539   if (maybe != e)
 540       return 0;
 541   if (maybe < e)
 542       return 0;
 543   if (maybe <= e)
 544       return 0;
 545   if (maybe > e)
 546       return 0;
 547   if (maybe >= e)
 548       return 0;
 549
 550   // We only warn on out-of-range bitfields and expressions with limited range
 551   // under -Wtantological-in-range-compare, not under -Wtype-limits, because
 552   // the warning is not based on the type alone.
 553   struct A {
 554     int a : 3;
 555     unsigned b : 3;
 556     long c : 3;
 557     unsigned long d : 3;
 558   } a;
 559   if (a.a < 3) {}
 560   if (a.a < 4) {} // #bitfield1
 561   if (a.b < 7) {}
 562   if (a.b < 8) {} // #bitfield2
 563   if (a.c < 3) {}
 564   if (a.c < 4) {} // #bitfield3
 565   if (a.d < 7) {}
 566   if (a.d < 8) {} // #bitfield4
 567 #if TEST == 2
 568   // expected-warning@#bitfield1 {{comparison of 3-bit signed value < 4 is always true}}
 569   // expected-warning@#bitfield2 {{comparison of 3-bit unsigned value < 8 is always true}}
 570   // expected-warning@#bitfield3 {{comparison of 3-bit signed value < 4 is always true}}
 571   // expected-warning@#bitfield4 {{comparison of 3-bit unsigned value < 8 is always true}}
 572 #endif
 573
 574   if ((s & 0xff) < 0) {} // #valuerange1
 575   if ((s & 0xff) < 1) {}
 576   if ((s & -3) < -4) {}
 577   if ((s & -3) < -3) {}
 578   if ((s & -3) < 4u) {}
 579   if ((s & -3) > 4u) {}
 580   if ((s & -3) == 4u) {}
 581   if ((s & -3) == 3u) {} // FIXME: Impossible.
 582   if ((s & -3) == -5u) {}
 583   if ((s & -3) == -4u) {}
 584 #if TEST == 2
 585   // expected-warning@#valuerange1 {{comparison of 8-bit unsigned value < 0 is always false}}
 586 #endif
 587
 588   // FIXME: Our bit-level width tracking comes unstuck here: the second of the
 589   // conditions below is also tautological, but we can't tell that because we
 590   // don't track the actual range, only the bit-width.
 591   if ((s ? 1 : 0) + (us ? 1 : 0) > 1) {}
 592   if ((s ? 1 : 0) + (us ? 1 : 0) > 2) {}
 593   if ((s ? 1 : 0) + (us ? 1 : 0) > 3) {} // #addrange1
 594 #if TEST == 2
 595   // expected-warning@#addrange1 {{comparison of 2-bit unsigned value > 3 is always false}}
 596 #endif
 597
 598   // FIXME: The second and third comparisons are also tautological; 0x40000000
 599   // is the greatest value that multiplying two int16s can produce.
 600   if (s * s > 0x3fffffff) {}
 601   if (s * s > 0x40000000) {}
 602   if (s * s > 0x7ffffffe) {}
 603   if (s * s > 0x7fffffff) {} // expected-warning {{result of comparison 'int' > 2147483647 is always false}}
 604
 605   if ((s & 0x3ff) * (s & 0x1f) > 0x7be0) {}
 606   if ((s & 0x3ff) * (s & 0x1f) > 0x7be1) {} // FIXME
 607   if ((s & 0x3ff) * (s & 0x1f) > 0x7ffe) {} // FIXME
 608   if ((s & 0x3ff) * (s & 0x1f) > 0x7fff) {} // #mulrange1
 609 #if TEST == 2
 610   // expected-warning@#mulrange1 {{comparison of 15-bit unsigned value > 32767 is always false}}
 611 #endif
 612
 613   if (a.a * a.b > 21) {} // FIXME
 614   if (a.a * a.b > 31) {} // #mulrange2
 615 #if TEST == 2
 616   // expected-warning@#mulrange2 {{comparison of 6-bit signed value > 31 is always false}}
 617 #endif
 618
 619   if (a.a - (s & 1) < -4) {}
 620   if (a.a - (s & 1) < -7) {} // FIXME
 621   if (a.a - (s & 1) < -8) {} // #subrange1
 622   if (a.a - (s & 1) > 3) {} // FIXME: Can be < -4 but not > 3.
 623   if (a.a - (s & 1) > 7) {} // #subrange2
 624
 625   if (a.a - (s & 7) < -8) {}
 626   if (a.a - (s & 7) > 7) {} // FIXME: Can be < -8 but not > 7.
 627   if (a.a - (s & 7) < -15) {}
 628   if (a.a - (s & 7) < -16) {} // #subrange3
 629   if (a.a - (s & 7) > 15) {} // #subrange4
 630
 631   if (a.b - (s & 1) > 6) {}
 632   if (a.b - (s & 1) > 7) {} // #subrange5
 633   if (a.b - (s & 7) < -8) {} // #subrange6
 634   if (a.b - (s & 15) < -8) {}
 635   if (a.b - (s & 15) < -16) {} // #subrange7
 636 #if TEST == 2
 637   // expected-warning@#subrange1 {{comparison of 4-bit signed value < -8 is always false}}
 638   // expected-warning@#subrange2 {{comparison of 4-bit signed value > 7 is always false}}
 639   // expected-warning@#subrange3 {{comparison of 5-bit signed value < -16 is always false}}
 640   // expected-warning@#subrange4 {{comparison of 5-bit signed value > 15 is always false}}
 641   // expected-warning@#subrange5 {{comparison of 4-bit signed value > 7 is always false}}
 642   // expected-warning@#subrange6 {{comparison of 4-bit signed value < -8 is always false}}
 643   // expected-warning@#subrange7 {{comparison of 5-bit signed value < -16 is always false}}
 644 #endif
 645
 646   // a.a % 3 is in range [-2, 2], which we expand to [-4, 4)
 647   if (a.a % 3 > 2) {}
 648   if (a.a % 3 > 3) {} // #remrange1
 649   if (a.a % 3 == -1) {}
 650   if (a.a % 3 == -2) {}
 651   if (a.a % 3 < -3) {} // FIXME
 652   if (a.a % 3 < -4) {} // #remrange2
 653
 654   // a.b % 3 is in range [0, 3), which we expand to [0, 4)
 655   if (a.b % 3 > 2) {}
 656   if (a.b % 3 > 3) {} // #remrange3
 657   if (a.b % 3 < 0) {} // #remrange4
 658 #if TEST == 2
 659   // expected-warning@#remrange1 {{comparison of 3-bit signed value > 3 is always false}}
 660   // expected-warning@#remrange2 {{comparison of 3-bit signed value < -4 is always false}}
 661   // expected-warning@#remrange3 {{comparison of 2-bit unsigned value > 3 is always false}}
 662   // expected-warning@#remrange4 {{comparison of 2-bit unsigned value < 0 is always false}}
 663 #endif
 664
 665   // Don't warn on non-constant-expression values that end up being a constant
 666   // 0; we generally only want to warn when one side of the comparison is
 667   // effectively non-constant.
 668   if ("x"[1] == 0) {}
 669   if (((void)s, 0) == 0) {}
 670
 671   return 1;
 672 }