[cfe-commits] r118647 - in /cfe/trunk: include/clang/Basic/DiagnosticSemaKinds.td lib/Sema/SemaChecking.cpp test/Sema/constant-conversion.c

[John McCall]

Author: rjmccall
Date: Tue Nov  9 17:24:47 2010
New Revision: 118647

URL: http://llvm.org/viewvc/llvm-project?rev=118647&view=rev
Log:
Add a warning for implicit truncation of constant values due to
bitfield assignment.

Implements rdar://problem/7809123


Modified:
    cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
    cfe/trunk/lib/Sema/SemaChecking.cpp
    cfe/trunk/test/Sema/constant-conversion.c

Modified: cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td?rev=118647&r1=118646&r2=118647&view=diff
==============================================================================
--- cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td (original)
+++ cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td Tue Nov  9 17:24:47 2010
@@ -1044,6 +1044,9 @@
 def warn_impcast_integer_precision_constant : Warning<
   "implicit conversion from %2 to %3 changes value from %0 to %1">,
   InGroup<DiagGroup<"constant-conversion">>;
+def warn_impcast_bitfield_precision_constant : Warning<
+  "implicit truncation from %2 to bitfield changes value from %0 to %1">,
+  InGroup<DiagGroup<"constant-conversion">>;
 
 def warn_cast_align : Warning<
   "cast from %0 to %1 increases required alignment from %2 to %3">,

Modified: cfe/trunk/lib/Sema/SemaChecking.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaChecking.cpp?rev=118647&r1=118646&r2=118647&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaChecking.cpp (original)
+++ cfe/trunk/lib/Sema/SemaChecking.cpp Tue Nov  9 17:24:47 2010
@@ -2587,6 +2587,52 @@
     << lex->getSourceRange() << rex->getSourceRange();
 }
 
+/// Analyze the given simple or compound assignment for warning-worthy
+/// operations.
+void AnalyzeAssignment(Sema &S, BinaryOperator *E) {
+  // Just recurse on the LHS.
+  AnalyzeImplicitConversions(S, E->getLHS(), E->getOperatorLoc());
+
+  // We want to recurse on the RHS as normal unless we're assigning to
+  // a bitfield.
+  if (FieldDecl *Bitfield = E->getLHS()->getBitField()) {
+    assert(Bitfield->isBitField());
+
+    Expr *RHS = E->getRHS()->IgnoreParenImpCasts();
+
+    llvm::APSInt Width(32);
+    Expr::EvalResult RHSValue;
+    if (!Bitfield->isInvalidDecl() &&
+        Bitfield->getBitWidth()->isIntegerConstantExpr(Width, S.Context) &&
+        RHS->Evaluate(RHSValue, S.Context) && RHSValue.Val.isInt()) {
+      const llvm::APSInt &Value = RHSValue.Val.getInt();
+      unsigned OriginalWidth = Value.getBitWidth();
+      unsigned FieldWidth = Width.getZExtValue();
+
+      if (OriginalWidth > FieldWidth) {
+        llvm::APSInt TruncatedValue = Value;
+        TruncatedValue.trunc(FieldWidth);
+        TruncatedValue.extend(OriginalWidth);
+
+        if (Value != TruncatedValue) {
+          std::string PrettyValue = Value.toString(10);
+          std::string PrettyTrunc = TruncatedValue.toString(10);
+
+          S.Diag(E->getOperatorLoc(),
+                 diag::warn_impcast_bitfield_precision_constant)
+            << PrettyValue << PrettyTrunc << RHS->getType()
+            << E->getRHS()->getSourceRange();
+
+          // Recurse, ignoring any implicit conversions on the RHS.
+          return AnalyzeImplicitConversions(S, RHS, E->getOperatorLoc());
+        }
+      }
+    }
+  }
+
+  AnalyzeImplicitConversions(S, E->getRHS(), E->getOperatorLoc());
+}
+
 /// Diagnose an implicit cast;  purely a helper for CheckImplicitConversion.
 void DiagnoseImpCast(Sema &S, Expr *E, QualType T, SourceLocation CContext,
                      unsigned diag) {
@@ -2810,9 +2856,15 @@
     return AnalyzeImplicitConversions(S, E, CC);
   }
 
-  // Do a somewhat different check with comparison operators.
-  if (isa<BinaryOperator>(E) && cast<BinaryOperator>(E)->isComparisonOp())
-    return AnalyzeComparison(S, cast<BinaryOperator>(E));
+  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
+    // Do a somewhat different check with comparison operators.
+    if (BO->isComparisonOp())
+      return AnalyzeComparison(S, BO);
+
+    // And with assignments and compound assignments.
+    if (BO->isAssignmentOp())
+      return AnalyzeAssignment(S, BO);
+  }
 
   // These break the otherwise-useful invariant below.  Fortunately,
   // we don't really need to recurse into them, because any internal

Modified: cfe/trunk/test/Sema/constant-conversion.c
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Sema/constant-conversion.c?rev=118647&r1=118646&r2=118647&view=diff
==============================================================================
--- cfe/trunk/test/Sema/constant-conversion.c (original)
+++ cfe/trunk/test/Sema/constant-conversion.c Tue Nov  9 17:24:47 2010
@@ -7,3 +7,9 @@
 void test_6792488(void) {
   int x = 0x3ff0000000000000U; // expected-warning {{implicit conversion from 'unsigned long' to 'int' changes value from 4607182418800017408 to 0}}
 }
+
+void test_7809123(void) {
+  struct { int i5 : 5; } a;
+
+  a.i5 = 36; // expected-warning {{implicit truncation for 'int' to bitfield changes value from 36 to 4}}
+}