Page MenuHomePhabricator
Differential D49074 Diff 174190 test/Analysis/multiplicative-folding.c

Changeset View

Standalone View

View Options

test/Analysis/multiplicative-folding.c

Show First 20 Lines • Show All 564 Lines • ▼ Show 20 Lines if (n / 2 != 3) {
clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}} clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}} //expected-warning@-1{{TRUE}}
} }
} }
} }
} }
} }
void signed_multiplication_lt_0(int32_t n) {
if (n * 2 < 3) {
int32_t U1 = 0x80000001,
L2 = 0xc0000000, U2 = 1,
L3 = 0x40000000;
assert(INT_MIN * 2 < 3);
assert(U1 * 2 < 3);
assert((U1 + 1) * 2 >= 3);
assert(L2 * 2 < 3);
assert((L2 - 1) * 2 >= 3);
assert(U2 * 2 < 3);
assert((U2 + 1) * 2 >= 3);
assert(L3 * 2 < 3);
assert((L3 - 1) * 2 >= 3);
assert(INT_MAX * 2 < 3);
if (n < INT_MIN / 2) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < INT_MAX / 2){
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_multiplication_lt_1(int32_t n) {
if (n * 2 < 4) {
int32_t U1 = 0x80000001,
L2 = 0xc0000000, U2 = 1,
L3 = 0x40000000;
assert(INT_MIN * 2 < 4);
assert(U1 * 2 < 4);
assert((U1 + 1) * 2 >= 4);
assert(L2 * 2 < 4);
assert((L2 - 1) * 2 >= 4);
assert(U2 * 2 < 4);
assert((U2 + 1) * 2 >= 4);
assert(L3 * 2 < 4);
assert((L3 - 1) * 2 >= 4);
assert(INT_MAX * 2 < 4);
if (n < INT_MIN / 2) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < INT_MAX / 2){
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_multiplication_lt_2(int32_t n) {
if (n * 2 < 5) {
int32_t U1 = 0x80000002,
L2 = 0xc0000000, U2 = 2,
L3 = 0x40000000;
assert(INT_MIN * 2 < 5);
assert(U1 * 2 < 5);
assert((U1 + 1) * 2 >= 5);
assert(L2 * 2 < 5);
assert((L2 - 1) * 2 >= 5);
assert(U2 * 2 < 5);
assert((U2 + 1) * 2 >= 5);
assert(L3 * 2 < 5);
assert((L3 - 1) * 2 >= 5);
assert(INT_MAX * 2 < 5);
if (n < INT_MIN / 2) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < INT_MAX / 2){
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_multiplication_lt_3(int32_t n) {
if (n * 3 < 4) {
int32_t U1 = 0xaaaaaaab,
L2 = 0xd5555556, U2 = 1,
L3 = 0x2aaaaaab, U3 = 0x55555556;
assert(INT_MIN * 3 < 4);
assert(U1 * 3 < 4);
assert((U1 + 1) * 3 >= 4);
assert(L2 * 3 < 4);
assert((L2 - 1) * 3 >= 4);
assert(U2 * 3 < 4);
assert((U2 + 1) * 3 >= 4);
assert(L3 * 3 < 4);
assert((L3 - 1) * 3 >= 4);
assert(U3 * 3 < 4);
assert((U3 + 1) * 3 >= 4);
if (n < (int32_t) 0xc0000000) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x15555556) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U3); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U3); //expected-warning{{FALSE}}
}
}
}
void signed_multiplication_lt_4(int32_t n) {
if (n * 6 < -2) {
int32_t L1 = 0x95555556, U1 = 0xaaaaaaaa,
L2 = 0xc0000000, U2 = 0x55555554,
L3 = 0xeaaaaaab, U3 = -1,
L4 = 0x15555556, U4 = 0x2aaaaaaa,
L5 = 0x40000000, U5 = 0x55555554,
L6 = 0x6aaaaaab;
assert(L1 * 6 < -2);
assert((L1 - 1) * 6 >= -2);
assert(U1 * 6 < -2);
assert((U1 + 1) * 6 >= -2);
assert(L2 * 6 < -2);
assert((L2 - 1) * 6 >= -2);
assert(U2 * 6 < -2);
assert((U2 + 1) * 6 >= -2);
assert(L3 * 6 < -2);
assert((L3 - 1) * 6 >= -2);
assert(U3 * 6 < -2);
assert((U3 + 1) * 6 >= -2);
assert(L4 * 6 < -2);
assert((L4 - 1) * 6 >= -2);
assert(U4 * 6 < -2);
assert((U4 + 1) * 6 >= -2);
assert(L5 * 6 < -2);
assert((L5 - 1) * 6 >= -2);
assert(U5 * 6 < -2);
assert((U5 + 1) * 6 >= -2);
assert(L6 * 6 < -2);
assert((L6 - 1) * 6 >= -2);
assert(INT_MAX * 6 < -2);
if (n < (int32_t) 0xb5555555) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0xdfffffff) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x0aaaaaaa) {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U3); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U3); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x35555555) {
clang_analyzer_eval(n < L4); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L4); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U4); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U4); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x5fffffff) {
clang_analyzer_eval(n < L5); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L5); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U5); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U5); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L6); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L6); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_division_lt_0(int32_t n) {
if (n / 4 < 0) {
const int32_t C = -4;
assert(C / 4 < 0);
assert((C + 1) / 4 >= 0);
clang_analyzer_eval(n <= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C); //expected-warning{{FALSE}}
}
}
void signed_division_lt_1(int32_t n) {
if (n / 3 < 2) {
const int32_t C = 5;
assert(C / 3 < 2);
assert((C + 1) / 3 >= 2);
clang_analyzer_eval(n <= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C); //expected-warning{{FALSE}}
}
}
void signed_division_lt_2(int32_t n) {
if (n / 5 < -7) {
const int32_t C = -40;
assert(C / 5 < -7);
assert((C + 1) / 5 >= -7);
clang_analyzer_eval(n <= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C); //expected-warning{{FALSE}}
}
}
void unsigned_multiplication_lt_0(uint32_t n) {
if (n * 2 < 3) {
uint32_t U1 = 1,
L2 = 0x80000000, U2 = 0x80000001;
assert(U1 * 2 < 3);
assert((U1 + 1) * 2 >= 3);
assert(L2 * 2 < 3);
assert((L2 - 1) * 2 >= 3);
assert(U2 * 2 < 3);
assert((U2 + 1) * 2 >= 3);
if (n < UINT_MAX / 2) {
clang_analyzer_eval(n == 0); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void unsigned_multiplication_lt_1(uint32_t n) {
if (n * 2 < 4) {
uint32_t U1 = 1,
L2 = 0x80000000, U2 = 0x80000001;
assert(U1 * 2 < 4);
assert((U1 + 1) * 2 >= 4);
assert(L2 * 2 < 4);
assert((L2 - 1) * 2 >= 4);
assert(U2 * 2 < 4);
assert((U2 + 1) * 2 >= 4);
if (n < UINT_MAX / 2) {
clang_analyzer_eval(n == 0); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void unsigned_multiplication_lt_2(uint32_t n) {
if (n * 2 < 5) {
uint32_t U1 = 2,
L2 = 0x80000000, U2 = 0x80000002;
assert(U1 * 2 < 5);
assert((U1 + 1) * 2 >= 5);
assert(L2 * 2 < 5);
assert((L2 - 1) * 2 >= 5);
assert(U2 * 2 < 5);
assert((U2 + 1) * 2 >= 5);
if (n < UINT_MAX / 2) {
clang_analyzer_eval(n == 0); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void unsigned_multiplication_lt_3(uint32_t n) {
if (n * 3 < 4) {
uint32_t U1 = 1, C2 = 0x55555556, C3 = 0xaaaaaaab;
assert(U1 * 3 < 4);
assert((U1 + 1) * 3 >= 4);
assert(C2 * 3 < 4);
assert((C2 - 1) * 3 >= 4);
assert((C2 + 1) * 3 >= 4);
assert(C3 * 3 < 4);
assert((C3 - 1) * 3 >= 4);
assert((C3 + 1) * 3 >= 4);
if (n < 0x2aaaaaab) {
clang_analyzer_eval(n == 0); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < 0x80000000) {
clang_analyzer_eval(n < C2); //expected-warning{{FALSE}}
clang_analyzer_eval(n == C2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < C3); //expected-warning{{FALSE}}
clang_analyzer_eval(n == C3); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C3); //expected-warning{{FALSE}}
}
}
}
void unsigned_division_lt_0(uint32_t n) {
if (n / 3 < 2) {
const uint32_t C = 5;
assert(C / 3 < 2);
assert((C + 1) / 3 >= 2);
clang_analyzer_eval(n <= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C); //expected-warning{{FALSE}}
}
}
void signed_multiplication_le_0(int32_t n) {
if (n * 2 <= 3) {
int32_t U1 = 0x80000001,
L2 = 0xc0000000, U2 = 1,
L3 = 0x40000000;
assert(INT_MIN * 2 <= 3);
assert(U1 * 2 <= 3);
assert((U1 + 1) * 2 > 3);
assert(L2 * 2 <= 3);
assert((L2 - 1) * 2 > 3);
assert(U2 * 2 <= 3);
assert((U2 + 1) * 2 > 3);
assert(L3 * 2 <= 3);
assert((L3 - 1) * 2 > 3);
assert(INT_MAX * 2 <= 3);
if (n < INT_MIN / 2) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < INT_MAX / 2) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_multiplication_le_1(int32_t n) {
if (n * 2 <= 4) {
int32_t U1 = 0x80000002,
L2 = 0xc0000000, U2 = 2,
L3 = 0x40000000;
assert(INT_MIN * 2 <= 4);
assert(U1 * 2 <= 4);
assert((U1 + 1) * 2 > 4);
assert(L2 * 2 <= 4);
assert((L2 - 1) * 2 > 4);
assert(U2 * 2 <= 4);
assert((U2 + 1) * 2 > 4);
assert(L3 * 2 <= 4);
assert((L3 - 1) * 2 > 4);
assert(INT_MAX * 2 <= 4);
if (n < INT_MIN / 2) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < INT_MAX / 2){
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_multiplication_le_2(int32_t n) {
if (n * 2 <= 5) {
int32_t U1 = 0x80000002,
L2 = 0xc0000000, U2 = 2,
L3 = 0x40000000;
assert(INT_MIN * 2 <= 5);
assert(U1 * 2 <= 5);
assert((U1 + 1) * 2 > 5);
assert(L2 * 2 <= 5);
assert((L2 - 1) * 2 > 5);
assert(U2 * 2 <= 5);
assert((U2 + 1) * 2 > 5);
assert(L3 * 2 <= 5);
assert((L3 - 1) * 2 > 5);
assert(INT_MAX * 2 <= 5);
if (n < INT_MIN / 2) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < INT_MAX / 2) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_multiplication_le_3(int32_t n) {
if (n * 3 <= 4) {
int32_t U1 = 0xaaaaaaac,
L2 = 0xd5555556, U2 = 1,
L3 = 0x2aaaaaab, U3 = 0x55555556;
assert(INT_MIN * 3 <= 4);
assert(U1 * 3 <= 4);
assert((U1 + 1) * 3 > 4);
assert(L2 * 3 <= 4);
assert((L2 - 1) * 3 > 4);
assert(U2 * 3 <= 4);
assert((U2 + 1) * 3 > 4);
assert(L3 * 3 <= 4);
assert((L3 - 1) * 3 > 4);
assert(U3 * 3 <= 4);
assert((U3 + 1) * 3 > 4);
if (n < (int32_t) 0xc0000001) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x15555556) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U3); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U3); //expected-warning{{FALSE}}
}
}
}
void signed_multiplication_le_4(int32_t n) {
if (n * 6 <= -2) {
int32_t L1 = 0x95555556, U1 = 0xaaaaaaaa,
L2 = 0xc0000000, U2 = 0x55555555,
L3 = 0xeaaaaaab, U3 = -1,
L4 = 0x15555556, U4 = 0x2aaaaaaa,
L5 = 0x40000000, U5 = 0x55555555,
L6 = 0x6aaaaaab;
assert(L1 * 6 <= -2);
assert((L1 - 1) * 6 > -2);
assert(U1 * 6 <= -2);
assert((U1 + 1) * 6 > -2);
assert(L2 * 6 <= -2);
assert((L2 - 1) * 6 > -2);
assert(U2 * 6 <= -2);
assert((U2 + 1) * 6 > -2);
assert(L3 * 6 <= -2);
assert((L3 - 1) * 6 > -2);
assert(U3 * 6 <= -2);
assert((U3 + 1) * 6 > -2);
assert(L4 * 6 <= -2);
assert((L4 - 1) * 6 > -2);
assert(U4 * 6 <= -2);
assert((U4 + 1) * 6 > -2);
assert(L5 * 6 <= -2);
assert((L5 - 1) * 6 > -2);
assert(U5 * 6 <= -2);
assert((U5 + 1) * 6 > -2);
assert(L6 * 6 <= -2);
assert((L6 - 1) * 6 > -2);
assert(INT_MAX * 6 <= -2);
if (n < (int32_t) 0xb5555555) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0xe0000000) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x0aaaaaaa) {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U3); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U3); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x35555555) {
clang_analyzer_eval(n < L4); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L4); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U4); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U4); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x60000000) {
clang_analyzer_eval(n < L5); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L5); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U5); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U5); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L6); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L6); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_division_le_0(int32_t n) {
if (n / 4 <= 0) {
const int32_t C = 3;
assert(C / 4 <= 0);
assert((C + 1) / 4 > 0);
clang_analyzer_eval(n <= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C); //expected-warning{{FALSE}}
}
}
void signed_division_le_1(int32_t n) {
if (n / 3 <= 2) {
const int32_t C = 8;
assert(C / 3 <= 2);
assert((C + 1) / 3 > 2);
clang_analyzer_eval(n <= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C); //expected-warning{{FALSE}}
}
}
void signed_division_le_2(int32_t n) {
if (n / 5 <= -7) {
const int32_t C = -35;
assert(C / 5 <= -7);
assert((C + 1) / 5 > -7);
clang_analyzer_eval(n <= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C); //expected-warning{{FALSE}}
}
}
void unsigned_multiplication_le_0(uint32_t n) {
if (n * 2 <= 3) {
uint32_t U1 = 1,
L2 = 0x80000000, U2 = 0x80000001;
assert(U1 * 2 <= 3);
assert((U1 + 1) * 2 > 3);
assert(L2 * 2 <= 3);
assert((L2 - 1) * 2 > 3);
assert(U2 * 2 <= 3);
assert((U2 + 1) * 2 > 3);
if (n < UINT_MAX / 2) {
clang_analyzer_eval(n == 0); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void unsigned_multiplication_le_1(uint32_t n) {
if (n * 2 <= 4) {
uint32_t U1 = 2,
L2 = 0x80000000, U2 = 0x80000002;
assert(U1 * 2 <= 4);
assert((U1 + 1) * 2 > 4);
assert(L2 * 2 <= 4);
assert((L2 - 1) * 2 > 4);
assert(U2 * 2 <= 4);
assert((U2 + 1) * 2 > 4);
if (n < UINT_MAX / 2) {
clang_analyzer_eval(n == 0); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void unsigned_multiplication_le_2(uint32_t n) {
if (n * 2 <= 5) {
uint32_t U1 = 2,
L2 = 0x80000000, U2 = 0x80000002;
assert(U1 * 2 <= 5);
assert((U1 + 1) * 2 > 5);
assert(L2 * 2 <= 5);
assert((L2 - 1) * 2 > 5);
assert(U2 * 2 <= 5);
assert((U2 + 1) * 2 > 5);
if (n < UINT_MAX / 2) {
clang_analyzer_eval(n == 0); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void unsigned_multiplication_le_3(uint32_t n) {
if (n * 3 <= 4) {
uint32_t U1 = 1,
C2 = 0x55555556,
L3 = 0xaaaaaaab, U3 = 0xaaaaaaac;
assert(U1 * 3 <= 4);
assert((U1 + 1) * 3 > 4);
assert(C2 * 3 <= 4);
assert((C2 - 1) * 3 > 4);
assert((C2 + 1) * 3 > 4);
assert(L3 * 3 <= 4);
assert((L3 - 1) * 3 > 4);
assert(U3 * 3 <= 4);
assert((U3 + 1) * 3 > 4);
if (n < 0x2aaaaaab) {
clang_analyzer_eval(n == 0); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < 0x80000000) {
clang_analyzer_eval(n < C2); //expected-warning{{FALSE}}
clang_analyzer_eval(n == C2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U3); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U3); //expected-warning{{FALSE}}
}
}
}
void unsigned_division_le_0(uint32_t n) {
if (n / 4 <= 0) {
const uint32_t C = 3;
assert(C / 4 <= 0);
assert((C + 1) / 4 > 0);
clang_analyzer_eval(n <= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C); //expected-warning{{FALSE}}
}
}
void unsigned_division_le_1(uint32_t n) {
if (n / 3 <= 2) {
const uint32_t C = 8;
assert(C / 3 <= 2);
assert((C + 1) / 3 > 2);
clang_analyzer_eval(n <= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n > C); //expected-warning{{FALSE}}
}
}
void signed_multiplication_gt_0(int32_t n) {
if (n * 2 > 3) {
int32_t L1 = 0x80000002, U1 = 0xbfffffff,
L2 = 2, U2 = 0x3fffffff;
assert(L1 * 2 > 3);
assert((L1 - 1) * 2 <= 3);
assert(U1 * 2 > 3);
assert((U1 + 1) * 2 <= 3);
assert(L2 * 2 > 3);
assert((L2 - 1) * 2 <= 3);
assert(U2 * 2 > 3);
assert((U2 + 1) * 2 <= 3);
if (n < 0) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void signed_multiplication_gt_1(int32_t n) {
if (n * 2 > 4) {
int32_t L1 = 0x80000003, U1 = 0xbfffffff,
L2 = 3, U2 = 0x3fffffff;
assert(L1 * 2 > 4);
assert((L1 - 1) * 2 <= 4);
assert(U1 * 2 > 4);
assert((U1 + 1) * 2 <= 4);
assert(L2 * 2 > 4);
assert((L2 - 1) * 2 <= 4);
assert(U2 * 2 > 4);
assert((U2 + 1) * 2 <= 4);
if (n < 0) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void signed_multiplication_gt_2(int32_t n) {
if (n * 2 > 5) {
int32_t L1 = 0x80000003, U1 = 0xbfffffff,
L2 = 3, U2 = 0x3fffffff;
assert(L1 * 2 > 5);
assert((L1 - 1) * 2 <= 5);
assert(U1 * 2 > 5);
assert((U1 + 1) * 2 <= 5);
assert(L2 * 2 > 5);
assert((L2 - 1) * 2 <= 5);
assert(U2 * 2 > 5);
assert((U2 + 1) * 2 <= 5);
if (n < 0) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void signed_multiplication_gt_3(int32_t n) {
if (n * 3 > 4) {
int32_t L1 = 0xaaaaaaad, U1 = 0xd5555555,
L2 = 2, U2 = 0x2aaaaaaa,
L3 = 0x55555557;
assert(L1 * 3 > 4);
assert((L1 - 1) * 3 <= 4);
assert(U1 * 3 > 4);
assert((U1 + 1) * 3 <= 4);
assert(L2 * 3 > 4);
assert((L2 - 1) * 3 <= 4);
assert(U2 * 3 > 4);
assert((U2 + 1) * 3 <= 4);
assert(L3 * 3 > 4);
assert((L3 - 1) * 3 <= 4);
assert(INT_MAX * 3 > 4);
if (n < 0) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < INT_MAX / 2) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_multiplication_gt_4(int32_t n) {
if (n * 6 > -2) {
int32_t U1 = 0x95555555,
L2 = 0xaaaaaaab, U2 = 0xbfffffff,
L3 = 0xd5555556, U3 = 0xeaaaaaaa,
L4 = 0, U4 = 0x15555555,
L5 = 0x2aaaaaab, U5 = 0x3fffffff,
L6 = 0x55555556, U6 = 0x6aaaaaaa;
assert(INT_MIN * 6 > -2);
assert(U1 * 6 > -2);
assert((U1 + 1) * 6 <= -2);
assert(L2 * 6 > -2);
assert((L2 - 1) * 6 <= -2);
assert(U2 * 6 > -2);
assert((U2 + 1) * 6 <= -2);
assert(L3 * 6 > -2);
assert((L3 - 1) * 6 <= -2);
assert(U3 * 6 > -2);
assert((U3 + 1) * 6 <= -2);
assert(L4 * 6 > -2);
assert((L4 - 1) * 6 <= -2);
assert(U4 * 6 > -2);
assert((U4 + 1) * 6 <= -2);
assert(L5 * 6 > -2);
assert((L5 - 1) * 6 <= -2);
assert(U5 * 6 > -2);
assert((U5 + 1) * 6 <= -2);
assert(L6 * 6 > -2);
assert((L6 - 1) * 6 <= -2);
assert(U6 * 6 > -2);
assert((U6 + 1) * 6 <= -2);
if (n < (int32_t) 0xa0000000) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0xcaaaaaaa) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0xf5555555) {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U3); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U3); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x20000000) {
clang_analyzer_eval(n < L4); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L4); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U4); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U4); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x4aaaaaaa) {
clang_analyzer_eval(n < L5); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L5); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U5); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U5); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L6); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L6); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U6); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U6); //expected-warning{{FALSE}}
}
}
}
void signed_division_gt_0(int32_t n) {
if (n / 4 > 0) {
const int32_t C = 4;
assert(C / 4 > 0);
assert((C - 1) / 4 <= 0);
clang_analyzer_eval(n >= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n < C); //expected-warning{{FALSE}}
}
}
void signed_division_gt_1(int32_t n) {
if (n / 3 > 2) {
const int32_t C = 9;
assert(C / 3 > 2);
assert((C - 1) / 3 <= 2);
clang_analyzer_eval(n >= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n < C); //expected-warning{{FALSE}}
}
}
void signed_division_gt_2(int32_t n) {
if (n / 5 > -7) {
const int32_t C = -34;
assert(C / 5 > -7);
assert((C - 1) / 5 <= -7);
clang_analyzer_eval(n >= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n < C); //expected-warning{{FALSE}}
}
}
void unsigned_multiplication_gt_0(uint32_t n) {
if (n * 2 > 3) {
uint32_t L1 = 2, U1 = 0x7fffffff,
L2 = 0x80000002;
assert(L1 * 2 > 3);
assert((L1 - 1) * 2 <= 3);
assert(U1 * 2 > 3);
assert((U1 + 1) * 2 <= 3);
assert(L2 * 2 > 3);
assert((L2 - 1) * 2 <= 3);
assert(UINT_MAX * 2 > 3);
if (n < UINT_MAX / 2 + 1) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void unsigned_multiplication_gt_1(uint32_t n) {
if (n * 2 > 4) {
uint32_t L1 = 3, U1 = 0x7fffffff,
L2 = 0x80000003;
assert(L1 * 2 > 4);
assert((L1 - 1) * 2 <= 4);
assert(U1 * 2 > 4);
assert((U1 + 1) * 2 <= 4);
assert(L2 * 2 > 4);
assert((L2 - 1) * 2 <= 4);
assert(UINT_MAX * 2 > 4);
if (n < UINT_MAX / 2 + 1) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void unsigned_multiplication_gt_2(uint32_t n) {
if (n * 2 > 5) {
uint32_t L1 = 3, U1 = 0x7fffffff,
L2 = 0x80000003;
assert(L1 * 2 > 5);
assert((L1 - 1) * 2 <= 5);
assert(U1 * 2 > 5);
assert((U1 + 1) * 2 <= 5);
assert(L2 * 2 > 5);
assert((L2 - 1) * 2 <= 5);
assert(UINT_MAX * 2 > 5);
if (n < UINT_MAX / 2 + 1) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void unsigned_multiplication_gt_3(uint32_t n) {
if (n * 3 > 4) {
uint32_t L1 = 2, U1 = 0x55555555,
L2 = 0x55555557, U2 = 0xaaaaaaaa,
L3 = 0xaaaaaaad;
assert(L1 * 3 > 4);
assert((L1 - 1) * 3 <= 4);
assert(U1 * 3 > 4);
assert((U1 + 1) * 3 <= 4);
assert(L2 * 3 > 4);
assert((L2 - 1) * 3 <= 4);
assert(U2 * 3 > 4);
assert((U2 + 1) * 3 <= 4);
assert(L3 * 3 > 4);
assert((L3 - 1) * 3 <= 4);
assert(INT_MAX * 3 > 4);
if (n < UINT_MAX / 3 + 1) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < 2 * (UINT_MAX / 3 + 1)) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void unsigned_division_gt_0(uint32_t n) {
if (n / 4 > 0) {
const uint32_t C = 4;
assert(C / 4 > 0);
assert((C - 1) / 4 <= 0);
clang_analyzer_eval(n >= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n < C); //expected-warning{{FALSE}}
}
}
void unsigned_division_gt_1(uint32_t n) {
if (n / 3 > 2) {
const uint32_t C = 9;
assert(C / 3 > 2);
assert((C - 1) / 3 <= 2);
clang_analyzer_eval(n >= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n < C); //expected-warning{{FALSE}}
}
}
void signed_multiplication_ge_0(int32_t n) {
if (n * 2 >= 3) {
int32_t L1 = 0x80000002, U1 = 0xbfffffff,
L2 = 2, U2 = 0x3fffffff;
assert(L1 * 2 >= 3);
assert((L1 - 1) * 2 < 3);
assert(U1 * 2 >= 3);
assert((U1 + 1) * 2 < 3);
assert(L2 * 2 >= 3);
assert((L2 - 1) * 2 < 3);
assert(U2 * 2 >= 3);
assert((U2 + 1) * 2 < 3);
if (n < 0) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void signed_multiplication_ge_1(int32_t n) {
if (n * 2 >= 4) {
int32_t L1 = 0x80000002, U1 = 0xbfffffff,
L2 = 2, U2 = 0x3fffffff;
assert(L1 * 2 >= 4);
assert((L1 - 1) * 2 < 4);
assert(U1 * 2 >= 4);
assert((U1 + 1) * 2 < 4);
assert(L2 * 2 >= 4);
assert((L2 - 1) * 2 < 4);
assert(U2 * 2 >= 4);
assert((U2 + 1) * 2 < 4);
if (n < 0) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void signed_multiplication_ge_2(int32_t n) {
if (n * 2 >= 5) {
int32_t L1 = 0x80000003, U1 = 0xbfffffff,
L2 = 3, U2 = 0x3fffffff;
assert(L1 * 2 >= 5);
assert((L1 - 1) * 2 < 5);
assert(U1 * 2 >= 5);
assert((U1 + 1) * 2 < 5);
assert(L2 * 2 >= 5);
assert((L2 - 1) * 2 < 5);
assert(U2 * 2 >= 5);
assert((U2 + 1) * 2 < 5);
if (n < 0) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
}
}
}
void signed_multiplication_ge_3(int32_t n) {
if (n * 3 >= 4) {
int32_t L1 = 0xaaaaaaac, U1 = 0xd5555555,
L2 = 2, U2 = 0x2aaaaaaa,
L3 = 0x55555557;
assert(L1 * 3 >= 4);
assert((L1 - 1) * 3 < 4);
assert(U1 * 3 >= 4);
assert((U1 + 1) * 3 < 4);
assert(L2 * 3 >= 4);
assert((L2 - 1) * 3 < 4);
assert(U2 * 3 >= 4);
assert((U2 + 1) * 3 < 4);
assert(L3 * 3 >= 4);
assert((L3 - 1) * 3 < 4);
assert(INT_MAX * 3 >= 4);
if (n < 0) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < INT_MAX / 2) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == INT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void signed_multiplication_ge_4(int32_t n) {
if (n * 6 >= -2) {
int32_t U1 = 0x95555555,
L2 = 0xaaaaaaab, U2 = 0xbfffffff,
L3 = 0xd5555555, U3 = 0xeaaaaaaa,
L4 = 0, U4 = 0x15555555,
L5 = 0x2aaaaaab, U5 = 0x3fffffff,
L6 = 0x55555555, U6 = 0x6aaaaaaa;
assert(INT_MIN * 6 >= -2);
assert(U1 * 6 >= -2);
assert((U1 + 1) * 6 < -2);
assert(L2 * 6 >= -2);
assert((L2 - 1) * 6 < -2);
assert(U2 * 6 >= -2);
assert((U2 + 1) * 6 < -2);
assert(L3 * 6 >= -2);
assert((L3 - 1) * 6 < -2);
assert(U3 * 6 >= -2);
assert((U3 + 1) * 6 < -2);
assert(L4 * 6 >= -2);
assert((L4 - 1) * 6 < -2);
assert(U4 * 6 >= -2);
assert((U4 + 1) * 6 < -2);
assert(L5 * 6 >= -2);
assert((L5 - 1) * 6 < -2);
assert(U5 * 6 >= -2);
assert((U5 + 1) * 6 < -2);
assert(L6 * 6 >= -2);
assert((L6 - 1) * 6 < -2);
assert(U6 * 6 >= -2);
assert((U6 + 1) * 6 < -2);
if (n < (int32_t) 0xa0000000) {
clang_analyzer_eval(n == INT_MIN); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0xcaaaaaaa) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0xf5555555) {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U3); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U3); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x20000000) {
clang_analyzer_eval(n < L4); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L4); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U4); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U4); //expected-warning{{FALSE}}
} else if (n < (int32_t) 0x4aaaaaaa) {
clang_analyzer_eval(n < L5); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L5); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U5); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U5); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L6); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L6); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U6); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U6); //expected-warning{{FALSE}}
}
}
}
void signed_division_ge_0(int32_t n) {
if (n / 4 >= 0) {
const int32_t C = -3;
assert(C / 4 >= 0);
assert((C - 1) / 4 < 0);
clang_analyzer_eval(n >= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n < C); //expected-warning{{FALSE}}
}
}
void signed_division_ge_1(int32_t n) {
if (n / 3 >= 2) {
const int32_t C = 6;
assert(C / 3 >= 2);
assert((C - 1) / 3 < 2);
clang_analyzer_eval(n >= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n < C); //expected-warning{{FALSE}}
}
}
void signed_division_ge_2(int32_t n) {
if (n / 5 >= -7) {
const int32_t C = -39;
assert(C / 5 >= -7);
assert((C - 1) / 5 < -7);
clang_analyzer_eval(n >= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n < C); //expected-warning{{FALSE}}
}
}
void unsigned_multiplication_ge_0(uint32_t n) {
if (n * 2 >= 3) {
uint32_t L1 = 2, U1 = 0x7fffffff,
L2 = 0x80000002;
assert(L1 * 2 >= 3);
assert((L1 - 1) * 2 < 3);
assert(U1 * 2 >= 3);
assert((U1 + 1) * 2 < 3);
assert(L2 * 2 >= 3);
assert((L2 - 1) * 2 < 3);
assert(UINT_MAX * 2 >= 3);
if (n < UINT_MAX / 2 + 1) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void unsigned_multiplication_ge_1(uint32_t n) {
if (n * 2 >= 4) {
uint32_t L1 = 2, U1 = 0x7fffffff,
L2 = 0x80000002;
assert(L1 * 2 >= 4);
assert((L1 - 1) * 2 < 4);
assert(U1 * 2 >= 4);
assert((U1 + 1) * 2 < 4);
assert(L2 * 2 >= 4);
assert((L2 - 1) * 2 < 4);
assert(UINT_MAX * 2 >= 4);
if (n < UINT_MAX / 2 + 1) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void unsigned_multiplication_ge_2(uint32_t n) {
if (n * 2 >= 5) {
uint32_t L1 = 3, U1 = 0x7fffffff,
L2 = 0x80000003;
assert(L1 * 2 >= 5);
assert((L1 - 1) * 2 < 5);
assert(U1 * 2 >= 5);
assert((U1 + 1) * 2 < 5);
assert(L2 * 2 >= 5);
assert((L2 - 1) * 2 < 5);
assert(UINT_MAX * 2 >= 5);
if (n < UINT_MAX / 2 + 1) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void unsigned_multiplication_ge_3(uint32_t n) {
if (n * 3 >= 4) {
uint32_t L1 = 2, U1 = 0x55555555,
L2 = 0x55555557, U2 = 0xaaaaaaaa,
L3 = 0xaaaaaaac;
assert(L1 * 3 >= 4);
assert((L1 - 1) * 3 < 4);
assert(U1 * 3 >= 4);
assert((U1 + 1) * 3 < 4);
assert(L2 * 3 >= 4);
assert((L2 - 1) * 3 < 4);
assert(U2 * 3 >= 4);
assert((U2 + 1) * 3 < 4);
assert(L3 * 3 >= 4);
assert((L3 - 1) * 3 < 4);
assert(INT_MAX * 3 >= 4);
if (n < UINT_MAX / 3 + 1) {
clang_analyzer_eval(n < L1); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L1); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U1); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U1); //expected-warning{{FALSE}}
} else if (n < 2 * (UINT_MAX / 3 + 1)) {
clang_analyzer_eval(n < L2); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L2); //expected-warning{{TRUE}}
clang_analyzer_eval(n <= U2); //expected-warning{{TRUE}}
clang_analyzer_eval(n > U2); //expected-warning{{FALSE}}
} else {
clang_analyzer_eval(n < L3); //expected-warning{{FALSE}}
clang_analyzer_eval(n >= L3); //expected-warning{{TRUE}}
clang_analyzer_eval(n == UINT_MAX); //expected-warning{{FALSE}}
//expected-warning@-1{{TRUE}}
}
}
}
void unsigned_division_ge_0(uint32_t n) {
if (n / 3 >= 2) {
const uint32_t C = 6;
assert(C / 3 >= 2);
assert((C - 1) / 3 < 2);
clang_analyzer_eval(n >= C); //expected-warning{{TRUE}}
clang_analyzer_eval(n < C); //expected-warning{{FALSE}}
}
}
void additive(int32_t n) { void additive(int32_t n) {
if (n * 2 + 1 == 4) { if (n * 2 + 1 == 4) {
clang_analyzer_warnIfReached(); // no-warning clang_analyzer_warnIfReached(); // no-warning
} else if (n * 4 - 1 == 15) { } else if (n * 4 - 1 == 15) {
const int32_t C1 = 0x80000004, C2 = 0xc0000004, C3 = 4, C4 = 0x40000004; const int32_t C1 = 0x80000004, C2 = 0xc0000004, C3 = 4, C4 = 0x40000004;
assert(C1 * 4 - 1 == 15); assert(C1 * 4 - 1 == 15);
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines