Fix -Winteger-overflow to diagnose regardless of the top-level syntactic form.

[rsmith]

Summary

Previously -Winteger-overflow did not do any checking of expressions
whose top-level syntactic form wasn't one of a small list of special
cases. This meant that the warning would appear and disappear depending
on enclosing syntax.

Additionally, if constant evaluation hit a case that it didn't
understand, it would often bail out without visiting subexpressions, so
we wouldn't see warnings on overflow in subexpressions depending on the
form of intervening expressions.

We now walk all evaluated subexpressions of a particular expression when
checking for overflow, and evaluate subtrees rooted on each operation
that might overflow. If such evaluation hits an unevaluatable
subexpression, we switch back to walking the AST looking for
subexpressions to evaluate.

The extra evaluation here also exposed an issue where casts between
complex and fixed-point types would create bogus AST nodes using
CK_IntegralCast, which would lead to the constant evaluator asserting.
That's fixed here too.

[vsapsai]

Looks good to me. Have a few clarification questions.

clang/lib/AST/ExprConstant.cpp

972–973

I'm not entirely sure but it can be useful to make it explicit in the comment the method doesn't deal with all the subexpressions recursively. Not convinced it is useful because don't have a good wording and you can get that information from the short method implementation. It is possible my suggestion is caused by checking the patch top-to-bottom without seeing how mightWarnOnUndefinedBehavior is used first, but that's not how developers would read the code later.

8398–8399

Just to confirm my understanding. There is no point in checking keepEvaluatingAfterFailure here because we are not short-circuiting anymore but can evaluate the expression in VisitExpr(UO). And we still check keepEvaluatingAfterFailure in SubexpressionVisitor::Run in EvaluateForDiagnostics.

clang/lib/Sema/SemaExpr.cpp

7125–7126

What is the purpose of these changes to return CK_Dependent? Tests are passing without them and it's not obvious to me why do you need to change CK_IntegralCast to CK_Dependent.

[rsmith]

clang/lib/AST/ExprConstant.cpp

972–973

Would renaming this to something like shouldEvaluateForUndefinedBehaviorChecks help? That still doesn't completely capture the non-recursive nature. I think improving the comment is a good idea regardless.

8398–8399

Yes, exactly.

clang/lib/Sema/SemaExpr.cpp

7125–7126

It shouldn't matter what we return, because the caller should always bail out and ignore our return value if Src is set to an invalid expression. But in principle, CK_IntegralCast is wrong, because this situation doesn't meet the constraints for an integral cast. We use "dependent" to mean not only "dependent on a C++ template parameter" but also "dependent on an error", so that seemed like the least wrong cast kind for this situation.

[vsapsai]

clang/lib/AST/ExprConstant.cpp

972–973

Don't have strong feelings about shouldEvaluateForUndefinedBehaviorChecks. Both shouldEvaluateForUndefinedBehaviorChecks and mightWarnOnUndefinedBehavior convey enough intention and actual implementation is fairly easy to understand. And information at the call site in ShouldEvaluate seems to be sufficient for intention and implementation purposes.

Also considered inlining mightWarnOnUndefinedBehavior but it doesn't look like a better alternative.

It's up to you if you want to tweak it further, I don't have good suggestions.

clang/lib/Sema/SemaExpr.cpp

7125–7126

Thanks for the explanation. "dependent on an error" is an important piece of information and now it makes more sense.

clang/include/clang/AST/EvaluatedExprVisitor.h

#define PTR(CLASS) typename Ptr<CLASS>::type
   void VisitUnaryExprOrTypeTraitExpr(PTR(UnaryExprOrTypeTraitExpr) E) { }
   void VisitExpressionTraitExpr(PTR(ExpressionTraitExpr) E) { }
   void VisitBlockExpr(PTR(BlockExpr) E) { }
   void VisitCXXUuidofExpr(PTR(CXXUuidofExpr) E) { }
   void VisitCXXNoexceptExpr(PTR(CXXNoexceptExpr) E) { }
 
   void VisitMemberExpr(PTR(MemberExpr) E) {
     // Only the base matters.
-    return this->Visit(E->getBase());
+    return static_cast<ImplClass*>(this)->Visit(E->getBase());
   }
 
   void VisitChooseExpr(PTR(ChooseExpr) E) {
     // Don't visit either child expression if the condition is dependent.
     if (E->getCond()->isValueDependent())
       return;
     // Only the selected subexpression matters; the other one is not evaluated.
-    return this->Visit(E->getChosenSubExpr());
+    return static_cast<ImplClass*>(this)->Visit(E->getChosenSubExpr());
   }
 
   void VisitGenericSelectionExpr(PTR(GenericSelectionExpr) E) {
     // The controlling expression of a generic selection is not evaluated.
 
     // Don't visit either child expression if the condition is type-dependent.
     if (E->isResultDependent())
       return;
     // Only the selected subexpression matters; the other subexpressions and the
     // controlling expression are not evaluated.
-    return this->Visit(E->getResultExpr());
+    return static_cast<ImplClass*>(this)->Visit(E->getResultExpr());
   }
 
   void VisitDesignatedInitExpr(PTR(DesignatedInitExpr) E) {
     // Only the actual initializer matters; the designators are all constant
     // expressions.
-    return this->Visit(E->getInit());
+    return static_cast<ImplClass*>(this)->Visit(E->getInit());
   }
 
   void VisitCXXTypeidExpr(PTR(CXXTypeidExpr) E) {
     if (E->isPotentiallyEvaluated())
-      return this->Visit(E->getExprOperand());
+      return static_cast<ImplClass*>(this)->Visit(E->getExprOperand());
   }
 
   void VisitCallExpr(PTR(CallExpr) CE) {
     if (!CE->isUnevaluatedBuiltinCall(Context))
       return static_cast<ImplClass*>(this)->VisitExpr(CE);
   }
 
   void VisitLambdaExpr(PTR(LambdaExpr) LE) {
     // Only visit the capture initializers, and not the body.
     for (LambdaExpr::const_capture_init_iterator I = LE->capture_init_begin(),
                                                  E = LE->capture_init_end();
          I != E; ++I)
       if (*I)
-        this->Visit(*I);
+        static_cast<ImplClass*>(this)->Visit(*I);
   }
 
   /// The basis case walks all of the children of the statement or
   /// expression, assuming they are all potentially evaluated.
   void VisitStmt(PTR(Stmt) S) {
     for (auto *SubStmt : S->children())
       if (SubStmt)
-        this->Visit(SubStmt);
+        static_cast<ImplClass*>(this)->Visit(SubStmt);
   }
 
 #undef PTR
 };
 
 /// EvaluatedExprVisitor - This class visits 'Expr *'s
 template <typename ImplClass>
 class EvaluatedExprVisitor

clang/include/clang/AST/Expr.h

public:
   llvm::APSInt EvaluateKnownConstInt(
       const ASTContext &Ctx,
       SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;
 
   llvm::APSInt EvaluateKnownConstIntCheckOverflow(
       const ASTContext &Ctx,
       SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;
 
-  void EvaluateForOverflow(const ASTContext &Ctx) const;
+  /// Evaluate this expression looking for and warning on undefined behavior.
+  /// This is valid even on value-dependent expressions.
+  void EvaluateForDiagnostics(const ASTContext &Ctx) const;
 
   /// EvaluateAsLValue - Evaluate an expression to see if we can fold it to an
   /// lvalue with link time known address, with no side-effects.
   bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx,
                         bool InConstantContext = false) const;
 
   /// EvaluateAsInitializer - Evaluate an expression as if it were the
   /// initializer of the given declaration. Returns true if the initializer

clang/include/clang/Sema/Sema.h

void CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
                           const FunctionDecl *FD = nullptr);
 
 public:
   void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS);
 
 private:
   void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation());
   void CheckBoolLikeConversion(Expr *E, SourceLocation CC);
-  void CheckForIntOverflow(Expr *E);
   void CheckUnsequencedOperations(const Expr *E);
 
   /// Perform semantic checks on a completed expression. This will either
   /// be a full-expression or a default argument expression.
   void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(),
                           bool IsConstexpr = false);
 
   void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field,

clang/lib/AST/ExprConstant.cpp

 #include "clang/AST/APValue.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/CurrentSourceLocExprScope.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/OSLog.h"
 #include "clang/AST/OptionalDiagnostic.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APFixedPoint.h"
public:
     } EvalMode;
 
     /// Are we checking whether the expression is a potential constant
     /// expression?
     bool checkingPotentialConstantExpression() const override  {
       return CheckingPotentialConstantExpression;
     }
 
-    /// Are we checking an expression for overflow?
-    // FIXME: We should check for any kind of undefined or suspicious behavior
-    // in such constructs, not just overflow.
+    /// Are we checking an expression for undefined?
+    ///
+    /// If any new cases are added that emit warnings on undefined behavior,
+    /// mightWarnOnUndefinedBehavior should be updated to match.
+    ///
+    /// FIXME: Add checks for more kinds of undefined or suspicious behavior.
     bool checkingForUndefinedBehavior() const override {
       return CheckingForUndefinedBehavior;
     }
 
+    // Determine if we might warn that the given expression exhibits undefined
+    // behavior.
+    bool mightWarnOnUndefinedBehavior(const Expr *E) {
+      if (!checkingForUndefinedBehavior())
+        return false;
+      if (auto *BO = dyn_cast<BinaryOperator>(E))
+        return BO->getType()->isIntegralOrEnumerationType() ||
+               BO->getType()->isFixedPointType();
+      return false;
+    }
+
     EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
         : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
           CallStackDepth(0), NextCallIndex(1),
           StepsLeft(C.getLangOpts().ConstexprStepLimit),
           EnableNewConstInterp(C.getLangOpts().EnableNewConstInterp),
           BottomFrame(*this, SourceLocation(), nullptr, nullptr, CallRef()),
           EvaluatingDecl((const ValueDecl *)nullptr),
           EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
Optional<APValue> MaybeDestValue =
       BufferToAPValueConverter::convert(Info, *Buffer, BCE);
   if (!MaybeDestValue)
     return false;
 
   DestValue = std::move(*MaybeDestValue);
   return true;
 }
 
+/// Evaluate the potentially-evaluated subexpressions of the given expression
+/// looking for undefined behavior, and discard the evaluation results.
+static void EvaluateForDiagnostics(EvalInfo &Info, const Expr *E,
+                                   bool SubexpressionsOnly) {
+  assert(Info.checkingForUndefinedBehavior() &&
+         "should only be called when checking for UB");
+
+  // Let the EvalInfo know that we're potentially skipping side-effects.
+  if (!Info.noteFailure())
+    return;
+
+  struct SubexpressionVisitor
+      : ConstEvaluatedExprVisitor<SubexpressionVisitor> {
+    EvalInfo &Info;
+    // A list of interesting expressions that we are going to evaluate.
+    SmallVector<const Expr*, 8> WorkList;
+
+    SubexpressionVisitor(EvalInfo &Info)
+        : ConstEvaluatedExprVisitor(Info.Ctx), Info(Info) {}
+
+    bool ShouldEvaluate(const Expr *E) {
+      // Evaluate an expression if it might either produce a warning or result
+      // in control flow.
+      // FIXME: We should use DiagRuntimeBehavior for our UB warnings, but it's
+      // not reachable from here.
+      return Info.mightWarnOnUndefinedBehavior(E) ||
+             isa<AbstractConditionalOperator>(E);
+    }
+
+    void Enqueue(const Expr *E, bool SubexpressionsOnly) {
+      if (SubexpressionsOnly)
+        EnqueueSubexpressions(E);
+      else
+        WorkList.push_back(E);
+    }
+
+    void EnqueueSubexpressions(const Expr *E) {
+      ConstEvaluatedExprVisitor::Visit(E);
+    }
+
+    void Run() {
+      while (!WorkList.empty() && Info.keepEvaluatingAfterFailure()) {
+        const Expr *E = WorkList.pop_back_val();
+        if (!E->isValueDependent() && ShouldEvaluate(E))
+          EvaluateIgnoredValue(Info, E);
+        else
+          EnqueueSubexpressions(E);
+      }
+    }
+
+    void Visit(const Stmt *Child) {
+      // Don't recurse to sub-statements; those will be checked separately.
+      if (auto *SubExpr = dyn_cast<Expr>(Child))
+        WorkList.push_back(SubExpr);
+    }
+  } Visitor(Info);
+
+  Visitor.Enqueue(E, SubexpressionsOnly);
+  Visitor.Run();
+}
+
 template <class Derived>
 class ExprEvaluatorBase
   : public ConstStmtVisitor<Derived, bool> {
 private:
   Derived &getDerived() { return static_cast<Derived&>(*this); }
   bool DerivedSuccess(const APValue &V, const Expr *E) {
     return getDerived().Success(V, E);
   }
public:
   bool Error(const Expr *E) {
     return Error(E, diag::note_invalid_subexpr_in_const_expr);
   }
 
   bool VisitStmt(const Stmt *) {
     llvm_unreachable("Expression evaluator should not be called on stmts");
   }
   bool VisitExpr(const Expr *E) {
-    return Error(E);
+    Error(E);
+
+    // We can't produce a value for this expression. If we're checking for UB,
+    // we should still recurse into subexpressions to check them.
+    if (Info.checkingForUndefinedBehavior())
+      ::EvaluateForDiagnostics(Info, E, /*SubexpressionsOnly=*/true);
+
+    return false;
   }
 
   bool VisitConstantExpr(const ConstantExpr *E) {
     if (E->hasAPValueResult())
       return DerivedSuccess(E->getAPValueResult(), E);
 
     return StmtVisitorTy::Visit(E->getSubExpr());
   }
public:
   }
   bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E) {
     return static_cast<Derived*>(this)->VisitCastExpr(E);
   }
 
   bool VisitBinaryOperator(const BinaryOperator *E) {
     switch (E->getOpcode()) {
     default:
-      return Error(E);
+      return VisitExpr(E);
 
     case BO_Comma:
       VisitIgnoredValue(E->getLHS());
       return StmtVisitorTy::Visit(E->getRHS());
 
     case BO_PtrMemD:
     case BO_PtrMemI: {
       LValue Obj;
if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) {
           if (!HandleOperatorNewCall(Info, E, Ptr))
             return false;
           Ptr.moveInto(Result);
           return CallScope.destroy();
         } else {
           return HandleOperatorDeleteCall(Info, E) && CallScope.destroy();
         }
       }
-    } else
-      return Error(E);
+    } else {
+      return VisitExpr(E);
+    }
 
     // Evaluate the arguments now if we've not already done so.
     if (!Call) {
       Call = Info.CurrentCall->createCall(FD);
       if (!EvaluateArgs(Args, Call, Info, FD))
         return false;
     }
 
public:
   bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
     return StmtVisitorTy::Visit(E->getInitializer());
   }
   bool VisitInitListExpr(const InitListExpr *E) {
     if (E->getNumInits() == 0)
       return DerivedZeroInitialization(E);
     if (E->getNumInits() == 1)
       return StmtVisitorTy::Visit(E->getInit(0));
-    return Error(E);
+    return VisitExpr(E);
   }
   bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
     return DerivedZeroInitialization(E);
   }
   bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
     return DerivedZeroInitialization(E);
   }
   bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
bool VisitCastExpr(const CastExpr *E) {
     case CK_AddressSpaceConversion: {
       APValue Value;
       if (!Evaluate(Value, Info, E->getSubExpr()))
         return false;
       return DerivedSuccess(Value, E);
     }
     }
 
-    return Error(E);
+    return VisitExpr(E);
   }
 
   bool VisitUnaryPostInc(const UnaryOperator *UO) {
     return VisitUnaryPostIncDec(UO);
   }
   bool VisitUnaryPostDec(const UnaryOperator *UO) {
     return VisitUnaryPostIncDec(UO);
   }
   bool VisitUnaryPostIncDec(const UnaryOperator *UO) {
-    if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
-      return Error(UO);
+    if (!Info.getLangOpts().CPlusPlus14)
+      return VisitExpr(UO);
 
     LValue LVal;
     if (!EvaluateLValue(UO->getSubExpr(), LVal, Info))
       return false;
     APValue RVal;
     if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(),
                       UO->isIncrementOp(), &RVal))
       return false;
bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
 
   // Handle non-static data members.
   return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
 }
 
 bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
   // FIXME: Deal with vectors as array subscript bases.
   if (E->getBase()->getType()->isVectorType())
-    return Error(E);
+    return ExprEvaluatorBaseTy::VisitArraySubscriptExpr(E);
 
   APSInt Index;
   bool Success = true;
 
   // C++17's rules require us to evaluate the LHS first, regardless of which
   // side is the base.
   for (const Expr *SubExpr : {E->getLHS(), E->getRHS()}) {
     if (SubExpr == E->getBase() ? !evaluatePointer(SubExpr, Result)
assert(E->getSubExpr()->getType()->isAnyComplexType() &&
          "lvalue __imag__ on scalar?");
   if (!Visit(E->getSubExpr()))
     return false;
   HandleLValueComplexElement(Info, E, Result, E->getType(), true);
   return true;
 }
 
 bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) {
-  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
-    return Error(UO);
+  if (!Info.getLangOpts().CPlusPlus14)
+    return VisitExpr(UO);
 
   if (!this->Visit(UO->getSubExpr()))
     return false;
 
   return handleIncDec(
       this->Info, UO, Result, UO->getSubExpr()->getType(),
       UO->isIncrementOp(), nullptr);
 }
public:
   bool VisitBinaryOperator(const BinaryOperator *E);
   bool VisitCastExpr(const CastExpr* E);
   bool VisitUnaryAddrOf(const UnaryOperator *E);
   bool VisitObjCStringLiteral(const ObjCStringLiteral *E)
       { return Success(E); }
   bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
     if (E->isExpressibleAsConstantInitializer())
       return Success(E);
-    if (Info.noteFailure())
-      EvaluateIgnoredValue(Info, E->getSubExpr());
-    return Error(E);
+    return ExprEvaluatorBaseTy::VisitObjCBoxedExpr(E);
   }
   bool VisitAddrLabelExpr(const AddrLabelExpr *E)
       { return Success(E); }
   bool VisitCallExpr(const CallExpr *E);
   bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
   bool VisitBlockExpr(const BlockExpr *E) {
     if (!E->getBlockDecl()->hasCaptures())
       return Success(E);
if (SETy->isIntegerType()) {
         return false;
       Val = APValue(std::move(IntResult));
     } else if (SETy->isRealFloatingType()) {
       APFloat FloatResult(0.0);
       if (!EvaluateFloat(SE, FloatResult, Info))
         return false;
       Val = APValue(std::move(FloatResult));
     } else {
-      return Error(E);
+      return ExprEvaluatorBaseTy::VisitCastExpr(E);
     }
 
     // Splat and create vector APValue.
     SmallVector<APValue, 4> Elts(NElts, Val);
     return Success(Elts, E);
   }
   case CK_BitCast: {
     // Evaluate the operand into an APInt we can extract from.
static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {
   return true;
 }
 
 bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E,
                                            QualType AllocType) {
   const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(
       AllocType.isNull() ? E->getType() : AllocType);
   if (!CAT)
-    return Error(E);
+    return ExprEvaluatorBaseTy::VisitInitListExpr(E);
 
   // C++11 [dcl.init.string]p1: A char array [...] can be initialized by [...]
   // an appropriately-typed string literal enclosed in braces.
   if (E->isStringLiteralInit()) {
     auto *SL = dyn_cast<StringLiteral>(E->getInit(0)->IgnoreParens());
     // FIXME: Support ObjCEncodeExpr here once we support it in
     // ArrayExprEvaluator generally.
     if (!SL)
for (unsigned I = 0; I != N; ++I)
           !HandleLValueArrayAdjustment(Info, E, ArrayElt,
                                        CAT->getElementType(), 1))
         return false;
 
     return true;
   }
 
   if (!Type->isRecordType())
-    return Error(E);
+    return ExprEvaluatorBaseTy::VisitCXXConstructExpr(E);
 
   return RecordExprEvaluator(Info, Subobject, *Value)
              .VisitCXXConstructExpr(E, Type);
 }
 
 //===----------------------------------------------------------------------===//
 // Integer Evaluation
 //
public:
 
   /// True if \param E is a binary operator that we are going to handle
   /// data recursively.
   /// We handle binary operators that are comma, logical, or that have operands
   /// with integral or enumeration type.
   static bool shouldEnqueue(const BinaryOperator *E) {
     return E->getOpcode() == BO_Comma || E->isLogicalOp() ||
            (E->isRValue() && E->getType()->isIntegralOrEnumerationType() &&
+            E->getLHS()->isRValue() &&
             E->getLHS()->getType()->isIntegralOrEnumerationType() &&
+            E->getRHS()->isRValue() &&
             E->getRHS()->getType()->isIntegralOrEnumerationType());
   }
 
   bool Traverse(const BinaryOperator *E) {
     enqueue(E);
     EvalResult PrevResult;
     while (!Queue.empty())
       process(PrevResult);
 
-    if (PrevResult.Failed) return false;
+    if (PrevResult.Failed)
+      return false;
 
     FinalResult.swap(PrevResult.Val);
     return true;
   }
 
 private:
   bool Success(uint64_t Value, const Expr *E, APValue &Result) {
     return IntEval.Success(Value, E, Result);
return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result,
                                    ConstantExprKind::Normal);
   };
   return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
     return ExprEvaluatorBaseTy::VisitBinCmp(E);
   });
 }
 
 bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
-  // We don't support assignment in C. C++ assignments don't get here because
-  // assignment is an lvalue in C++.
-  if (E->isAssignmentOp()) {
-    Error(E);
-    if (!Info.noteFailure())
-      return false;
-  }
-
   if (DataRecursiveIntBinOpEvaluator::shouldEnqueue(E))
     return DataRecursiveIntBinOpEvaluator(*this, Result).Traverse(E);
 
-  assert((!E->getLHS()->getType()->isIntegralOrEnumerationType() ||
-          !E->getRHS()->getType()->isIntegralOrEnumerationType()) &&
-         "DataRecursiveIntBinOpEvaluator should have handled integral types");
-
   if (E->isComparisonOp()) {
     // Evaluate builtin binary comparisons by evaluating them as three-way
     // comparisons and then translating the result.
     auto OnSuccess = [&](CmpResult CR, const BinaryOperator *E) {
       assert((CR != CmpResult::Unequal || E->isEqualityOp()) &&
              "should only produce Unequal for equality comparisons");
       bool IsEqual   = CR == CmpResult::Equal,
            IsLess    = CR == CmpResult::Less,
bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *OOE) {
   return Success(Result, OOE);
 }
 
 bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
   switch (E->getOpcode()) {
   default:
     // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
     // See C99 6.6p3.
-    return Error(E);
+    return ExprEvaluatorBaseTy::VisitUnaryOperator(E);
   case UO_Extension:
     // FIXME: Should extension allow i-c-e extension expressions in its scope?
     // If so, we could clear the diagnostic ID.
     return Visit(E->getSubExpr());
   case UO_Plus:
     // The result is just the value.
     return Visit(E->getSubExpr());
   case UO_Minus: {
bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_BitCast:
   case CK_Dependent:
   case CK_LValueBitCast:
   case CK_ARCProduceObject:
   case CK_ARCConsumeObject:
   case CK_ARCReclaimReturnedObject:
   case CK_ARCExtendBlockObject:
   case CK_CopyAndAutoreleaseBlockObject:
-    return Error(E);
+    // Allow the base class to reject.
+    return ExprEvaluatorBaseTy::VisitCastExpr(E);
 
   case CK_UserDefinedConversion:
   case CK_LValueToRValue:
   case CK_AtomicToNonAtomic:
   case CK_NoOp:
   case CK_LValueToRValueBitCast:
     return ExprEvaluatorBaseTy::VisitCastExpr(E);
 

 bool IntExprEvaluator::VisitRequiresExpr(const RequiresExpr *E) {
   return Success(E->isSatisfied(), E);
 }
 
 bool FixedPointExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
   switch (E->getOpcode()) {
     default:
       // Invalid unary operators
-      return Error(E);
+      return ExprEvaluatorBaseTy::VisitUnaryOperator(E);
     case UO_Plus:
       // The result is just the value.
       return Visit(E->getSubExpr());
     case UO_Minus: {
       if (!Visit(E->getSubExpr())) return false;
       if (!Result.isFixedPoint())
         return Error(E);
       bool Overflowed;
bool FixedPointExprEvaluator::VisitCastExpr(const CastExpr *E) {
 
   switch (E->getCastKind()) {
   case CK_FixedPointCast: {
     APFixedPoint Src(Info.Ctx.getFixedPointSemantics(SubExpr->getType()));
     if (!EvaluateFixedPoint(SubExpr, Src, Info))
       return false;
     bool Overflowed;
     APFixedPoint Result = Src.convert(DestFXSema, &Overflowed);
-    if (Overflowed) {
-      if (Info.checkingForUndefinedBehavior())
-        Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
-                                         diag::warn_fixedpoint_constant_overflow)
-          << Result.toString() << E->getType();
-      if (!HandleOverflow(Info, E, Result, E->getType()))
-        return false;
-    }
+    if (Overflowed && !HandleOverflow(Info, E, Result, E->getType()))
     return Success(Result, E);
   }
   case CK_IntegralToFixedPoint: {
     APSInt Src;
     if (!EvaluateInteger(SubExpr, Src, Info))
       return false;
 
     bool Overflowed;
     APFixedPoint IntResult = APFixedPoint::getFromIntValue(
         Src, Info.Ctx.getFixedPointSemantics(DestType), &Overflowed);
 
-    if (Overflowed) {
-      if (Info.checkingForUndefinedBehavior())
-        Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
-                                         diag::warn_fixedpoint_constant_overflow)
-          << IntResult.toString() << E->getType();
-      if (!HandleOverflow(Info, E, IntResult, E->getType()))
-        return false;
-    }
+    if (Overflowed && !HandleOverflow(Info, E, IntResult, E->getType()))
 
     return Success(IntResult, E);
   }
   case CK_FloatingToFixedPoint: {
     APFloat Src(0.0);
     if (!EvaluateFloat(SubExpr, Src, Info))
       return false;
 
     bool Overflowed;
     APFixedPoint Result = APFixedPoint::getFromFloatValue(
         Src, Info.Ctx.getFixedPointSemantics(DestType), &Overflowed);
 
-    if (Overflowed) {
-      if (Info.checkingForUndefinedBehavior())
-        Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
-                                         diag::warn_fixedpoint_constant_overflow)
-          << Result.toString() << E->getType();
-      if (!HandleOverflow(Info, E, Result, E->getType()))
-        return false;
-    }
+    if (Overflowed && !HandleOverflow(Info, E, Result, E->getType()))
 
     return Success(Result, E);
   }
-  case CK_NoOp:
-  case CK_LValueToRValue:
-    return ExprEvaluatorBaseTy::VisitCastExpr(E);
   default:
-    return Error(E);
+    return ExprEvaluatorBaseTy::VisitCastExpr(E);
   }
 }
 
 bool FixedPointExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
   if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
     return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
 
   const Expr *LHS = E->getLHS();
bool FixedPointExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
   }
   default:
     return false;
   }
   if (OpOverflow || ConversionOverflow) {
     if (Info.checkingForUndefinedBehavior())
       Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
                                        diag::warn_fixedpoint_constant_overflow)
           << Result.toString() << E->getType();
     if (!HandleOverflow(Info, E, Result, E->getType()))
       return false;
   }
   return Success(Result, E);
 }
 
 //===----------------------------------------------------------------------===//
 // Float Evaluation
bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
   VisitIgnoredValue(E->getSubExpr());
   const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType());
   Result = llvm::APFloat::getZero(Sem);
   return true;
 }
 
 bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
   switch (E->getOpcode()) {
-  default: return Error(E);
+  default:
+    return ExprEvaluatorBaseTy::VisitUnaryOperator(E);
   case UO_Plus:
     return EvaluateFloat(E->getSubExpr(), Result, Info);
   case UO_Minus:
     // In C standard, WG14 N2478 F.3 p4
     // "the unary - raises no floating point exceptions,
     // even if the operand is signalling."
     if (!EvaluateFloat(E->getSubExpr(), Result, Info))
       return false;
bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_MemberPointerToBoolean:
   case CK_ReinterpretMemberPointer:
   case CK_ConstructorConversion:
   case CK_IntegralToPointer:
   case CK_PointerToIntegral:
   case CK_PointerToBoolean:
   case CK_ToVoid:
   case CK_VectorSplat:
-  case CK_IntegralCast:
   case CK_BooleanToSignedIntegral:
+  case CK_IntegralCast:
   case CK_IntegralToBoolean:
   case CK_IntegralToFloating:
   case CK_FloatingToIntegral:
   case CK_FloatingToBoolean:
   case CK_FloatingCast:
   case CK_CPointerToObjCPointerCast:
   case CK_BlockPointerToObjCPointerCast:
   case CK_AnyPointerToBlockPointerCast:
bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_FixedPointToIntegral:
   case CK_IntegralToFixedPoint:
     llvm_unreachable("invalid cast kind for complex value");
 
   case CK_LValueToRValue:
   case CK_AtomicToNonAtomic:
   case CK_NoOp:
   case CK_LValueToRValueBitCast:
-    return ExprEvaluatorBaseTy::VisitCastExpr(E);
-
   case CK_Dependent:
   case CK_LValueBitCast:
   case CK_UserDefinedConversion:
-    return Error(E);
+    return ExprEvaluatorBaseTy::VisitCastExpr(E);
 
   case CK_FloatingRealToComplex: {
     APFloat &Real = Result.FloatReal;
     if (!EvaluateFloat(E->getSubExpr(), Real, Info))
       return false;
 
     Result.makeComplexFloat();
     Result.FloatImag = APFloat(Real.getSemantics());

 
 bool ComplexExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
   // Get the operand value into 'Result'.
   if (!Visit(E->getSubExpr()))
     return false;
 
   switch (E->getOpcode()) {
   default:
-    return Error(E);
+    return ExprEvaluatorBaseTy::VisitUnaryOperator(E);
   case UO_Extension:
     return true;
   case UO_Plus:
     // The result is always just the subexpr.
     return true;
   case UO_Minus:
     if (Result.isComplexFloat()) {
       Result.getComplexFloatReal().changeSign();
APSInt Expr::EvaluateKnownConstIntCheckOverflow(
   bool Result = ::EvaluateAsRValue(Info, this, EVResult.Val);
   (void)Result;
   assert(Result && "Could not evaluate expression");
   assert(EVResult.Val.isInt() && "Expression did not evaluate to integer");
 
   return EVResult.Val.getInt();
 }
 
-void Expr::EvaluateForOverflow(const ASTContext &Ctx) const {
-  assert(!isValueDependent() &&
-         "Expression evaluator can't be called on a dependent expression.");
-
-  bool IsConst;
-  EvalResult EVResult;
-  if (!FastEvaluateAsRValue(this, EVResult, Ctx, IsConst)) {
-    EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects);
-    Info.CheckingForUndefinedBehavior = true;
-    (void)::EvaluateAsRValue(Info, this, EVResult.Val);
-  }
+void Expr::EvaluateForDiagnostics(const ASTContext &Ctx) const {
+  EvalStatus Status;
+  EvalInfo Info(Ctx, Status, EvalInfo::EM_IgnoreSideEffects);
+  ::EvaluateForDiagnostics(Info, this, /*SubexpressionsOnly=*/false);
 }
 
 bool Expr::EvalResult::isGlobalLValue() const {
   assert(Val.isLValue());
   return IsGlobalLValue(Val.getLValueBase());
 }
 
 /// isIntegerConstantExpr - this recursive routine will test if an expression is

clang/lib/Sema/SemaChecking.cpp

 }
 
 /// CheckBoolLikeConversion - Check conversion of given expression to boolean.
 /// Input argument E is a logical expression.
 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) {
-  // Use a work list to deal with nested struct initializers.
-  SmallVector<Expr *, 2> Exprs(1, E);
-
-  do {
-    Expr *OriginalE = Exprs.pop_back_val();
-    Expr *E = OriginalE->IgnoreParenCasts();
-
-    if (isa<BinaryOperator>(E)) {
-      E->EvaluateForOverflow(Context);
-      continue;
-    }
-
-    if (auto InitList = dyn_cast<InitListExpr>(OriginalE))
-      Exprs.append(InitList->inits().begin(), InitList->inits().end());
-    else if (isa<ObjCBoxedExpr>(OriginalE))
-      E->EvaluateForOverflow(Context);
-    else if (auto Call = dyn_cast<CallExpr>(E))
-      Exprs.append(Call->arg_begin(), Call->arg_end());
-    else if (auto Message = dyn_cast<ObjCMessageExpr>(E))
-      Exprs.append(Message->arg_begin(), Message->arg_end());
-  } while (!Exprs.empty());
-}
-
 namespace {
 
 /// Visitor for expressions which looks for unsequenced operations on the
 /// same object.
 class SequenceChecker : public ConstEvaluatedExprVisitor<SequenceChecker> {
   using Base = ConstEvaluatedExprVisitor<SequenceChecker>;
 
   /// A tree of sequenced regions within an expression. Two regions are

 
 void Sema::CheckCompletedExpr(Expr *E, SourceLocation CheckLoc,
                               bool IsConstexpr) {
   llvm::SaveAndRestore<bool> ConstantContext(
       isConstantEvaluatedOverride, IsConstexpr || isa<ConstantExpr>(E));
   CheckImplicitConversions(E, CheckLoc);
   if (!E->isInstantiationDependent())
     CheckUnsequencedOperations(E);
-  if (!IsConstexpr && !E->isValueDependent())
-    CheckForIntOverflow(E);
+  if (!IsConstexpr)
+    E->EvaluateForDiagnostics(Context);
   DiagnoseMisalignedMembers();
 }
 
 void Sema::CheckBitFieldInitialization(SourceLocation InitLoc,
                                        FieldDecl *BitField,
                                        Expr *Init) {
   (void) AnalyzeBitFieldAssignment(*this, BitField, Init, InitLoc);
 }

clang/lib/Sema/SemaExpr.cpp

case Type::STK_Integral:
       return CK_FixedPointToIntegral;
     case Type::STK_Floating:
       return CK_FixedPointToFloating;
     case Type::STK_IntegralComplex:
     case Type::STK_FloatingComplex:
       Diag(Src.get()->getExprLoc(),
            diag::err_unimplemented_conversion_with_fixed_point_type)
           << DestTy;
-      return CK_IntegralCast;
+      Src = ExprError();
+      return CK_Dependent;
     case Type::STK_CPointer:
     case Type::STK_ObjCObjectPointer:
     case Type::STK_BlockPointer:
     case Type::STK_MemberPointer:
       llvm_unreachable("illegal cast to pointer type");
     }
     llvm_unreachable("Should have returned before this");
 
case Type::STK_FloatingComplex:
     case Type::STK_BlockPointer:
       llvm_unreachable("valid complex float->pointer cast?");
     case Type::STK_MemberPointer:
       llvm_unreachable("member pointer type in C");
     case Type::STK_FixedPoint:
       Diag(Src.get()->getExprLoc(),
            diag::err_unimplemented_conversion_with_fixed_point_type)
           << SrcTy;
-      return CK_IntegralCast;
+      Src = ExprError();
+      return CK_Dependent;
     }
     llvm_unreachable("Should have returned before this");
 
   case Type::STK_IntegralComplex:
     switch (DestTy->getScalarTypeKind()) {
     case Type::STK_FloatingComplex:
       return CK_IntegralComplexToFloatingComplex;
     case Type::STK_IntegralComplex:
case Type::STK_IntegralComplex:
     case Type::STK_BlockPointer:
       llvm_unreachable("valid complex int->pointer cast?");
     case Type::STK_MemberPointer:
       llvm_unreachable("member pointer type in C");
     case Type::STK_FixedPoint:
       Diag(Src.get()->getExprLoc(),
            diag::err_unimplemented_conversion_with_fixed_point_type)
           << SrcTy;
-      return CK_IntegralCast;
+      Src = ExprError();
+      return CK_Dependent;
     }
     llvm_unreachable("Should have returned before this");
   }
 
   llvm_unreachable("Unhandled scalar cast");
 }
 
 static bool breakDownVectorType(QualType type, uint64_t &len,
if (VTy->getVectorKind() == VectorType::AltiVecVector) {
     // The number of initializers must be one or must match the size of the
     // vector. If a single value is specified in the initializer then it will
     // be replicated to all the components of the vector
     if (numExprs == 1) {
       QualType ElemTy = VTy->getElementType();
       ExprResult Literal = DefaultLvalueConversion(exprs[0]);
       if (Literal.isInvalid())
         return ExprError();
-      Literal = ImpCastExprToType(Literal.get(), ElemTy,
-                                  PrepareScalarCast(Literal, ElemTy));
+      CastKind CK = PrepareScalarCast(Literal, ElemTy);
+      if (Literal.isInvalid())
+        return ExprError();
+      Literal = ImpCastExprToType(Literal.get(), ElemTy, CK);
       return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
     }
     else if (numExprs < numElems) {
       Diag(E->getExprLoc(),
            diag::err_incorrect_number_of_vector_initializers);
       return ExprError();
     }
     else
       initExprs.append(exprs, exprs + numExprs);
   }
   else {
     // For OpenCL, when the number of initializers is a single value,
     // it will be replicated to all components of the vector.
     if (getLangOpts().OpenCL &&
         VTy->getVectorKind() == VectorType::GenericVector &&
         numExprs == 1) {
         QualType ElemTy = VTy->getElementType();
         ExprResult Literal = DefaultLvalueConversion(exprs[0]);
         if (Literal.isInvalid())
           return ExprError();
-        Literal = ImpCastExprToType(Literal.get(), ElemTy,
-                                    PrepareScalarCast(Literal, ElemTy));
+        CastKind CK = PrepareScalarCast(Literal, ElemTy);
+        if (Literal.isInvalid())
+          return ExprError();
+        Literal = ImpCastExprToType(Literal.get(), ElemTy, CK);
         return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
     }
 
     initExprs.append(exprs, exprs + numExprs);
   }
   // FIXME: This means that pretty-printing the final AST will produce curly
   // braces instead of the original commas.
   InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc,
if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
     // different sizes, or between ExtInts and other types.
     if (ResTy.isNull() && (LHSTy->isExtIntType() || RHSTy->isExtIntType())) {
       Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
           << LHSTy << RHSTy << LHS.get()->getSourceRange()
           << RHS.get()->getSourceRange();
       return QualType();
     }
 
-    LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
-    RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
+    CastKind LHSCK = PrepareScalarCast(LHS, ResTy);
+    if (LHS.isInvalid())
+      return QualType();
+
+    CastKind RHSCK = PrepareScalarCast(RHS, ResTy);
+    if (RHS.isInvalid())
+      return QualType();
 
+    LHS = ImpCastExprToType(LHS.get(), ResTy, LHSCK);
+    RHS = ImpCastExprToType(RHS.get(), ResTy, RHSCK);
     return ResTy;
   }
 
   // And if they're both bfloat (which isn't arithmetic), that's fine too.
   if (LHSTy->isBFloat16Type() && RHSTy->isBFloat16Type()) {
     return LHSTy;
   }
 
Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS,
   // discards the imaginary part.
   if (getLangOpts().CPlusPlus && RHSType->getAs<ComplexType>() &&
       !LHSType->getAs<ComplexType>())
     return Incompatible;
 
   // Arithmetic conversions.
   if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&
       !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) {
-    if (ConvertRHS)
+    if (ConvertRHS) {
       Kind = PrepareScalarCast(RHS, LHSType);
+      // FIXME: Let the caller know we already diagnosed this to avoid a
+      // duplicate diagnostic.
+      if (RHS.isInvalid())
+        return Incompatible;
+    }
     return Compatible;
   }
 
   // Conversions to normal pointers.
   if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
     // U* -> T*
     if (isa<PointerType>(RHSType)) {
       LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();

clang/lib/Sema/SemaExprCXX.cpp

if (LHS.isInvalid() || RHS.isInvalid())
       return QualType();
     if (ResTy.isNull()) {
       Diag(QuestionLoc,
            diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
         << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
       return QualType();
     }
 
-    LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
-    RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
+    CastKind LHSCK = PrepareScalarCast(LHS, ResTy);
+    if (LHS.isInvalid())
+      return QualType();
+    CastKind RHSCK = PrepareScalarCast(RHS, ResTy);
+    if (RHS.isInvalid())
+      return QualType();
 
+    LHS = ImpCastExprToType(LHS.get(), ResTy, LHSCK);
+    RHS = ImpCastExprToType(RHS.get(), ResTy, RHSCK);
     return ResTy;
   }
 
   //   -- The second and third operands have pointer type, or one has pointer
   //      type and the other is a null pointer constant, or both are null
   //      pointer constants, at least one of which is non-integral; pointer
   //      conversions and qualification conversions are performed to bring them
   //      to their composite pointer type. The result is of the composite

clang/test/Sema/integer-overflow.c

 // RUN: %clang_cc1 %s -verify -fsyntax-only -triple x86_64-pc-linux-gnu
 typedef unsigned long long uint64_t;
 typedef unsigned int uint32_t;
 
 // Check integer sizes.
 int array64[sizeof(uint64_t) == 8 ? 1 : -1];
 int array32[sizeof(uint32_t) == 4 ? 1 : -1];
 int arrayint[sizeof(int) < sizeof(uint64_t) ? 1 : -1];
+extern int array[];
 
 uint64_t f0(uint64_t);
 uint64_t f1(uint64_t, uint32_t);
 uint64_t f2(uint64_t, ...);
 
 static const uint64_t overflow = 1 * 4608 * 1024 * 1024; // expected-warning {{overflow in expression; result is 536870912 with type 'int'}}
 
 uint64_t check_integer_overflows(int i) {
// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
   uint64_t not_overflow2 = (1ULL * ((uint64_t)(4608) * (1024 * 1024)) + 2ULL);
 
 // expected-warning@+1 2{{overflow in expression; result is 536870912 with type 'int'}}
   overflow = 4608 * 1024 * 1024 ?  4608 * 1024 * 1024 : 0;
 
 // expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
   overflow =  0 ? 0 : 4608 * 1024 * 1024;
 
+  if (i == 1)
+    // expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+    return array[4608 * 1024 * 1024];
+
 // expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
   if (4608 * 1024 * 1024)
     return 0;
 
 // expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
   if ((uint64_t)(4608 * 1024 * 1024))
     return 1;
 

clang/test/SemaCXX/integer-overflow.cpp

-// RUN: %clang_cc1 %s -verify -fsyntax-only -std=gnu++98 -triple x86_64-pc-linux-gnu
-// RUN: %clang_cc1 %s -verify -fsyntax-only -std=gnu++2a -triple x86_64-pc-linux-gnu
+// RUN: %clang_cc1 %s -verify -fsyntax-only -std=gnu++98 -triple x86_64-pc-linux-gnu -fcxx-exceptions
+// RUN: %clang_cc1 %s -verify -fsyntax-only -std=gnu++2a -triple x86_64-pc-linux-gnu -fcxx-exceptions
 
 typedef unsigned long long uint64_t;
 typedef unsigned int uint32_t;
 
 // Check integer sizes.
 int array64[sizeof(uint64_t) == 8 ? 1 : -1];
 int array32[sizeof(uint32_t) == 4 ? 1 : -1];
 int arrayint[sizeof(int) < sizeof(uint64_t) ? 1 : -1];
// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
   uint64_t x = f0(4608 * 1024 * 1024);
 
 // expected-warning@+2 {{overflow in expression; result is 536870912 with type 'int'}}
   uint64_t (*f0_ptr)(uint64_t) = &f0;
   (void)(*f0_ptr)(4608 * 1024 * 1024);
 
 // expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
   (void)f2(0, f0(4608 * 1024 * 1024));
+
+#if __cplusplus >= 201103L
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  uint64_t n = uint64_t{f0(4608 * 1024 * 1024)};
+#endif
+
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  throw 4608 * 1024 * 1024;
+
+  // No warning, UB is not reachable.
+  void(1 ? 1 : 4608 * 1024 * 1024);
+
+// expected-warning@+1 {{overflow in expression; result is 536870912 with type 'int'}}
+  void(0 ? 1 : 4608 * 1024 * 1024);
 }
 
 // Tests that ensure that evaluation-for-overflow of random expressions doesn't
 // crash.
 namespace EvaluationCrashes {
   namespace VirtualCallWithVbase {
     struct A {};
     struct B : virtual A {