Mercurial > hg > CbC > CbC_llvm

comparison clang/test/Sema/tautological-constant-compare.c @ 207:2e18cbf3894f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM12
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Tue, 08 Jun 2021 06:07:14 +0900
parents 1d019706d866
children c4bab56944e8
comparison
equal deleted inserted replaced
173:0572611fdcc8 207:2e18cbf3894f
1 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -Wtautological-constant-in-range-compare -DTEST -verify %s 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 -verify -x c++ %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 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 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 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 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 %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 -x c++ %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 %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 -x c++ %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 %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 -x c++ %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
13 17
14 int value(void); 18 int value(void);
15 19
16 #define macro(val) val 20 #define macro(val) val
17 21
182 if (-32768L > s) // expected-warning {{comparison -32768 > 'short' is always false}} 186 if (-32768L > s) // expected-warning {{comparison -32768 > 'short' is always false}}
183 return 0; 187 return 0;
184 if (-32768L >= s) 188 if (-32768L >= s)
185 return 0; 189 return 0;
186 #else 190 #else
187 // expected-no-diagnostics
188 if (s == 32767) 191 if (s == 32767)
189 return 0; 192 return 0;
190 if (s != 32767) 193 if (s != 32767)
191 return 0; 194 return 0;
192 if (s < 32767) 195 if (s < 32767)
371 if (65535UL > us) 374 if (65535UL > us)
372 return 0; 375 return 0;
373 if (65535UL >= us) // expected-warning {{comparison 65535 >= 'unsigned short' is always true}} 376 if (65535UL >= us) // expected-warning {{comparison 65535 >= 'unsigned short' is always true}}
374 return 0; 377 return 0;
375 #else 378 #else
376 // expected-no-diagnostics
377 if (us == 65535) 379 if (us == 65535)
378 return 0; 380 return 0;
379 if (us != 65535) 381 if (us != 65535)
380 return 0; 382 return 0;
381 if (us < 65535) 383 if (us < 65535)
543 if (maybe > e) 545 if (maybe > e)
544 return 0; 546 return 0;
545 if (maybe >= e) 547 if (maybe >= e)
546 return 0; 548 return 0;
547 549
548 // For the time being, use the declared type of bit-fields rather than their 550 // We only warn on out-of-range bitfields and expressions with limited range
549 // length when determining whether a value is in-range. 551 // under -Wtantological-in-range-compare, not under -Wtype-limits, because
550 // FIXME: Reconsider this. 552 // the warning is not based on the type alone.
551 struct A { 553 struct A {
552 int a : 3; 554 int a : 3;
553 unsigned b : 3; 555 unsigned b : 3;
554 long c : 3; 556 long c : 3;
555 unsigned long d : 3; 557 unsigned long d : 3;
556 } a; 558 } a;
557 if (a.a < 3) {} 559 if (a.a < 3) {}
558 if (a.a < 4) {} 560 if (a.a < 4) {} // #bitfield1
559 if (a.b < 7) {} 561 if (a.b < 7) {}
560 if (a.b < 8) {} 562 if (a.b < 8) {} // #bitfield2
561 if (a.c < 3) {} 563 if (a.c < 3) {}
562 if (a.c < 4) {} 564 if (a.c < 4) {} // #bitfield3
563 if (a.d < 7) {} 565 if (a.d < 7) {}
564 if (a.d < 8) {} 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) {}
565 670
566 return 1; 671 return 1;
567 } 672 }