rob.lougher created this revision.
rob.lougher added a reviewer: gbiv.
rob.lougher added a subscriber: cfe-commits.
The -Wdouble-promotion warning was added to clang in r251588 (fixing PR15109).
The added test, however, only covered a subset of the cases where implicit
conversion can occur (assignment and function return). This patch extends the
coverage to include argument passing and a binary operator (multiply).
The patch also includes coverage for *= and the conditional (ternary) operator.
However, warnings are not produced for all the *= cases, and no warnings are
generated for the conditional operator. These have been marked as FIXME and I
will raise bugs for these separately.
Note, I've added George Burgess IV as reviewer as he committed the original
change and Carl Norum (the author) doesn't seem to be registered.
http://reviews.llvm.org/D16298
Files:
test/Sema/warn-double-promotion.c
Index: test/Sema/warn-double-promotion.c
===================================================================
--- test/Sema/warn-double-promotion.c
+++ test/Sema/warn-double-promotion.c
@@ -24,11 +24,51 @@
return d; //expected-warning{{implicit conversion increases floating-point
precision: 'double' to 'long double'}}
}
-void Convert(float f, double d, long double ld) {
+void Assignment(float f, double d, long double ld) {
d = f; //expected-warning{{implicit conversion increases floating-point
precision: 'float' to 'double'}}
ld = f; //expected-warning{{implicit conversion increases floating-point
precision: 'float' to 'long double'}}
ld = d; //expected-warning{{implicit conversion increases floating-point
precision: 'double' to 'long double'}}
f = d;
f = ld;
d = ld;
}
+
+extern void DoubleParameter(double);
+extern void LongDoubleParameter(long double);
+
+void ArgumentPassing(float f, double d, long double ld) {
+ DoubleParameter(f); // expected-warning{{implicit conversion increases
floating-point precision: 'float' to 'double'}}
+ LongDoubleParameter(f); // expected-warning{{implicit conversion increases
floating-point precision: 'float' to 'long double'}}
+ LongDoubleParameter(d); // expected-warning{{implicit conversion increases
floating-point precision: 'double' to 'long double'}}
+}
+
+void BinaryOperator(float f, double d, long double ld) {
+ f = f * d; // expected-warning{{implicit conversion increases floating-point
precision: 'float' to 'double'}}
+ f = d * f; // expected-warning{{implicit conversion increases floating-point
precision: 'float' to 'double'}}
+ f = f * ld; // expected-warning{{implicit conversion increases
floating-point precision: 'float' to 'long double'}}
+ f = ld * f; // expected-warning{{implicit conversion increases
floating-point precision: 'float' to 'long double'}}
+ d = d * ld; // expected-warning{{implicit conversion increases
floating-point precision: 'double' to 'long double'}}
+ d = ld * d; // expected-warning{{implicit conversion increases
floating-point precision: 'double' to 'long double'}}
+}
+
+void MultiplicationAssignment(float f, double d, long double ld) {
+ d *= f; // expected-warning{{implicit conversion increases floating-point
precision: 'float' to 'double'}}
+ ld *= f; // expected-warning{{implicit conversion increases floating-point
precision: 'float' to 'long double'}}
+ ld *= d; // expected-warning{{implicit conversion increases floating-point
precision: 'double' to 'long double'}}
+
+ // FIXME: These cases should produce warnings as above.
+ f *= d;
+ f *= ld;
+ d *= ld;
+}
+
+// FIXME: As with a binary operator, the operands to the conditional operator
are
+// converted to a common type and should produce a warning.
+void ConditionalOperator(float f, double d, long double ld, int i) {
+ f = i ? f : d;
+ f = i ? d : f;
+ f = i ? f : ld;
+ f = i ? ld : f;
+ d = i ? d : ld;
+ d = i ? ld : d;
+}
Index: test/Sema/warn-double-promotion.c
===================================================================
--- test/Sema/warn-double-promotion.c
+++ test/Sema/warn-double-promotion.c
@@ -24,11 +24,51 @@
return d; //expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}}
}
-void Convert(float f, double d, long double ld) {
+void Assignment(float f, double d, long double ld) {
d = f; //expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}}
ld = f; //expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}}
ld = d; //expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}}
f = d;
f = ld;
d = ld;
}
+
+extern void DoubleParameter(double);
+extern void LongDoubleParameter(long double);
+
+void ArgumentPassing(float f, double d, long double ld) {
+ DoubleParameter(f); // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}}
+ LongDoubleParameter(f); // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}}
+ LongDoubleParameter(d); // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}}
+}
+
+void BinaryOperator(float f, double d, long double ld) {
+ f = f * d; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}}
+ f = d * f; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}}
+ f = f * ld; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}}
+ f = ld * f; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}}
+ d = d * ld; // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}}
+ d = ld * d; // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}}
+}
+
+void MultiplicationAssignment(float f, double d, long double ld) {
+ d *= f; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}}
+ ld *= f; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}}
+ ld *= d; // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}}
+
+ // FIXME: These cases should produce warnings as above.
+ f *= d;
+ f *= ld;
+ d *= ld;
+}
+
+// FIXME: As with a binary operator, the operands to the conditional operator are
+// converted to a common type and should produce a warning.
+void ConditionalOperator(float f, double d, long double ld, int i) {
+ f = i ? f : d;
+ f = i ? d : f;
+ f = i ? f : ld;
+ f = i ? ld : f;
+ d = i ? d : ld;
+ d = i ? ld : d;
+}
_______________________________________________
cfe-commits mailing list
[email protected]
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
