424 lines
21 KiB
C++
424 lines
21 KiB
C++
// Force x86-64 because some of our heuristics are actually based
|
|
// on integer sizes.
|
|
|
|
// RUN: %clang_cc1 -triple x86_64-apple-darwin -fsyntax-only -pedantic -verify -Wsign-compare -std=c++11 %s
|
|
|
|
int test0(long a, unsigned long b) {
|
|
enum EnumA {A};
|
|
enum EnumB {B};
|
|
enum EnumC {C = 0x10000};
|
|
return
|
|
// (a,b)
|
|
(a == (unsigned long) b) + // expected-warning {{comparison of integers of different signs}}
|
|
(a == (unsigned int) b) +
|
|
(a == (unsigned short) b) +
|
|
(a == (unsigned char) b) +
|
|
((long) a == b) + // expected-warning {{comparison of integers of different signs}}
|
|
((int) a == b) + // expected-warning {{comparison of integers of different signs}}
|
|
((short) a == b) + // expected-warning {{comparison of integers of different signs}}
|
|
((signed char) a == b) + // expected-warning {{comparison of integers of different signs}}
|
|
((long) a == (unsigned long) b) + // expected-warning {{comparison of integers of different signs}}
|
|
((int) a == (unsigned int) b) + // expected-warning {{comparison of integers of different signs}}
|
|
((short) a == (unsigned short) b) +
|
|
((signed char) a == (unsigned char) b) +
|
|
(a < (unsigned long) b) + // expected-warning {{comparison of integers of different signs}}
|
|
(a < (unsigned int) b) +
|
|
(a < (unsigned short) b) +
|
|
(a < (unsigned char) b) +
|
|
((long) a < b) + // expected-warning {{comparison of integers of different signs}}
|
|
((int) a < b) + // expected-warning {{comparison of integers of different signs}}
|
|
((short) a < b) + // expected-warning {{comparison of integers of different signs}}
|
|
((signed char) a < b) + // expected-warning {{comparison of integers of different signs}}
|
|
((long) a < (unsigned long) b) + // expected-warning {{comparison of integers of different signs}}
|
|
((int) a < (unsigned int) b) + // expected-warning {{comparison of integers of different signs}}
|
|
((short) a < (unsigned short) b) +
|
|
((signed char) a < (unsigned char) b) +
|
|
|
|
// (A,b)
|
|
(A == (unsigned long) b) +
|
|
(A == (unsigned int) b) +
|
|
(A == (unsigned short) b) +
|
|
(A == (unsigned char) b) +
|
|
((long) A == b) +
|
|
((int) A == b) +
|
|
((short) A == b) +
|
|
((signed char) A == b) +
|
|
((long) A == (unsigned long) b) +
|
|
((int) A == (unsigned int) b) +
|
|
((short) A == (unsigned short) b) +
|
|
((signed char) A == (unsigned char) b) +
|
|
(A < (unsigned long) b) +
|
|
(A < (unsigned int) b) +
|
|
(A < (unsigned short) b) +
|
|
(A < (unsigned char) b) +
|
|
((long) A < b) +
|
|
((int) A < b) +
|
|
((short) A < b) +
|
|
((signed char) A < b) +
|
|
((long) A < (unsigned long) b) +
|
|
((int) A < (unsigned int) b) +
|
|
((short) A < (unsigned short) b) +
|
|
((signed char) A < (unsigned char) b) +
|
|
|
|
// (a,B)
|
|
(a == (unsigned long) B) +
|
|
(a == (unsigned int) B) +
|
|
(a == (unsigned short) B) +
|
|
(a == (unsigned char) B) +
|
|
((long) a == B) +
|
|
((int) a == B) +
|
|
((short) a == B) +
|
|
((signed char) a == B) +
|
|
((long) a == (unsigned long) B) +
|
|
((int) a == (unsigned int) B) +
|
|
((short) a == (unsigned short) B) +
|
|
((signed char) a == (unsigned char) B) +
|
|
(a < (unsigned long) B) + // expected-warning {{comparison of integers of different signs}}
|
|
(a < (unsigned int) B) +
|
|
(a < (unsigned short) B) +
|
|
(a < (unsigned char) B) +
|
|
((long) a < B) +
|
|
((int) a < B) +
|
|
((short) a < B) +
|
|
((signed char) a < B) +
|
|
((long) a < (unsigned long) B) + // expected-warning {{comparison of integers of different signs}}
|
|
((int) a < (unsigned int) B) + // expected-warning {{comparison of integers of different signs}}
|
|
((short) a < (unsigned short) B) +
|
|
((signed char) a < (unsigned char) B) +
|
|
|
|
// (C,b)
|
|
(C == (unsigned long) b) +
|
|
(C == (unsigned int) b) +
|
|
(C == (unsigned short) b) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'unsigned short' is always false}}
|
|
(C == (unsigned char) b) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'unsigned char' is always false}}
|
|
((long) C == b) +
|
|
((int) C == b) +
|
|
((short) C == b) +
|
|
((signed char) C == b) +
|
|
((long) C == (unsigned long) b) +
|
|
((int) C == (unsigned int) b) +
|
|
((short) C == (unsigned short) b) +
|
|
((signed char) C == (unsigned char) b) +
|
|
(C < (unsigned long) b) +
|
|
(C < (unsigned int) b) +
|
|
(C < (unsigned short) b) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'unsigned short' is always false}}
|
|
(C < (unsigned char) b) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'unsigned char' is always false}}
|
|
((long) C < b) +
|
|
((int) C < b) +
|
|
((short) C < b) +
|
|
((signed char) C < b) +
|
|
((long) C < (unsigned long) b) +
|
|
((int) C < (unsigned int) b) +
|
|
((short) C < (unsigned short) b) +
|
|
((signed char) C < (unsigned char) b) +
|
|
|
|
// (a,C)
|
|
(a == (unsigned long) C) +
|
|
(a == (unsigned int) C) +
|
|
(a == (unsigned short) C) +
|
|
(a == (unsigned char) C) +
|
|
((long) a == C) +
|
|
((int) a == C) +
|
|
((short) a == C) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'short' is always false}}
|
|
((signed char) a == C) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'signed char' is always false}}
|
|
((long) a == (unsigned long) C) +
|
|
((int) a == (unsigned int) C) +
|
|
((short) a == (unsigned short) C) +
|
|
((signed char) a == (unsigned char) C) +
|
|
(a < (unsigned long) C) + // expected-warning {{comparison of integers of different signs}}
|
|
(a < (unsigned int) C) +
|
|
(a < (unsigned short) C) +
|
|
(a < (unsigned char) C) +
|
|
((long) a < C) +
|
|
((int) a < C) +
|
|
((short) a < C) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'short' is always true}}
|
|
((signed char) a < C) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'signed char' is always true}}
|
|
((long) a < (unsigned long) C) + // expected-warning {{comparison of integers of different signs}}
|
|
((int) a < (unsigned int) C) + // expected-warning {{comparison of integers of different signs}}
|
|
((short) a < (unsigned short) C) +
|
|
((signed char) a < (unsigned char) C) +
|
|
|
|
// (0x80000,b)
|
|
(0x80000 == (unsigned long) b) +
|
|
(0x80000 == (unsigned int) b) +
|
|
(0x80000 == (unsigned short) b) + // expected-warning {{comparison of constant 524288 with expression of type 'unsigned short' is always false}}
|
|
(0x80000 == (unsigned char) b) + // expected-warning {{comparison of constant 524288 with expression of type 'unsigned char' is always false}}
|
|
((long) 0x80000 == b) +
|
|
((int) 0x80000 == b) +
|
|
((short) 0x80000 == b) +
|
|
((signed char) 0x80000 == b) +
|
|
((long) 0x80000 == (unsigned long) b) +
|
|
((int) 0x80000 == (unsigned int) b) +
|
|
((short) 0x80000 == (unsigned short) b) +
|
|
((signed char) 0x80000 == (unsigned char) b) +
|
|
(0x80000 < (unsigned long) b) +
|
|
(0x80000 < (unsigned int) b) +
|
|
(0x80000 < (unsigned short) b) + // expected-warning {{comparison of constant 524288 with expression of type 'unsigned short' is always false}}
|
|
(0x80000 < (unsigned char) b) + // expected-warning {{comparison of constant 524288 with expression of type 'unsigned char' is always false}}
|
|
((long) 0x80000 < b) +
|
|
((int) 0x80000 < b) +
|
|
((short) 0x80000 < b) +
|
|
((signed char) 0x80000 < b) +
|
|
((long) 0x80000 < (unsigned long) b) +
|
|
((int) 0x80000 < (unsigned int) b) +
|
|
((short) 0x80000 < (unsigned short) b) +
|
|
((signed char) 0x80000 < (unsigned char) b) +
|
|
|
|
// (a,0x80000)
|
|
(a == (unsigned long) 0x80000) +
|
|
(a == (unsigned int) 0x80000) +
|
|
(a == (unsigned short) 0x80000) +
|
|
(a == (unsigned char) 0x80000) +
|
|
((long) a == 0x80000) +
|
|
((int) a == 0x80000) +
|
|
((short) a == 0x80000) + // expected-warning {{comparison of constant 524288 with expression of type 'short' is always false}}
|
|
((signed char) a == 0x80000) + // expected-warning {{comparison of constant 524288 with expression of type 'signed char' is always false}}
|
|
((long) a == (unsigned long) 0x80000) +
|
|
((int) a == (unsigned int) 0x80000) +
|
|
((short) a == (unsigned short) 0x80000) +
|
|
((signed char) a == (unsigned char) 0x80000) +
|
|
(a < (unsigned long) 0x80000) + // expected-warning {{comparison of integers of different signs}}
|
|
(a < (unsigned int) 0x80000) +
|
|
(a < (unsigned short) 0x80000) +
|
|
(a < (unsigned char) 0x80000) +
|
|
((long) a < 0x80000) +
|
|
((int) a < 0x80000) +
|
|
((short) a < 0x80000) + // expected-warning {{comparison of constant 524288 with expression of type 'short' is always true}}
|
|
((signed char) a < 0x80000) + // expected-warning {{comparison of constant 524288 with expression of type 'signed char' is always true}}
|
|
((long) a < (unsigned long) 0x80000) + // expected-warning {{comparison of integers of different signs}}
|
|
((int) a < (unsigned int) 0x80000) + // expected-warning {{comparison of integers of different signs}}
|
|
((short) a < (unsigned short) 0x80000) +
|
|
((signed char) a < (unsigned char) 0x80000) +
|
|
|
|
10
|
|
;
|
|
}
|
|
|
|
int test1(int i) {
|
|
enum en { zero };
|
|
return i > zero;
|
|
}
|
|
|
|
enum E { e };
|
|
void test2(int i, void *vp) {
|
|
if (test1 == vp) { } // expected-warning{{equality comparison between function pointer and void pointer}}
|
|
if (test1 == e) { } // expected-error{{comparison between pointer and integer}}
|
|
if (vp < 0) { }
|
|
if (test1 < e) { } // expected-error{{comparison between pointer and integer}}
|
|
}
|
|
|
|
// PR7536
|
|
static const unsigned int kMax = 0;
|
|
int pr7536() {
|
|
return (kMax > 0);
|
|
}
|
|
|
|
// -Wsign-compare should not warn when ?: operands have different signedness.
|
|
// This will be caught by -Wsign-conversion
|
|
void test3() {
|
|
unsigned long a;
|
|
signed long b;
|
|
(void) (true ? a : b);
|
|
(void) (true ? (unsigned int)a : (signed int)b);
|
|
(void) (true ? b : a);
|
|
(void) (true ? (unsigned char)b : (signed char)a);
|
|
}
|
|
|
|
// Test comparison of short to unsigned. If tautological compare does not
|
|
// trigger, then the signed comparision warning will.
|
|
void test4(short s) {
|
|
// A is max short plus 1. All zero and positive shorts are smaller than it.
|
|
// All negative shorts are cast towards the max unsigned range. Relation
|
|
// comparisons are possible, but equality comparisons are tautological.
|
|
const unsigned A = 32768;
|
|
void (s < A); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
void (s > A); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
void (s <= A); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
void (s >= A); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
|
|
void (s == A); // expected-warning{{comparison of constant 32768 with expression of type 'short' is always false}}
|
|
void (s != A); // expected-warning{{comparison of constant 32768 with expression of type 'short' is always true}}
|
|
|
|
// When negative one is converted to an unsigned value, it becomes the max
|
|
// unsigned. Likewise, a negative one short can also be converted to max
|
|
// unsigned.
|
|
const unsigned B = -1;
|
|
void (s < B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
void (s > B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
void (s <= B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
void (s >= B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
void (s == B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
void (s != B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
|
|
|
|
}
|
|
|
|
void test5(bool b) {
|
|
(void) (b < -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always false}}
|
|
(void) (b > -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always true}}
|
|
(void) (b == -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always false}}
|
|
(void) (b != -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always true}}
|
|
(void) (b <= -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always false}}
|
|
(void) (b >= -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always true}}
|
|
|
|
(void) (b < -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always false}}
|
|
(void) (b > -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always true}}
|
|
(void) (b == -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always false}}
|
|
(void) (b != -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always true}}
|
|
(void) (b <= -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always false}}
|
|
(void) (b >= -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always true}}
|
|
|
|
(void) (b < 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always true}}
|
|
(void) (b > 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always false}}
|
|
(void) (b == 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always false}}
|
|
(void) (b != 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always true}}
|
|
(void) (b <= 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always true}}
|
|
(void) (b >= 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always false}}
|
|
|
|
(void) (b < 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always true}}
|
|
(void) (b > 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always false}}
|
|
(void) (b == 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always false}}
|
|
(void) (b != 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always true}}
|
|
(void) (b <= 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always true}}
|
|
(void) (b >= 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always false}}
|
|
}
|
|
|
|
void test6(signed char sc) {
|
|
(void)(sc < 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
|
|
(void)(sc > 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
|
|
(void)(sc <= 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
|
|
(void)(sc >= 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
|
|
(void)(sc == 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
|
|
(void)(sc != 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
|
|
|
|
(void)(200 < sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
|
|
(void)(200 > sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
|
|
(void)(200 <= sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
|
|
(void)(200 >= sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
|
|
(void)(200 == sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
|
|
(void)(200 != sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
|
|
}
|
|
|
|
// Test many signedness combinations.
|
|
void test7(unsigned long other) {
|
|
// Common unsigned, other unsigned, constant unsigned
|
|
(void)((unsigned)other != (unsigned long)(0x1ffffffff)); // expected-warning{{true}}
|
|
(void)((unsigned)other != (unsigned long)(0xffffffff));
|
|
(void)((unsigned long)other != (unsigned)(0x1ffffffff));
|
|
(void)((unsigned long)other != (unsigned)(0xffffffff));
|
|
|
|
// Common unsigned, other signed, constant unsigned
|
|
(void)((int)other != (unsigned long)(0xffffffffffffffff)); // expected-warning{{different signs}}
|
|
(void)((int)other != (unsigned long)(0x00000000ffffffff)); // expected-warning{{true}}
|
|
(void)((int)other != (unsigned long)(0x000000000fffffff));
|
|
(void)((int)other < (unsigned long)(0x00000000ffffffff)); // expected-warning{{different signs}}
|
|
(void)((int)other == (unsigned)(0x800000000));
|
|
|
|
// Common unsigned, other unsigned, constant signed
|
|
(void)((unsigned long)other != (int)(0xffffffff)); // expected-warning{{different signs}}
|
|
|
|
// Common unsigned, other signed, constant signed
|
|
// Should not be possible as the common type should also be signed.
|
|
|
|
// Common signed, other signed, constant signed
|
|
(void)((int)other != (long)(0xffffffff)); // expected-warning{{true}}
|
|
(void)((int)other != (long)(0xffffffff00000000)); // expected-warning{{true}}
|
|
(void)((int)other != (long)(0xfffffff));
|
|
(void)((int)other != (long)(0xfffffffff0000000));
|
|
|
|
// Common signed, other signed, constant unsigned
|
|
(void)((int)other != (unsigned char)(0xffff));
|
|
(void)((int)other != (unsigned char)(0xff));
|
|
|
|
// Common signed, other unsigned, constant signed
|
|
(void)((unsigned char)other != (int)(0xff));
|
|
(void)((unsigned char)other != (int)(0xffff)); // expected-warning{{true}}
|
|
|
|
// Common signed, other unsigned, constant unsigned
|
|
(void)((unsigned char)other != (unsigned short)(0xff));
|
|
(void)((unsigned char)other != (unsigned short)(0x100)); // expected-warning{{true}}
|
|
(void)((unsigned short)other != (unsigned char)(0xff));
|
|
}
|
|
|
|
void test8(int x) {
|
|
enum E {
|
|
Negative = -1,
|
|
Positive = 1
|
|
};
|
|
|
|
(void)((E)x == 1);
|
|
(void)((E)x == -1);
|
|
}
|
|
|
|
void test9(int x) {
|
|
enum E : int {
|
|
Positive = 1
|
|
};
|
|
(void)((E)x == 1);
|
|
}
|
|
|
|
namespace templates {
|
|
template<class T> T max();
|
|
|
|
template<> constexpr int max<int>() { return 2147483647; };
|
|
|
|
template<typename T>
|
|
bool less_than_max(short num, T value) {
|
|
const T vmax = max<T>();
|
|
return (vmax >= num); // no warning
|
|
}
|
|
|
|
template<typename T>
|
|
bool less_than_max(short num) {
|
|
// This should trigger one warning on the template pattern, and not a
|
|
// warning per specialization.
|
|
return num < max<int>(); // expected-warning{{comparison of constant 2147483647 with expression of type 'short' is always true}}
|
|
}
|
|
|
|
void test10(short num, int x) {
|
|
less_than_max(num, x);
|
|
less_than_max<int>(num);
|
|
less_than_max<long>(num);
|
|
less_than_max<short>(num);
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool less_than_zero(T num, T value) {
|
|
return num < 0; // no warning
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool less_than_zero(unsigned num) {
|
|
// This should trigger one warning on the template pattern, and not a
|
|
// warning per specialization.
|
|
return num < 0; // expected-warning{{comparison of unsigned expression < 0 is always false}}
|
|
}
|
|
|
|
void test11(unsigned num) {
|
|
less_than_zero(num, num);
|
|
less_than_zero<int>(num);
|
|
less_than_zero<long>(num);
|
|
less_than_zero<short>(num);
|
|
}
|
|
|
|
template<unsigned n> bool compare(unsigned k) { return k >= n; }
|
|
|
|
void test12() {
|
|
compare<0>(42);
|
|
}
|
|
|
|
struct A { static int x; };
|
|
struct B { static int x; };
|
|
typedef A otherA;
|
|
|
|
template <typename T>
|
|
void testx() {
|
|
if (A::x == T::x && // no warning
|
|
A::x == otherA::x) // expected-warning{{self-comparison always evaluates to true}}
|
|
return;
|
|
}
|
|
|
|
void test13() {
|
|
testx<A>();
|
|
testx<B>();
|
|
}
|
|
}
|