[Sema] Issue a warning for integer overflow in struct initializer

[ahatanak]

Summary

Issue a warning if an initializing integer expression overflows.

For example, clang should issue a warning when compiling the following code because 4 * 1024 * 1024 * 1024 doesn't fit into a 32-bit integer:

struct s {
unsigned x;
} s = {
.x = 4 * 1024 * 1024 * 1024
};

[ahatanak]

ping

[vsk]

Looks good to me.

Caveat: This isn't quite my area. This seems reasonable given what I've read in EvaluateForOverflow and EvaluateAsRValue. I think you should be fine to commit if no one objects soon.

[ahatanak]

OK, thank you for the review.

I'll commit this patch in a day or two unless someone comes up with a better solution.

cfe/trunk/lib/Sema/SemaChecking.cpp

void Sema::CheckBoolLikeConversion(Expr *E, SourceLocation CC) {
   ::CheckBoolLikeConversion(*this, E, CC);
 }
 
 /// Diagnose when expression is an integer constant expression and its evaluation
 /// results in integer overflow
 void Sema::CheckForIntOverflow (Expr *E) {
   if (isa<BinaryOperator>(E->IgnoreParenCasts()))
     E->IgnoreParenCasts()->EvaluateForOverflow(Context);
+  else if (auto InitList = dyn_cast<InitListExpr>(E))
+    for (Expr *E : InitList->inits())
+      if (isa<BinaryOperator>(E->IgnoreParenCasts()))
+        E->IgnoreParenCasts()->EvaluateForOverflow(Context);
 }
 
 namespace {
 /// \brief Visitor for expressions which looks for unsequenced operations on the
 /// same object.
 class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> {
   typedef EvaluatedExprVisitor<SequenceChecker> Base;
 

cfe/trunk/test/Sema/integer-overflow.c

 // expected-warning@+3 {{array index 536870912 is past the end of the array (which contains 10 elements)}}
 // expected-note@+1 {{array 'a' declared here}}
   uint64_t a[10];
   a[4608 * 1024 * 1024] = 1i;
 
 // expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}
   return ((4608 * 1024 * 1024) + ((uint64_t)(4608 * 1024 * 1024)));
 }
+
+struct s {
+  unsigned x;
+  unsigned y;
+} s = {
+  .y = 5,
+  .x = 4 * 1024 * 1024 * 1024  // expected-warning {{overflow in expression; result is 0 with type 'int'}}
+};