in expression evaluator, treat non-literal types as discarded value expressions if EvalInfo says to continue evaluating them

[nlewycky]

Summary

Make the integer overflow evaluator continue into expressions with non-literal types, notably void.

In passing it fixes a crash attempting to codegen:

struct A { char x; };
struct B : virtual A {};
A &a = ((A&)*(B*)0);

which we nearly have a test for except that it casted to void and therefore was ignored instead of being evaluated. The existing test (test/SemaCXX/cstyle-cast.cpp) is sufficient to cover this case now that we don't stop at a void cast.

[rsmith]

Thanks. Could you also add something like:

struct A {};
struct B : virtual A {};
constexpr A &a = (A&)*(B*)0;

to test/SemaCXX/constant-expression-cxx11.cpp to ensure we produce a suitable diagnostic, please?

lib/AST/ExprConstant.cpp

 static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
                              const CXXRecordDecl *DerivedDecl,
                              const CXXBaseSpecifier *Base) {
   const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl();
 
   if (!Base->isVirtual())
     return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl);
 
+  if (!Obj.checkNullPointer(Info, E, CSK_Base))
+    return false;
+
   SubobjectDesignator &D = Obj.Designator;
   if (D.Invalid)
     return false;
 
   // Extract most-derived object and corresponding type.
   DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl();
   if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength))
     return false;

 }
 
 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
 /// lvalue-to-rvalue cast if it is an lvalue.
 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
   if (E->getType().isNull())
     return false;
 
-  if (!CheckLiteralType(Info, E))
+  if (!CheckLiteralType(Info, E)) {
+    if (Info.noteFailure())
+      EvaluateIgnoredValue(Info, E);
     return false;
+  }
 
   if (!::Evaluate(Result, Info, E))
     return false;
 
   if (E->isGLValue()) {
     LValue LV;
     LV.setFrom(Info.Ctx, Result);
     if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))

test/Sema/integer-overflow.c

 // expected-warning@+4 {{overflow in expression; result is 536870912 with type 'int'}}
 // 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@+2 {{overflow in expression; result is 536870912 with type 'int'}}
   uint64_t *b;
-  uint64_t b2 = b[4608 * 1024 * 1024] + 1;
+  (void)b[4608 * 1024 * 1024];
 
 // expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}
-  int j1 = i ? (4608 * 1024 * 1024) : (4608 * 1024 * 1024);
+  (void)(i ? (4608 * 1024 * 1024) : (4608 * 1024 * 1024));
 
 // expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
-  int j2 = -(4608 * 1024 * 1024);
+  (void)(-(4608 * 1024 * 1024));
 
 // expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
-  uint64_t j3 = b[4608 * 1024 * 1024];
+  (void)b[4608 * 1024 * 1024];
 
 // 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;