mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-26 00:06:06 +00:00
ab982eace6
If we are equality comparing an FP literal with a value cast from a type where the literal can't be represented, that's known true or false and probably a programmer error. Fixes issue #54222. https://github.com/llvm/llvm-project/issues/54222 Note - I added the optimizer change with: 9397bdc67eb2 ...and as discussed in the post-commit comments, that transform might be too dangerous without this warning in place, so it was reverted to allow this change first. Differential Revision: https://reviews.llvm.org/D121306
64 lines
1.9 KiB
C
64 lines
1.9 KiB
C
// RUN: %clang_cc1 -fsyntax-only -Wfloat-equal -verify %s
|
|
|
|
int f1(float x, float y) {
|
|
return x == y; // expected-warning {{comparing floating point with ==}}
|
|
}
|
|
|
|
int f2(float x, float y) {
|
|
return x != y; // expected-warning {{comparing floating point with ==}}
|
|
}
|
|
|
|
int f3(float x) {
|
|
return x == x; // no-warning
|
|
}
|
|
|
|
// 0.0 can be represented exactly, so don't warn.
|
|
int f4(float x) {
|
|
return x == 0.0; // no-warning {{comparing}}
|
|
}
|
|
|
|
int f5(float x) {
|
|
return x == __builtin_inf(); // no-warning
|
|
}
|
|
|
|
// The literal is a double that can't be represented losslessly as a float.
|
|
int tautological_FP_compare(float x) {
|
|
return x == 3.14159; // expected-warning {{floating-point comparison is always false}}
|
|
}
|
|
|
|
int tautological_FP_compare_inverse(float x) {
|
|
return x != 3.14159; // expected-warning {{floating-point comparison is always true}}
|
|
}
|
|
|
|
// The literal is a double that can be represented losslessly as a long double,
|
|
// but this might not be the comparison what was intended.
|
|
int not_tautological_FP_compare(long double f) {
|
|
return f == 0.1; // expected-warning {{comparing floating point with ==}}
|
|
}
|
|
|
|
int tautological_FP_compare_commute(float f) {
|
|
return 0.3 == f; // expected-warning {{floating-point comparison is always false}}
|
|
}
|
|
|
|
int tautological_FP_compare_commute_inverse(float f) {
|
|
return 0.3 != f; // expected-warning {{floating-point comparison is always true}}
|
|
}
|
|
|
|
int tautological_FP_compare_explicit_upcast(float f) {
|
|
return 0.3 == (double) f; // expected-warning {{floating-point comparison is always false}}
|
|
}
|
|
|
|
int tautological_FP_compare_explicit_downcast(double d) {
|
|
return 0.3 == (float) d; // expected-warning {{floating-point comparison is always false}}
|
|
}
|
|
|
|
int tautological_FP_compare_ignore_parens(float f) {
|
|
return f == (0.3); // expected-warning {{floating-point comparison is always false}}
|
|
}
|
|
|
|
#define CST 0.3
|
|
|
|
int tautological_FP_compare_macro(float f) {
|
|
return f == CST; // expected-warning {{floating-point comparison is always false}}
|
|
}
|