maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Sema/outof-range-constant-compare.c

277 lines
11 KiB
C
Raw Normal View History

c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
// RUN: %clang_cc1 -triple x86_64-apple-darwin -fsyntax-only -Wtautological-constant-out-of-range-compare -verify %s
// rdar://12202422
int value(void);
int main()
{
int a = value();
[Sema] -Wtautological-compare: handle comparison of unsigned with 0S. Summary: This is a first half(?) of a fix for the following bug: https://bugs.llvm.org/show_bug.cgi?id=34147 (gcc -Wtype-limits) GCC's -Wtype-limits does warn on comparison of unsigned value with signed zero (as in, with 0), but clang only warns if the zero is unsigned (i.e. 0U). Also, be careful not to double-warn, or falsely warn on comparison of signed/fp variable and signed 0. Yes, all these testcases are needed. Testing: $ ninja check-clang-sema check-clang-semacxx Also, no new warnings for clang stage-2 build. Reviewers: rjmccall, rsmith, aaron.ballman Reviewed By: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D37565 llvm-svn: 312750
2017-09-08 06:14:25 +08:00
if (a == 0x0000000000000000L)
return 0;
if (a != 0x0000000000000000L)
return 0;
if (a < 0x0000000000000000L)
return 0;
if (a <= 0x0000000000000000L)
return 0;
if (a > 0x0000000000000000L)
return 0;
if (a >= 0x0000000000000000L)
return 0;
if (0x0000000000000000L == a)
return 0;
if (0x0000000000000000L != a)
return 0;
if (0x0000000000000000L < a)
return 0;
if (0x0000000000000000L <= a)
return 0;
if (0x0000000000000000L > a)
return 0;
if (0x0000000000000000L >= a)
return 0;
if (a == 0x0000000000000000UL)
return 0;
if (a != 0x0000000000000000UL)
return 0;
if (a < 0x0000000000000000UL) // expected-warning {{comparison of unsigned expression < 0 is always false}}
return 0;
if (a <= 0x0000000000000000UL)
return 0;
if (a > 0x0000000000000000UL)
return 0;
if (a >= 0x0000000000000000UL) // expected-warning {{comparison of unsigned expression >= 0 is always true}}
return 0;
if (0x0000000000000000UL == a)
return 0;
if (0x0000000000000000UL != a)
return 0;
if (0x0000000000000000UL < a)
return 0;
if (0x0000000000000000UL <= a) // expected-warning {{comparison of 0 <= unsigned expression is always true}}
return 0;
if (0x0000000000000000UL > a) // expected-warning {{comparison of 0 > unsigned expression is always false}}
return 0;
if (0x0000000000000000UL >= a)
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a == 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a != 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a < 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a <= 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a > 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a >= 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L == a) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L != a) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L < a) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L <= a) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L > a) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L >= a) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a == 0x1234567812345678LL) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a == -0x1234567812345678L) // expected-warning {{comparison of constant -1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a < -0x1234567812345678L) // expected-warning {{comparison of constant -1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a > -0x1234567812345678L) // expected-warning {{comparison of constant -1311768465173141112 with expression of type 'int' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a <= -0x1234567812345678L) // expected-warning {{comparison of constant -1311768465173141112 with expression of type 'int' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (a >= -0x1234567812345678L) // expected-warning {{comparison of constant -1311768465173141112 with expression of type 'int' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
if (a == 0x12345678L) // no warning
return 1;
short s = value();
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (s == 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (s != 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (s < 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (s <= 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (s > 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (s >= 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L == s) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L != s) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L < s) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L <= s) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L > s) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (0x1234567812345678L >= s) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'short' is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
[Sema] -Wtautological-compare: handle comparison of unsigned with 0S. Summary: This is a first half(?) of a fix for the following bug: https://bugs.llvm.org/show_bug.cgi?id=34147 (gcc -Wtype-limits) GCC's -Wtype-limits does warn on comparison of unsigned value with signed zero (as in, with 0), but clang only warns if the zero is unsigned (i.e. 0U). Also, be careful not to double-warn, or falsely warn on comparison of signed/fp variable and signed 0. Yes, all these testcases are needed. Testing: $ ninja check-clang-sema check-clang-semacxx Also, no new warnings for clang stage-2 build. Reviewers: rjmccall, rsmith, aaron.ballman Reviewed By: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D37565 llvm-svn: 312750
2017-09-08 06:14:25 +08:00
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
long l = value();
if (l == 0x1234567812345678L)
return 0;
if (l != 0x1234567812345678L)
return 0;
if (l < 0x1234567812345678L)
return 0;
if (l <= 0x1234567812345678L)
return 0;
if (l > 0x1234567812345678L)
return 0;
if (l >= 0x1234567812345678L)
return 0;
if (0x1234567812345678L == l)
return 0;
if (0x1234567812345678L != l)
return 0;
if (0x1234567812345678L < l)
return 0;
if (0x1234567812345678L <= l)
return 0;
if (0x1234567812345678L > l)
return 0;
if (0x1234567812345678L >= l)
return 0;
unsigned un = 0;
if (un == 0x0000000000000000L)
return 0;
if (un != 0x0000000000000000L)
return 0;
[Sema] -Wtautological-compare: handle comparison of unsigned with 0S. Summary: This is a first half(?) of a fix for the following bug: https://bugs.llvm.org/show_bug.cgi?id=34147 (gcc -Wtype-limits) GCC's -Wtype-limits does warn on comparison of unsigned value with signed zero (as in, with 0), but clang only warns if the zero is unsigned (i.e. 0U). Also, be careful not to double-warn, or falsely warn on comparison of signed/fp variable and signed 0. Yes, all these testcases are needed. Testing: $ ninja check-clang-sema check-clang-semacxx Also, no new warnings for clang stage-2 build. Reviewers: rjmccall, rsmith, aaron.ballman Reviewed By: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D37565 llvm-svn: 312750
2017-09-08 06:14:25 +08:00
if (un < 0x0000000000000000L) // expected-warning {{comparison of unsigned expression < 0 is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
if (un <= 0x0000000000000000L)
return 0;
if (un > 0x0000000000000000L)
return 0;
[Sema] -Wtautological-compare: handle comparison of unsigned with 0S. Summary: This is a first half(?) of a fix for the following bug: https://bugs.llvm.org/show_bug.cgi?id=34147 (gcc -Wtype-limits) GCC's -Wtype-limits does warn on comparison of unsigned value with signed zero (as in, with 0), but clang only warns if the zero is unsigned (i.e. 0U). Also, be careful not to double-warn, or falsely warn on comparison of signed/fp variable and signed 0. Yes, all these testcases are needed. Testing: $ ninja check-clang-sema check-clang-semacxx Also, no new warnings for clang stage-2 build. Reviewers: rjmccall, rsmith, aaron.ballman Reviewed By: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D37565 llvm-svn: 312750
2017-09-08 06:14:25 +08:00
if (un >= 0x0000000000000000L) // expected-warning {{comparison of unsigned expression >= 0 is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
if (0x0000000000000000L == un)
return 0;
if (0x0000000000000000L != un)
return 0;
if (0x0000000000000000L < un)
return 0;
[Sema] -Wtautological-compare: handle comparison of unsigned with 0S. Summary: This is a first half(?) of a fix for the following bug: https://bugs.llvm.org/show_bug.cgi?id=34147 (gcc -Wtype-limits) GCC's -Wtype-limits does warn on comparison of unsigned value with signed zero (as in, with 0), but clang only warns if the zero is unsigned (i.e. 0U). Also, be careful not to double-warn, or falsely warn on comparison of signed/fp variable and signed 0. Yes, all these testcases are needed. Testing: $ ninja check-clang-sema check-clang-semacxx Also, no new warnings for clang stage-2 build. Reviewers: rjmccall, rsmith, aaron.ballman Reviewed By: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D37565 llvm-svn: 312750
2017-09-08 06:14:25 +08:00
if (0x0000000000000000L <= un) // expected-warning {{comparison of 0 <= unsigned expression is always true}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
[Sema] -Wtautological-compare: handle comparison of unsigned with 0S. Summary: This is a first half(?) of a fix for the following bug: https://bugs.llvm.org/show_bug.cgi?id=34147 (gcc -Wtype-limits) GCC's -Wtype-limits does warn on comparison of unsigned value with signed zero (as in, with 0), but clang only warns if the zero is unsigned (i.e. 0U). Also, be careful not to double-warn, or falsely warn on comparison of signed/fp variable and signed 0. Yes, all these testcases are needed. Testing: $ ninja check-clang-sema check-clang-semacxx Also, no new warnings for clang stage-2 build. Reviewers: rjmccall, rsmith, aaron.ballman Reviewed By: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D37565 llvm-svn: 312750
2017-09-08 06:14:25 +08:00
if (0x0000000000000000L > un) // expected-warning {{comparison of 0 > unsigned expression is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
if (0x0000000000000000L >= un)
return 0;
[Sema] -Wtautological-compare: handle comparison of unsigned with 0S. Summary: This is a first half(?) of a fix for the following bug: https://bugs.llvm.org/show_bug.cgi?id=34147 (gcc -Wtype-limits) GCC's -Wtype-limits does warn on comparison of unsigned value with signed zero (as in, with 0), but clang only warns if the zero is unsigned (i.e. 0U). Also, be careful not to double-warn, or falsely warn on comparison of signed/fp variable and signed 0. Yes, all these testcases are needed. Testing: $ ninja check-clang-sema check-clang-semacxx Also, no new warnings for clang stage-2 build. Reviewers: rjmccall, rsmith, aaron.ballman Reviewed By: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D37565 llvm-svn: 312750
2017-09-08 06:14:25 +08:00
if (un == 0x0000000000000000UL)
return 0;
if (un != 0x0000000000000000UL)
return 0;
if (un < 0x0000000000000000UL) // expected-warning {{comparison of unsigned expression < 0 is always false}}
return 0;
if (un <= 0x0000000000000000UL)
return 0;
if (un > 0x0000000000000000UL)
return 0;
if (un >= 0x0000000000000000UL) // expected-warning {{comparison of unsigned expression >= 0 is always true}}
return 0;
if (0x0000000000000000UL == un)
return 0;
if (0x0000000000000000UL != un)
return 0;
if (0x0000000000000000UL < un)
return 0;
if (0x0000000000000000UL <= un) // expected-warning {{comparison of 0 <= unsigned expression is always true}}
return 0;
if (0x0000000000000000UL > un) // expected-warning {{comparison of 0 > unsigned expression is always false}}
return 0;
if (0x0000000000000000UL >= un)
return 0;
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
float fl = 0;
[Sema] -Wtautological-compare: handle comparison of unsigned with 0S. Summary: This is a first half(?) of a fix for the following bug: https://bugs.llvm.org/show_bug.cgi?id=34147 (gcc -Wtype-limits) GCC's -Wtype-limits does warn on comparison of unsigned value with signed zero (as in, with 0), but clang only warns if the zero is unsigned (i.e. 0U). Also, be careful not to double-warn, or falsely warn on comparison of signed/fp variable and signed 0. Yes, all these testcases are needed. Testing: $ ninja check-clang-sema check-clang-semacxx Also, no new warnings for clang stage-2 build. Reviewers: rjmccall, rsmith, aaron.ballman Reviewed By: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D37565 llvm-svn: 312750
2017-09-08 06:14:25 +08:00
if (fl == 0x0000000000000000L)
return 0;
if (fl != 0x0000000000000000L)
return 0;
if (fl < 0x0000000000000000L)
return 0;
if (fl <= 0x0000000000000000L)
return 0;
if (fl > 0x0000000000000000L)
return 0;
if (fl >= 0x0000000000000000L)
return 0;
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
[Sema] -Wtautological-compare: handle comparison of unsigned with 0S. Summary: This is a first half(?) of a fix for the following bug: https://bugs.llvm.org/show_bug.cgi?id=34147 (gcc -Wtype-limits) GCC's -Wtype-limits does warn on comparison of unsigned value with signed zero (as in, with 0), but clang only warns if the zero is unsigned (i.e. 0U). Also, be careful not to double-warn, or falsely warn on comparison of signed/fp variable and signed 0. Yes, all these testcases are needed. Testing: $ ninja check-clang-sema check-clang-semacxx Also, no new warnings for clang stage-2 build. Reviewers: rjmccall, rsmith, aaron.ballman Reviewed By: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D37565 llvm-svn: 312750
2017-09-08 06:14:25 +08:00
if (0x0000000000000000L == fl)
return 0;
if (0x0000000000000000L != fl)
return 0;
if (0x0000000000000000L < fl)
return 0;
if (0x0000000000000000L <= fl)
return 0;
if (0x0000000000000000L > fl)
return 0;
if (0x0000000000000000L >= fl)
return 0;
double dl = 0;
if (dl == 0x0000000000000000L)
return 0;
if (dl != 0x0000000000000000L)
return 0;
if (dl < 0x0000000000000000L)
return 0;
if (dl <= 0x0000000000000000L)
return 0;
if (dl > 0x0000000000000000L)
return 0;
if (dl >= 0x0000000000000000L)
return 0;
if (0x0000000000000000L == dl)
return 0;
if (0x0000000000000000L != dl)
return 0;
if (0x0000000000000000L < dl)
return 0;
if (0x0000000000000000L <= dl)
return 0;
if (0x0000000000000000L > dl)
return 0;
if (0x0000000000000000L >= dl)
return 0;
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
enum E {
yes,
no,
maybe
};
enum E e;
Improvements to my patch in r164143 per Richard's comments. // rdar://12202422 llvm-svn: 164316
2012-09-21 03:36:41 +08:00
if (e == 0x1234567812345678L) // expected-warning {{comparison of constant 1311768465173141112 with expression of type 'enum E' is always false}}
c: warn when an integer value comparison with an integral expression have the obvious result. Patch reviewed by John McCall off line. // rdar://12202422 llvm-svn: 164143
2012-09-19 01:37:21 +08:00
return 0;
return 1;
}