ExprConstant: Propagate correct return values from constant evaluation.

[jyknight]

Summary

The constant evaluation now returns false whenever indicating failure
would be appropriate for the requested mode, instead of returning
"true" for success, and depending on the caller examining the various
status variables after the fact, in some circumstances.

In EM_ConstantExpression mode, evaluation is aborted as soon as a
diagnostic note is generated, and therefore, a "true" return value now
actually indicates that the expression was a constexpr. (You no longer
have to additionally check for a lack of diagnostic messages.)

In EM_ConstantFold, evaluation is now aborted upon running into a
side-effect -- so a "true" return value now actually indicates that
there were no side-effects

Also -- update and clarify documentation for the evaluation modes.

This is a cleanup, not intending to change the functionality, as
callers had been checking those properties manually before.

[rsmith]

clang/lib/AST/ExprConstant.cpp

12–32

Is this comment still correct?

682–719

Nit: LLVM style avoids /*...*/ comments even for long comment blocks like this (https://llvm.org/docs/CodingStandards.html#comment-formatting).

686–687

I think talking about diagnostic notes here distracts from the purpose, which is that this column indicates that we accept constructs that are not permitted by the language mode's constant expression rules.

688–690

"is okay" here is misleading, I think. The point of keepEvaluatingAfter[...] is that it's safe to stop evaluating if they return false, because later evaluations can't affect the overall result.

692

defer -> be deferred?

706–707

Allowing EM_ConstantExpression to evaluate expressions that EM_ConstantFold cannot evaluate would violate our invariants. We rely on being able to check up front that an expression is a constant expression and then later just ask for its value, and for the later query to always succeed and return the same value as the earlier one. (This is one of the reasons why I suggested in D52854 that we add an explicit AST representation for constant expressions.)

711

This is not the intent. The evaluator uses the rules of the current language mode. However, it doesn't enforce the C and C++98 syntactic restrictions on what can appear in a constant expression, because it turns out to be cleaner to check those separately rather than to interleave them with evaluation.

We should probably document this as evaluating following the evaluation (but not syntactic) constant expression rules of the current language mode.

726–732

This sentence is a little hard to read.

897–898

Nit: delete line

958

"Note" is beside the point here. We should be talking about non-constant expressions; that's what matters.

1283–1286

I would strongly prefer to keep the emission of the diagnostic and the corresponding return false adjacent whenever possible, so I'd prefer that we add a bool return value to diagnosePointerArithmetic.

(Eventually, we should remove these bool return values entirely and replace them with an enum, where the failure value is only ever created by the ...Diag functions and from places where we can prove that a diagnostic has already been emitted, so that we can easily ensure that every failure path produces a diagnostic first.)

1445–1449

checkSubobject should return false if it produced a diagnostic that should cause evaluation to halt; this call to keepEvaluatingAfterNote should not be necessary. (And likewise below.)

11489

Nit: there's no such thing as "a constexpr". I think you mean "a constant expression".

11492

How confident are you that all return false;s produce an accompanying note? We have had a long tail of situations where such notes are missing from some cases where evaluation fails. (Those were previously QoI bugs but will now result in an assertion failure.)

11605–11606

I fear that a "Same as above" comment will become stale during refactorings.

[jyknight]

Address most comments.

[jyknight]

clang/lib/AST/ExprConstant.cpp

12–32

Yes -- the "potential" constant expression mode still has this semantic.

682–719

Done.

686–687

Reworded.

688–690

The overall return value of the evaluation indicates whether the expression was evaluable under a specified set of conditions. The different modes cause failure under different conditions -- so I think "is okay" really _is_ what is meant here. In this particular case, "failure to evaluate" can still return success!

Not sure if some rewording would communicate that better?

692

Done.

706–707

I agree, it would right now. But I do think it should be fixed not to in the future. Let me reword the TODO, noting that it's not trivial.

711

I'm not really sure what you mean to distinguish between C/C++98 "evaluation constant expression rules" and the definition of a C/C++98 ICE?

Perhaps you mean that if evaluation succeeds, it will have produced a value consistent with the rules of the current language, but that it may not produce the diagnostics in all cases it ought to?

AFAICT, the evaluator is designed to emit diagnostics only for the C++11 (and later) constant expression rules, as well as for inability to evaluate. The diagnostic notes are usually dropped on the floor in C++98 and C modes, as only "fold" is typically used there -- along with the separate CheckICE to produce warnings.

I believe the only place the diagnostics were being actually emitted in pre-c++11 modes is for the diagnose_if and enable_if attributes' "potential constant expression" check. And there it really seems to me to be using the c++11 evaluation semantics.

The existence of isCXX11ConstantExpr suggests an intent for the function to provide the C++11 rules, as well, no?

726–732

Reworded.

897–898

Done.

958

Renamed to keepEvaluatingAfterNonConstexpr, updated comment.

1283–1286

Done, for diagnosePointerArithmetic.

1445–1449

Are you sure?

Today, checkSubobject returns false if it sees something "invalid" -- and the callers seem to depend on that -- but invalid subobject designators are still allowed during evaluation in fold mode.

E.g., this is valid in C:
struct Foo { int x[]; }; struct Foo f; int *g = f.x;

But, in C++, constexpr int *g = f.x; is an error, diagnosing note_constexpr_unsupported_unsized_array.

All the LValue code, with its mutable "Result" state, and carrying of a couple different "Invalid" bits off on the side, is really rather confusing!

11492

I attempted to ensure they were all covered. But I cannot be completely 100% sure.

I care more about the inverse really, though: that everywhere evaluation _should_ fail actually returns false, instead of only emitting a note.

11605–11606

Good point; copied the comment instead.

[rsmith]

clang/lib/AST/ExprConstant.cpp

710

LLVM -> Clang (or "we" or similar)

711

Perhaps you mean that if evaluation succeeds, it will have produced a value consistent with the rules of the current language, but that it may not produce the diagnostics in all cases it ought to?

The concern I have with this comment is that it describes a happenstance of implementation rather than the intent. The intent is certainly *not* that we will use the C++11 rules when calling this in C++98 mode, but it just so happens that there are no interesting differences there right now.

Looking at this another way, the fact that we only guarantee to produce "not a constant expression because" notes in C++11 onwards is unrelated to the evaluation mode. Rather, the reason for that is instead because all the validity / ICE checking in other language modes is based on the syntactic form of the expression (and is checked separately as a result).

As a concrete suggestion, how about something like:

"Evaluate as a constant expression. Stop if we find that the expression is not a constant expression. Note that this doesn't enforce the syntactic ICE requirements of C and C++98."

723

Do we now guarantee to stop on UB in this mode? We didn't appear to do so previously. (Particularly, we'd evaluate past signed overflow and take the 2's complement value.)

956

only no -> only if no

958

Capitalize as "...NonConstExpr" instead, since this is just an abbreviation of the term "constant expression", not C++11's notion of "constexpr". (I'd also lengthen this to "...NonConstantExpr" or "...NonConstantExpression" to further clarify.)

1198–1200

Simplify to return Info.keepEvaluating...();

1445–1449

What I mean is that you should change the code to make what I said be true, if necessary. It's the callee's responsibility to say whether we hit something we can't evaluate past. The caller should not be guessing that the only reason that checkSubobject can fail is due to a CCEDiag -- if checkSubobject fails with an FFDiag, this will sometimes return true, which would be wrong.

Here's how I'd look at it: a false value is a token that indicates that someone has produced a diagnostic whose severity is such that we don't need to keep evaluating. Once that happens, we don't need to re-check whether to keep evaluating, because we've already been told that we shouldn't, and we just need to propagate that fact to our caller.

2527–2529

Simplify to return LVal.adjust[...]

7438

Nit: drop the braces here.

11490–11492

I don't believe the parenthetical is true: in C++11 or later, we should always get a note if and only if the expression is not a constant expression, regardless of evaluation mode. Instead, I think the thing you're highlighting here is that the return value from EvaluateAsRValue does not indicate whether the expression is a constant expression unless the evaluation mode is EM_ConstantExpression.

11495–11496

Combine these two ifs.

clang/include/clang/AST/Expr.h

public:
 
   /// Determine whether this expression involves a call to any function
   /// that is not trivial.
   bool hasNonTrivialCall(const ASTContext &Ctx) const;
 
   /// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded
   /// integer. This must be called on an expression that constant folds to an
   /// integer.
-  llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx,
-                    SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;
+  llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx) const;
 
   void EvaluateForOverflow(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) const;
 
   /// EvaluateAsInitializer - Evaluate an expression as if it were the

clang/lib/AST/ExprConstant.cpp

 //===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Expr constant evaluator.
 //
 // Constant expression evaluation produces four main results:
 //
 //  * A success/failure flag indicating whether constant folding was successful.
 //    This is the 'bool' return value used by most of the code in this file. A
 //    'false' return value indicates that constant folding has failed, and any
 //    appropriate diagnostic has already been produced.
 //
 //  * An evaluated result, valid only if constant folding has not failed.
 //
 //  * A flag indicating if evaluation encountered (unevaluated) side-effects.
 //    These arise in cases such as (sideEffect(), 0) and (sideEffect() || 1),
 //    where it is possible to determine the evaluated result regardless.
 //
 //  * A set of notes indicating why the evaluation was not a constant expression
 //    (under the C++11 / C++1y rules only, at the moment), or, if folding failed
 //    too, why the expression could not be folded.
 //
 // If we are checking for a potential constant expression, failure to constant
 // fold a potential constant sub-expression will be indicated by a 'false'
 // return value (the expression could not be folded) and no diagnostic (the
 // expression is not necessarily non-constant).
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/APValue.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/CharUnits.h"
void addComplexUnchecked(QualType EltTy, bool Imag) {
 
       // This is technically a most-derived object, though in practice this
       // is unlikely to matter.
       MostDerivedType = EltTy;
       MostDerivedIsArrayElement = true;
       MostDerivedArraySize = 2;
       MostDerivedPathLength = Entries.size();
     }
-    void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, const Expr *E);
-    void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
+    bool diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
                                    const APSInt &N);
     /// Add N to the address of this subobject.
-    void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
-      if (Invalid || !N) return;
-      uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
-      if (isMostDerivedAnUnsizedArray()) {
-        diagnoseUnsizedArrayPointerArithmetic(Info, E);
-        // Can't verify -- trust that the user is doing the right thing (or if
-        // not, trust that the caller will catch the bad behavior).
-        // FIXME: Should we reject if this overflows, at least?
-        Entries.back().ArrayIndex += TruncatedN;
-        return;
-      }
-
-      // [expr.add]p4: For the purposes of these operators, a pointer to a
-      // nonarray object behaves the same as a pointer to the first element of
-      // an array of length one with the type of the object as its element type.
-      bool IsArray = MostDerivedPathLength == Entries.size() &&
-                     MostDerivedIsArrayElement;
-      uint64_t ArrayIndex =
-          IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd;
-      uint64_t ArraySize =
-          IsArray ? getMostDerivedArraySize() : (uint64_t)1;
-
-      if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
-        // Calculate the actual index in a wide enough type, so we can include
-        // it in the note.
-        N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
-        (llvm::APInt&)N += ArrayIndex;
-        assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index");
-        diagnosePointerArithmetic(Info, E, N);
-        setInvalid();
-        return;
-      }
-
-      ArrayIndex += TruncatedN;
-      assert(ArrayIndex <= ArraySize &&
-             "bounds check succeeded for out-of-bounds index");
-
-      if (IsArray)
-        Entries.back().ArrayIndex = ArrayIndex;
-      else
-        IsOnePastTheEnd = (ArrayIndex != 0);
-    }
+    bool adjustIndex(EvalInfo &Info, const Expr *E, APSInt N);
   };
 
   /// A stack frame in the constexpr call stack.
   struct CallStackFrame {
     EvalInfo &Info;
 
     /// Parent - The caller of this stack frame.
     CallStackFrame *Caller;
struct EvalInfo {
     /// Have we emitted a diagnostic explaining why we couldn't constant
     /// fold (not just why it's not strictly a constant expression)?
     bool HasFoldFailureDiagnostic;
 
     /// Whether or not we're currently speculatively evaluating.
     bool IsSpeculativelyEvaluating;
 
     enum EvaluationMode {
-      /// Evaluate as a constant expression. Stop if we find that the expression
-      /// is not a constant expression.
-      EM_ConstantExpression,
+      // The various EvaluationMode kinds vary in terms of what sorts of
+      // expressions they accept.
+      //
+      // Key for the following table:
+      // * N = Expressions which are evaluable, but are not a constant
+      //       expression (according to the language rules) are OK
+      //       (keepEvaluatingAfterNonConstexpr)
+      // * S = Failure to evaluate which only occurs in expressions used for
+      //       side-effect are okay.  (keepEvaluatingAfterSideEffect)
+      // * F = Failure to evaluate is okay. (keepEvaluatingAfterFailure)
+      // * E = Eagerly evaluate certain builtins to a value which would normally
+      //       be deferred until after optimizations.
+      //
+      // +-----------------------------------------+---+---+---+---+
+      // |                                         | N | S | F | E |
+      // +-----------------------------------------+---+---+---+---+
+      // |EM_ConstantExpression                    | . | . | . | . |
+      // |EM_ConstantFold                          | Y | . | . | . |
+      // |EM_ConstantFoldUnevaluated               | Y | . | . | Y |
+      // |EM_IgnoreSideEffects                     | Y | Y | . | . |
+      // |EM_PotentialConstantExpression           | . | Y | Y | . |
+      // |EM_PotentialConstantExpressionUnevaluated| . | Y | Y | Y |
+      // |EM_EvaluateForOverflow                   | Y | Y | Y | . |
+      // +-----------------------------------------+---+---+---+---+
+      //
+      // TODO: Fix EM_ConstantExpression and EM_PotentialConstantExpression to
+      // also eagerly evaluate. (and then delete
+      // EM_PotentialConstantExpressionUnevaluated as a duplicate).  This will
+      // be somewhat tricky to change, because LLVM currently verifies that an
+      // expression is a constant expression (possibly strictly with
+      // EM_ConstantExpression) in Sema/*, while it evaluates the value
+      // separately in CodeGen/* with EM_ConstantFold. Any changes to semantics
+      // here MUST ensure that if the first evaluation succeeds, the second must
+      // also, with the same value.
 
-      /// Evaluate as a potential constant expression. Keep going if we hit a
-      /// construct that we can't evaluate yet (because we don't yet know the
-      /// value of something) but stop if we hit something that could never be
-      /// a constant expression.
-      EM_PotentialConstantExpression,
+      /// Evaluate as a constant expression, as per C++11-and-later constexpr
+      /// rules. Stop if we find that the expression is not a constant
+      /// expression.
+      EM_ConstantExpression,
 
-      /// Fold the expression to a constant. Stop if we hit a side-effect that
-      /// we can't model.
+      /// Fold the expression to a constant, using any techniques we can. Stop
+      /// if we hit a side-effect that we can't model, or undefined behavior.
       EM_ConstantFold,
 
-      /// Evaluate the expression looking for integer overflow and similar
-      /// issues. Don't worry about side-effects, and try to visit all
-      /// subexpressions.
-      EM_EvaluateForOverflow,
+      /// Like EM_ConstantFold, but eagerly evaluates certain builtins which
+      /// always evaluate to a constant value eventually, but may otherwise do
+      /// so in the backend (in order to allow optimization passes to run).
+      /// This affects __builtin_object_size (and in the future also
+      /// __builtin_constant_p)
+      EM_ConstantFoldUnevaluated,
 
-      /// Evaluate in any way we know how. Don't worry about side-effects that
-      /// can't be modeled.
+      /// Like EM_ConstantFold, but in addition, ignores failure to evaluate
+      /// sub-expressions which are being evaluated for side-effect only.
       EM_IgnoreSideEffects,
 
-      /// Evaluate as a constant fold. Some expressions can be retried in the
-      /// optimizer if we don't constant fold them here, but in an unevaluated
-      /// context we try to fold them immediately since the optimizer never gets
-      /// a chance to look at it.
-      EM_ConstantFoldUnevaluated,
+      /// Evaluate as a potential constant expression, where the values of some
+      /// variables may be unknown. Keep going if we hit a construct that we
+      /// can't evaluate yet, but stop if we hit something that could never be a
+      /// constant expression.
+      EM_PotentialConstantExpression,
 
-      /// Evaluate as a potential constant expression. Keep going if we hit a
-      /// construct that we can't evaluate yet (because we don't yet know the
-      /// value of something) but stop if we hit something that could never be
-      /// a constant expression. Some expressions can be retried in the
-      /// optimizer if we don't constant fold them here, but in an unevaluated
-      /// context we try to fold them immediately since the optimizer never
-      /// gets a chance to look at it.
+      /// Just like EM_PotentialConstantExpression, but with the eager
+      /// evaluation behavior of EM_ConstantFoldUnevaluated.
       EM_PotentialConstantExpressionUnevaluated,
+
+      /// Evaluate the expression looking for integer overflow and similar
+      /// issues. Don't worry about side-effects, and try to visit as much of
+      /// the expression as possible.
+      EM_EvaluateForOverflow,
     } EvalMode;
 
     /// Are we checking whether the expression is a potential constant
     /// expression?
     bool checkingPotentialConstantExpression() const {
       return EvalMode == EM_PotentialConstantExpression ||
              EvalMode == EM_PotentialConstantExpressionUnevaluated;
     }
OptionalDiagnostic FFDiag(const Expr *E, diag::kind DiagId
                             unsigned ExtraNotes = 0) {
       if (EvalStatus.Diag)
         return Diag(E->getExprLoc(), DiagId, ExtraNotes, /*IsCCEDiag*/false);
       HasActiveDiagnostic = false;
       return OptionalDiagnostic();
     }
 
     /// Diagnose that the evaluation does not produce a C++11 core constant
     /// expression.
-    ///
-    /// FIXME: Stop evaluating if we're in EM_ConstantExpression or
-    /// EM_PotentialConstantExpression mode and we produce one of these.
     OptionalDiagnostic CCEDiag(SourceLocation Loc, diag::kind DiagId
                                  = diag::note_invalid_subexpr_in_const_expr,
                                unsigned ExtraNotes = 0) {
       // Don't override a previous diagnostic. Don't bother collecting
       // diagnostics if we're evaluating for overflow.
       if (!EvalStatus.Diag || !EvalStatus.Diag->empty()) {
         HasActiveDiagnostic = false;
         return OptionalDiagnostic();
       }
public:
 
     /// Note that we have had a side-effect, and determine whether we should
     /// keep evaluating.
     bool noteSideEffect() {
       EvalStatus.HasSideEffects = true;
       return keepEvaluatingAfterSideEffect();
     }
 
-    /// Should we continue evaluation after encountering undefined behavior?
-    bool keepEvaluatingAfterUndefinedBehavior() {
+    /// Should we continue evaluation after finding into a evaluatable
+    /// expression which is not a constant expression? If this returns true,
+    /// then the evaluation will be successful if and only no diagnostics are
+    /// emitted. If it returns false, evaluation can succeed with diagnostics.
+    bool keepEvaluatingAfterNonConstexpr() {
       switch (EvalMode) {
       case EM_EvaluateForOverflow:
       case EM_IgnoreSideEffects:
       case EM_ConstantFold:
       case EM_ConstantFoldUnevaluated:
         return true;
 
       case EM_PotentialConstantExpression:
       case EM_PotentialConstantExpressionUnevaluated:
       case EM_ConstantExpression:
         return false;
       }
       llvm_unreachable("Missed EvalMode case");
     }
 
     /// Note that we hit something that was technically undefined behavior, but
     /// that we can evaluate past it (such as signed overflow or floating-point
     /// division by zero.)
     bool noteUndefinedBehavior() {
       EvalStatus.HasUndefinedBehavior = true;
-      return keepEvaluatingAfterUndefinedBehavior();
+      return keepEvaluatingAfterNonConstexpr();
     }
 
     /// Should we continue evaluation as much as possible after encountering a
     /// construct which can't be reduced to a value?
     bool keepEvaluatingAfterFailure() {
       if (!StepsLeft)
         return false;
 

   typedef ScopeRAII<true> FullExpressionRAII;
 }
 
 bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
                                          CheckSubobjectKind CSK) {
   if (Invalid)
     return false;
   if (isOnePastTheEnd()) {
-    Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
-      << CSK;
+    Info.FFDiag(E, diag::note_constexpr_past_end_subobject) << CSK;
     setInvalid();
     return false;
   }
   // Note, we do not diagnose if isMostDerivedAnUnsizedArray(), because there
   // must actually be at least one array element; even a VLA cannot have a
   // bound of zero. And if our index is nonzero, we already had a CCEDiag.
   return true;
 }
 
-void SubobjectDesignator::diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info,
-                                                                const Expr *E) {
-  Info.CCEDiag(E, diag::note_constexpr_unsized_array_indexed);
-  // Do not set the designator as invalid: we can represent this situation,
-  // and correct handling of __builtin_object_size requires us to do so.
-}
-
-void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
+bool SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
                                                     const Expr *E,
                                                     const APSInt &N) {
   // If we're complaining, we must be able to statically determine the size of
   // the most derived array.
   if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)
     Info.CCEDiag(E, diag::note_constexpr_array_index)
       << N << /*array*/ 0
       << static_cast<unsigned>(getMostDerivedArraySize());
   else
     Info.CCEDiag(E, diag::note_constexpr_array_index)
       << N << /*non-array*/ 1;
   setInvalid();
+  if (!Info.keepEvaluatingAfterNonConstexpr())
+    return false;
+  return true;
+}
+
+bool SubobjectDesignator::adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
+  if (Invalid || !N)
+    return true;
+  uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
+  if (isMostDerivedAnUnsizedArray()) {
+    // Do not set the designator as invalid: we can represent this
+    // situation, and correct handling of __builtin_object_size
+    // requires us to do so.
+    Info.CCEDiag(E, diag::note_constexpr_unsized_array_indexed);
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
+    // Can't verify -- trust that the user is doing the right thing (or if
+    // not, trust that the caller will catch the bad behavior).
+    // FIXME: Should we reject if this overflows, at least?
+    Entries.back().ArrayIndex += TruncatedN;
+    return true;
+  }
+
+  // [expr.add]p4: For the purposes of these operators, a pointer to a
+  // nonarray object behaves the same as a pointer to the first element of
+  // an array of length one with the type of the object as its element type.
+  bool IsArray =
+      MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement;
+  uint64_t ArrayIndex =
+      IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd;
+  uint64_t ArraySize = IsArray ? getMostDerivedArraySize() : (uint64_t)1;
+
+  if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
+    // Calculate the actual index in a wide enough type, so we can include
+    // it in the note.
+    N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
+    (llvm::APInt &)N += ArrayIndex;
+    assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index");
+    return diagnosePointerArithmetic(Info, E, N);
+  }
+
+  ArrayIndex += TruncatedN;
+  assert(ArrayIndex <= ArraySize &&
+         "bounds check succeeded for out-of-bounds index");
+
+  if (IsArray)
+    Entries.back().ArrayIndex = ArrayIndex;
+  else
+    IsOnePastTheEnd = (ArrayIndex != 0);
+  return true;
 }
 
 CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
                                const FunctionDecl *Callee, const LValue *This,
                                APValue *Arguments)
     : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This),
       Arguments(Arguments), CallLoc(CallLoc), Index(Info.NextCallIndex++) {
   Info.CurrentCall = this;

 
 void EvalInfo::addCallStack(unsigned Limit) {
   // Determine which calls to skip, if any.
   unsigned ActiveCalls = CallStackDepth - 1;
   unsigned SkipStart = ActiveCalls, SkipEnd = SkipStart;
   if (Limit && Limit < ActiveCalls) {
     SkipStart = Limit / 2 + Limit % 2;
     SkipEnd = ActiveCalls - Limit / 2;
   }
 
   // Walk the call stack and add the diagnostics.
   unsigned CallIdx = 0;
   for (CallStackFrame *Frame = CurrentCall; Frame != &BottomFrame;
        Frame = Frame->Caller, ++CallIdx) {
     // Skip this call?
     if (CallIdx >= SkipStart && CallIdx < SkipEnd) {
       if (CallIdx == SkipStart) {
         // Note that we're skipping calls.
         addDiag(Frame->CallLoc, diag::note_constexpr_calls_suppressed)
           << unsigned(ActiveCalls - Limit);
void setNull(QualType PointerTy, uint64_t TargetVal) {
       IsNullPtr = true;
     }
 
     void setInvalid(APValue::LValueBase B, unsigned I = 0) {
       set(B, true);
     }
 
     // Check that this LValue is not based on a null pointer. If it is, produce
-    // a diagnostic and mark the designator as invalid.
+    // a diagnostic, mark the designator as invalid, and returns false.
     bool checkNullPointer(EvalInfo &Info, const Expr *E,
                           CheckSubobjectKind CSK) {
       if (Designator.Invalid)
         return false;
       if (IsNullPtr) {
         Info.CCEDiag(E, diag::note_constexpr_null_subobject)
           << CSK;
         Designator.setInvalid();
         return false;
       }
       return true;
     }
 
     // Check this LValue refers to an object. If not, set the designator to be
     // invalid and emit a diagnostic.
     bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {
       return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
              Designator.checkSubobject(Info, E, CSK);
     }
 
-    void addDecl(EvalInfo &Info, const Expr *E,
-                 const Decl *D, bool Virtual = false) {
-      if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
+    bool addDecl(EvalInfo &Info, const Expr *E, const Decl *D,
+                 bool Virtual = false) {
+      if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base)) {
         Designator.addDeclUnchecked(D, Virtual);
+        return true;
+      }
+      return Info.keepEvaluatingAfterNonConstexpr();
     }
-    void addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) {
+    bool addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) {
       if (!Designator.Entries.empty()) {
         Info.CCEDiag(E, diag::note_constexpr_unsupported_unsized_array);
         Designator.setInvalid();
-        return;
+        return Info.keepEvaluatingAfterNonConstexpr();
       }
       if (checkSubobject(Info, E, CSK_ArrayToPointer)) {
         assert(getType(Base)->isPointerType() || getType(Base)->isArrayType());
         Designator.FirstEntryIsAnUnsizedArray = true;
         Designator.addUnsizedArrayUnchecked(ElemTy);
+        return true;
       }
+      return Info.keepEvaluatingAfterNonConstexpr();
     }
-    void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
-      if (checkSubobject(Info, E, CSK_ArrayToPointer))
+    bool addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
+      if (checkSubobject(Info, E, CSK_ArrayToPointer)) {
         Designator.addArrayUnchecked(CAT);
+        return true;
       }
-    void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
-      if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
+      return Info.keepEvaluatingAfterNonConstexpr();
+    }
+    bool addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
+      if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real)) {
         Designator.addComplexUnchecked(EltTy, Imag);
+        return true;
+      }
+      return Info.keepEvaluatingAfterNonConstexpr();
     }
     void clearIsNullPointer() {
       IsNullPtr = false;
     }
-    void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
+    bool adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
                               const APSInt &Index, CharUnits ElementSize) {
       // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB,
       // but we're not required to diagnose it and it's valid in C++.)
       if (!Index)
-        return;
+        return true;
 
       // Compute the new offset in the appropriate width, wrapping at 64 bits.
       // FIXME: When compiling for a 32-bit target, we should use 32-bit
       // offsets.
       uint64_t Offset64 = Offset.getQuantity();
       uint64_t ElemSize64 = ElementSize.getQuantity();
       uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
       Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64);
 
-      if (checkNullPointer(Info, E, CSK_ArrayIndex))
-        Designator.adjustIndex(Info, E, Index);
+      if (!checkNullPointer(Info, E, CSK_ArrayIndex)) {
+        if (!Info.keepEvaluatingAfterNonConstexpr())
+          return false;
+      }
+
+      if (!Designator.adjustIndex(Info, E, Index))
+        return false;
+
       clearIsNullPointer();
+      return true;
     }
     void adjustOffset(CharUnits N) {
       Offset += N;
       if (N.getQuantity())
         clearIsNullPointer();
     }
   };
 
static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
   // an extension: the standard requires them to point to an object.
   if (!IsReferenceType)
     return true;
 
   // A reference constant expression must refer to an object.
   if (!Base) {
     // FIXME: diagnostic
     Info.CCEDiag(Loc);
-    return true;
+    return Info.keepEvaluatingAfterNonConstexpr();
   }
 
   // Does this refer one past the end of some object?
   if (!Designator.Invalid && Designator.isOnePastTheEnd()) {
     const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
-    Info.FFDiag(Loc, diag::note_constexpr_past_end, 1)
+    Info.CCEDiag(Loc, diag::note_constexpr_past_end, 1)
         << !Designator.Entries.empty() << !!VD << VD;
     NoteLValueLocation(Info, Base);
+    return Info.keepEvaluatingAfterNonConstexpr();
   }
 
   return true;
 }
 
 /// Member pointers are constant expressions unless they point to a
 /// non-virtual dllimport member function.
 static bool CheckMemberPointerConstantExpression(EvalInfo &Info,
if (Info.getLangOpts().OpenCL)
       // OpenCL 6.3j: shift values are effectively % word size of LHS.
       RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
                     static_cast<uint64_t>(LHS.getBitWidth() - 1)),
                     RHS.isUnsigned());
     else if (RHS.isSigned() && RHS.isNegative()) {
       // During constant-folding, a negative shift is an opposite shift. Such
       // a shift is not a constant expression.
       Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
+      if (!Info.keepEvaluatingAfterNonConstexpr())
+        return false;
+
       RHS = -RHS;
       goto shift_right;
     }
   shift_left:
     // C++11 [expr.shift]p1: Shift width must be less than the bit width of
     // the shifted type.
     unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
     if (SA != RHS) {
       Info.CCEDiag(E, diag::note_constexpr_large_shift)
         << RHS << E->getType() << LHS.getBitWidth();
+      if (!Info.keepEvaluatingAfterNonConstexpr())
+        return false;
     } else if (LHS.isSigned()) {
       // C++11 [expr.shift]p2: A signed left shift must have a non-negative
       // operand, and must not overflow the corresponding unsigned type.
-      if (LHS.isNegative())
+      if (LHS.isNegative()) {
         Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
-      else if (LHS.countLeadingZeros() < SA)
+        if (!Info.keepEvaluatingAfterNonConstexpr())
+          return false;
+      } else if (LHS.countLeadingZeros() < SA) {
         Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
+        if (!Info.keepEvaluatingAfterNonConstexpr())
+          return false;
+      }
     }
     Result = LHS << SA;
     return true;
   }
   case BO_Shr: {
     if (Info.getLangOpts().OpenCL)
       // OpenCL 6.3j: shift values are effectively % word size of LHS.
       RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
                     static_cast<uint64_t>(LHS.getBitWidth() - 1)),
                     RHS.isUnsigned());
     else if (RHS.isSigned() && RHS.isNegative()) {
       // During constant-folding, a negative shift is an opposite shift. Such a
       // shift is not a constant expression.
       Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
+      if (!Info.keepEvaluatingAfterNonConstexpr())
+        return false;
+
       RHS = -RHS;
       goto shift_left;
     }
   shift_right:
     // C++11 [expr.shift]p1: Shift width must be less than the bit width of the
     // shifted type.
     unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
-    if (SA != RHS)
+    if (SA != RHS) {
       Info.CCEDiag(E, diag::note_constexpr_large_shift)
         << RHS << E->getType() << LHS.getBitWidth();
+      if (!Info.keepEvaluatingAfterNonConstexpr())
+        return false;
+    }
     Result = LHS >> SA;
     return true;
   }
 
   case BO_LT: Result = LHS < RHS; return true;
   case BO_GT: Result = LHS > RHS; return true;
   case BO_LE: Result = LHS <= RHS; return true;
   case BO_GE: Result = LHS >= RHS; return true;
static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj,
                                    const CXXRecordDecl *Base,
                                    const ASTRecordLayout *RL = nullptr) {
   if (!RL) {
     if (Derived->isInvalidDecl()) return false;
     RL = &Info.Ctx.getASTRecordLayout(Derived);
   }
 
   Obj.getLValueOffset() += RL->getBaseClassOffset(Base);
-  Obj.addDecl(Info, E, Base, /*Virtual*/ false);
-  return true;
+  return Obj.addDecl(Info, E, Base, /*Virtual*/ false);
 }
 
 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);
 
   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;
 
   // Find the virtual base class.
   if (DerivedDecl->isInvalidDecl()) return false;
   const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
   Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl);
-  Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
-  return true;
+  return Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
 }
 
 static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E,
                                  QualType Type, LValue &Result) {
   for (CastExpr::path_const_iterator PathI = E->path_begin(),
                                      PathE = E->path_end();
        PathI != PathE; ++PathI) {
     if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(),
static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal,
                                const ASTRecordLayout *RL = nullptr) {
   if (!RL) {
     if (FD->getParent()->isInvalidDecl()) return false;
     RL = &Info.Ctx.getASTRecordLayout(FD->getParent());
   }
 
   unsigned I = FD->getFieldIndex();
   LVal.adjustOffset(Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I)));
-  LVal.addDecl(Info, E, FD);
-  return true;
+  return LVal.addDecl(Info, E, FD);
 }
 
 /// Update LVal to refer to the given indirect field.
 static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E,
                                        LValue &LVal,
                                        const IndirectFieldDecl *IFD) {
   for (const auto *C : IFD->chain())
     if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(C)))

 /// \param Adjustment - The adjustment, in objects of type EltTy, to add.
 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
                                         LValue &LVal, QualType EltTy,
                                         APSInt Adjustment) {
   CharUnits SizeOfPointee;
   if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfPointee))
     return false;
 
-  LVal.adjustOffsetAndIndex(Info, E, Adjustment, SizeOfPointee);
+  if (!LVal.adjustOffsetAndIndex(Info, E, Adjustment, SizeOfPointee))
+    return false;
   return true;
 }
 
 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
                                         LValue &LVal, QualType EltTy,
                                         int64_t Adjustment) {
   return HandleLValueArrayAdjustment(Info, E, LVal, EltTy,
                                      APSInt::get(Adjustment));
 }
 
 /// Update an lvalue to refer to a component of a complex number.
 /// \param Info - Information about the ongoing evaluation.
 /// \param LVal - The lvalue to be updated.
 /// \param EltTy - The complex number's component type.
 /// \param Imag - False for the real component, true for the imaginary.
 static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E,
                                        LValue &LVal, QualType EltTy,
                                        bool Imag) {
   if (Imag) {
     CharUnits SizeOfComponent;
     if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent))
       return false;
     LVal.Offset += SizeOfComponent;
   }
-  LVal.addComplex(Info, E, EltTy, Imag);
-  return true;
+  return LVal.addComplex(Info, E, EltTy, Imag);
 }
 
 static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
                                            QualType Type, const LValue &LVal,
                                            APValue &RVal);
 
 /// Try to evaluate the initializer for a variable declaration.
 ///
if (!VD->evaluateValue(Notes)) {
     Info.Note(VD->getLocation(), diag::note_declared_at);
     Info.addNotes(Notes);
     return false;
   } else if (!VD->checkInitIsICE()) {
     Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant,
                  Notes.size() + 1) << VD;
     Info.Note(VD->getLocation(), diag::note_declared_at);
     Info.addNotes(Notes);
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
   }
 
   Result = VD->getEvaluatedValue();
   return true;
 }
 
 static bool IsConstNonVolatile(QualType T) {
   Qualifiers Quals = T.getQualifiers();
if (!Frame) {
         // static const data members of such types (supported as an extension)
         // more useful.
         if (Info.getLangOpts().CPlusPlus11) {
           Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
           Info.Note(VD->getLocation(), diag::note_declared_at);
         } else {
           Info.CCEDiag(E);
         }
+        if (!Info.keepEvaluatingAfterNonConstexpr())
+          return CompleteObject();
       } else if (BaseType.isConstQualified() && VD->hasDefinition(Info.Ctx)) {
         Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr) << VD;
+        if (!Info.keepEvaluatingAfterNonConstexpr())
+          return CompleteObject();
         // Keep evaluating to see what we can do.
       } else {
         // FIXME: Allow folding of values of any literal type in all languages.
         if (Info.checkingPotentialConstantExpression() &&
             VD->getType().isConstQualified() && !VD->hasDefinition(Info.Ctx)) {
           // The definition of this variable could be constexpr. We can't
           // access it right now, but may be able to in future.
         } else if (Info.getLangOpts().CPlusPlus11) {
if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
     return false;
 
   QualType TargetQT = E->getType();
   if (const PointerType *PT = TargetQT->getAs<PointerType>())
     TargetQT = PT->getPointeeType();
 
   // Check this cast lands within the final derived-to-base subobject path.
   if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) {
-    Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
+    Info.FFDiag(E, diag::note_constexpr_invalid_downcast)
         << D.MostDerivedType << TargetQT;
     return false;
   }
 
   // Check the type of the final cast. We don't need to check the path,
   // since a cast can only be formed if the path is unique.
   unsigned NewEntriesSize = D.Entries.size() - E->path_size();
   const CXXRecordDecl *TargetType = TargetQT->getAsCXXRecordDecl();
   const CXXRecordDecl *FinalType;
   if (NewEntriesSize == D.MostDerivedPathLength)
     FinalType = D.MostDerivedType->getAsCXXRecordDecl();
   else
     FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
   if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) {
-    Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
+    Info.FFDiag(E, diag::note_constexpr_invalid_downcast)
         << D.MostDerivedType << TargetQT;
     return false;
   }
 
   // Truncate the lvalue to the appropriate derived class.
   return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize);
 }
 
 namespace {
if (Info.getLangOpts().CPlusPlus11) {
       // FIXME: If DiagDecl is an implicitly-declared special member function,
       // we should be much more explicit about why it's not constexpr.
       Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
         << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD;
       Info.Note(CD->getLocation(), diag::note_declared_at);
     } else {
       Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
     }
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
   }
   return true;
 }
 
 /// CheckConstexprFunction - Check that a function can be called in a constant
 /// expression.
 static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc,
                                    const FunctionDecl *Declaration,
bool HandleConditionalOperator(const ConditionalOperator *E) {
     return StmtVisitorTy::Visit(EvalExpr);
   }
 
 protected:
   EvalInfo &Info;
   typedef ConstStmtVisitor<Derived, bool> StmtVisitorTy;
   typedef ExprEvaluatorBase ExprEvaluatorBaseTy;
 
-  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
-    return Info.CCEDiag(E, D);
-  }
-
   bool ZeroInitialization(const Expr *E) { return Error(E); }
 
 public:
   ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
 
   EvalInfo &getEvalInfo() { return Info; }
 
   /// Report an evaluation error. This should only be called when an error is
bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
     return StmtVisitorTy::Visit(E->getExpr());
   }
   // We cannot create any objects for which cleanups are required, so there is
   // nothing to do here; all cleanups must come from unevaluated subexpressions.
   bool VisitExprWithCleanups(const ExprWithCleanups *E)
     { return StmtVisitorTy::Visit(E->getSubExpr()); }
 
   bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
-    CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
+    Info.CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
     return static_cast<Derived*>(this)->VisitCastExpr(E);
   }
   bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
-    CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
+    Info.CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
     return static_cast<Derived*>(this)->VisitCastExpr(E);
   }
 
   bool VisitBinaryOperator(const BinaryOperator *E) {
     switch (E->getOpcode()) {
     default:
       return Error(E);
 
     case BO_Comma:
-      VisitIgnoredValue(E->getLHS());
+      if (!VisitIgnoredValue(E->getLHS()))
+        return false;
       return StmtVisitorTy::Visit(E->getRHS());
 
     case BO_PtrMemD:
     case BO_PtrMemI: {
       LValue Obj;
       if (!HandleMemberPointerAccess(Info, E, Obj))
         return false;
       APValue Result;
for (CompoundStmt::const_body_iterator BI = CS->body_begin(),
         return false;
       }
     }
 
     llvm_unreachable("Return from function from the loop above.");
   }
 
   /// Visit a value which is evaluated, but whose value is ignored.
-  void VisitIgnoredValue(const Expr *E) {
-    EvaluateIgnoredValue(Info, E);
+  bool VisitIgnoredValue(const Expr *E) {
+    return EvaluateIgnoredValue(Info, E);
   }
 
   /// Potentially visit a MemberExpr's base expression.
-  void VisitIgnoredBaseExpression(const Expr *E) {
+  bool VisitIgnoredBaseExpression(const Expr *E) {
     // While MSVC doesn't evaluate the base expression, it does diagnose the
     // presence of side-effecting behavior.
     if (Info.getLangOpts().MSVCCompat && !E->HasSideEffects(Info.Ctx))
-      return;
-    VisitIgnoredValue(E);
+      return true;
+    return VisitIgnoredValue(E);
   }
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Common base class for lvalue and temporary evaluation.
 //===----------------------------------------------------------------------===//
public:
   bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO);
 
   bool VisitCastExpr(const CastExpr *E) {
     switch (E->getCastKind()) {
     default:
       return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
 
     case CK_LValueBitCast:
-      this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
+      Info.CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
+      if (!Info.keepEvaluatingAfterNonConstexpr())
+        return false;
       if (!Visit(E->getSubExpr()))
         return false;
       Result.Designator.setInvalid();
-      return true;
+      return Info.keepEvaluatingAfterNonConstexpr();
 
     case CK_BaseToDerived:
       if (!Visit(E->getSubExpr()))
         return false;
       return HandleBaseToDerivedCast(Info, E, Result);
     }
   }
 };

 
 bool LValueExprEvaluator::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
   return Success(E);
 }
 
 bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
   // Handle static data members.
   if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) {
-    VisitIgnoredBaseExpression(E->getBase());
+    if (!VisitIgnoredBaseExpression(E->getBase()))
+      return false;
     return VisitVarDecl(E, VD);
   }
 
   // Handle static member functions.
   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) {
     if (MD->isStatic()) {
-      VisitIgnoredBaseExpression(E->getBase());
+      if (!VisitIgnoredBaseExpression(E->getBase()))
+        return false;
       return Success(MD);
     }
   }
 
   // Handle non-static data members.
   return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
 }
 
static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base,
   if (!tryUnwrapAllocSizeCall(E))
     return false;
 
   // Store E instead of E unwrapped so that the type of the LValue's base is
   // what the user wanted.
   Result.setInvalid(E);
 
   QualType Pointee = E->getType()->castAs<PointerType>()->getPointeeType();
-  Result.addUnsizedArray(Info, E, Pointee);
-  return true;
+  return Result.addUnsizedArray(Info, E, Pointee);
 }
 
 namespace {
 class PointerExprEvaluator
   : public ExprEvaluatorBase<PointerExprEvaluator> {
   LValue &Result;
   bool InvalidBaseOK;
 
case CK_AddressSpaceConversion:
     if (!Visit(SubExpr))
       return false;
     // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are
     // permitted in constant expressions in C++11. Bitcasts from cv void* are
     // also static_casts, but we disallow them as a resolution to DR1312.
     if (!E->getType()->isVoidPointerType()) {
       Result.Designator.setInvalid();
       if (SubExpr->getType()->isVoidPointerType())
-        CCEDiag(E, diag::note_constexpr_invalid_cast)
+        Info.CCEDiag(E, diag::note_constexpr_invalid_cast)
             << 3 << SubExpr->getType();
       else
-        CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
+        Info.CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
+      if (!Info.keepEvaluatingAfterNonConstexpr())
+        return false;
     }
     if (E->getCastKind() == CK_AddressSpaceConversion && Result.IsNullPtr)
       ZeroInitialization(E);
     return true;
 
   case CK_DerivedToBase:
   case CK_UncheckedDerivedToBase:
     if (!evaluatePointer(E->getSubExpr(), Result))
bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_BaseToDerived:
     if (!Visit(E->getSubExpr()))
       return false;
     if (!Result.Base && Result.Offset.isZero())
       return true;
     return HandleBaseToDerivedCast(Info, E, Result);
 
   case CK_NullToPointer:
-    VisitIgnoredValue(E->getSubExpr());
+    if (!VisitIgnoredValue(E->getSubExpr()))
+      return false;
     return ZeroInitialization(E);
 
   case CK_IntegralToPointer: {
-    CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
+    Info.CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
 
     APValue Value;
     if (!EvaluateIntegerOrLValue(SubExpr, Value, Info))
       break;
 
     if (Value.isInt()) {
       unsigned Size = Info.Ctx.getTypeSize(E->getType());
       uint64_t N = Value.getInt().extOrTrunc(Size).getZExtValue();
if (SubExpr->isGLValue()) {
       APValue &Value = createTemporary(SubExpr, false, Result,
                                        *Info.CurrentCall);
       if (!EvaluateInPlace(Value, Info, Result, SubExpr))
         return false;
     }
     // The result is a pointer to the first element of the array.
     auto *AT = Info.Ctx.getAsArrayType(SubExpr->getType());
     if (auto *CAT = dyn_cast<ConstantArrayType>(AT))
-      Result.addArray(Info, E, CAT);
+      return Result.addArray(Info, E, CAT);
     else
-      Result.addUnsizedArray(Info, E, AT->getElementType());
-    return true;
+      return Result.addUnsizedArray(Info, E, AT->getElementType());
   }
 
   case CK_FunctionToPointerDecay:
     return evaluateLValue(SubExpr, Result);
 
   case CK_LValueToRValue: {
     LValue LVal;
     if (!evaluateLValue(E->getSubExpr(), LVal))
bool PointerExprEvaluator::visitNonBuiltinCallExpr(const CallExpr *E) {
   if (ExprEvaluatorBaseTy::VisitCallExpr(E))
     return true;
 
   if (!(InvalidBaseOK && getAllocSizeAttr(E)))
     return false;
 
   Result.setInvalid(E);
   QualType PointeeTy = E->getType()->castAs<PointerType>()->getPointeeType();
-  Result.addUnsizedArray(Info, E, PointeeTy);
-  return true;
+  return Result.addUnsizedArray(Info, E, PointeeTy);
 }
 
 bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) {
   if (IsStringLiteralCall(E))
     return Success(E);
 
   if (unsigned BuiltinOp = E->getBuiltinCallee())
     return VisitBuiltinCallExpr(E, BuiltinOp);
if (OffsetResult.Base) {
       } else {
         BaseAlignment =
           GetAlignOfExpr(Info, OffsetResult.Base.get<const Expr*>());
       }
 
       if (BaseAlignment < Align) {
         Result.Designator.setInvalid();
         // FIXME: Add support to Diagnostic for long / long long.
-        CCEDiag(E->getArg(0),
-                diag::note_constexpr_baa_insufficient_alignment) << 0
-          << (unsigned)BaseAlignment.getQuantity()
+        Info.FFDiag(E->getArg(0),
+                    diag::note_constexpr_baa_insufficient_alignment)
+            << 0 << (unsigned)BaseAlignment.getQuantity()
             << (unsigned)Align.getQuantity();
         return false;
       }
     }
 
     // The offset must also have the correct alignment.
     if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) {
       Result.Designator.setInvalid();
 
       (OffsetResult.Base
-           ? CCEDiag(E->getArg(0),
-                     diag::note_constexpr_baa_insufficient_alignment) << 1
-           : CCEDiag(E->getArg(0),
+           ? Info.FFDiag(E->getArg(0),
+                         diag::note_constexpr_baa_insufficient_alignment)
+                 << 1
+           : Info.FFDiag(E->getArg(0),
                          diag::note_constexpr_baa_value_insufficient_alignment))
           << (int)OffsetResult.Offset.getQuantity()
           << (unsigned)Align.getQuantity();
       return false;
     }
 
     return true;
   }
 
   case Builtin::BIstrchr:
   case Builtin::BIwcschr:
   case Builtin::BImemchr:
   case Builtin::BIwmemchr:
     if (Info.getLangOpts().CPlusPlus11)
       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
         << /*isConstexpr*/0 << /*isConstructor*/0
         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
     else
       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
     LLVM_FALLTHROUGH;
   case Builtin::BI__builtin_strchr:
   case Builtin::BI__builtin_wcschr:
   case Builtin::BI__builtin_memchr:
   case Builtin::BI__builtin_char_memchr:
   case Builtin::BI__builtin_wmemchr: {
     if (!Visit(E->getArg(0)))
       return false;
bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
   case Builtin::BIwmemcpy:
   case Builtin::BIwmemmove:
     if (Info.getLangOpts().CPlusPlus11)
       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
         << /*isConstexpr*/0 << /*isConstructor*/0
         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
     else
       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
     LLVM_FALLTHROUGH;
   case Builtin::BI__builtin_memcpy:
   case Builtin::BI__builtin_memmove:
   case Builtin::BI__builtin_wmemcpy:
   case Builtin::BI__builtin_wmemmove: {
     bool WChar = BuiltinOp == Builtin::BIwmemcpy ||
                  BuiltinOp == Builtin::BIwmemmove ||
                  BuiltinOp == Builtin::BI__builtin_wmemcpy ||

 }
 
 bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
   switch (E->getCastKind()) {
   default:
     return ExprEvaluatorBaseTy::VisitCastExpr(E);
 
   case CK_NullToMemberPointer:
-    VisitIgnoredValue(E->getSubExpr());
+    if (!VisitIgnoredValue(E->getSubExpr()))
+      return false;
     return ZeroInitialization(E);
 
   case CK_BaseToDerivedMemberPointer: {
     if (!Visit(E->getSubExpr()))
       return false;
     if (E->path_empty())
       return true;
     // Base-to-derived member pointer casts store the path in derived-to-base
bool RecordExprEvaluator::VisitCXXStdInitializerListExpr(
   const ConstantArrayType *ArrayType =
       Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
 
   LValue Array;
   if (!EvaluateLValue(E->getSubExpr(), Array, Info))
     return false;
 
   // Get a pointer to the first element of the array.
-  Array.addArray(Info, E, ArrayType);
+  if (!Array.addArray(Info, E, ArrayType))
+    return false;
 
   // FIXME: Perform the checks on the field types in SemaInit.
   RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
   RecordDecl::field_iterator Field = Record->field_begin();
   if (Field == Record->field_end())
     return Error(E);
 
   // Start pointer.
else
     ZeroElement =
         APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
 
   SmallVector<APValue, 4> Elements(VT->getNumElements(), ZeroElement);
   return Success(Elements, E);
 }
 
 bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
-  VisitIgnoredValue(E->getSubExpr());
+  if (!VisitIgnoredValue(E->getSubExpr()))
+    return false;
   return ZeroInitialization(E);
 }
 
 //===----------------------------------------------------------------------===//
 // Array Evaluation
 //===----------------------------------------------------------------------===//
 
 namespace {
bool ZeroInitialization(const Expr *E) {
         return Error(E);
 
       Result = APValue(APValue::UninitArray(), 0,
                        CAT->getSize().getZExtValue());
       if (!Result.hasArrayFiller()) return true;
 
       // Zero-initialize all elements.
       LValue Subobject = This;
-      Subobject.addArray(Info, E, CAT);
+      if (!Subobject.addArray(Info, E, CAT))
+        return false;
       ImplicitValueInitExpr VIE(CAT->getElementType());
       return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
     }
 
     bool VisitCallExpr(const CallExpr *E) {
       return handleCallExpr(E, Result, &This);
     }
     bool VisitInitListExpr(const InitListExpr *E);
bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
   if (!Filler.isUninit()) {
     for (unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I)
       Result.getArrayInitializedElt(I) = Filler;
     if (Result.hasArrayFiller())
       Result.getArrayFiller() = Filler;
   }
 
   LValue Subobject = This;
-  Subobject.addArray(Info, E, CAT);
+  if (!Subobject.addArray(Info, E, CAT))
+    return false;
   for (unsigned Index = 0; Index != NumEltsToInit; ++Index) {
     const Expr *Init =
         Index < E->getNumInits() ? E->getInit(Index) : FillerExpr;
     if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
                          Info, Subobject, Init) ||
         !HandleLValueArrayAdjustment(Info, Init, Subobject,
                                      CAT->getElementType(), 1)) {
       if (!Info.noteFailure())
if (E->getCommonExpr() &&
     return false;
 
   auto *CAT = cast<ConstantArrayType>(E->getType()->castAsArrayTypeUnsafe());
 
   uint64_t Elements = CAT->getSize().getZExtValue();
   Result = APValue(APValue::UninitArray(), Elements, Elements);
 
   LValue Subobject = This;
-  Subobject.addArray(Info, E, CAT);
+  if (!Subobject.addArray(Info, E, CAT))
+    return false;
 
   bool Success = true;
   for (EvalInfo::ArrayInitLoopIndex Index(Info); Index != Elements; ++Index) {
     if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
                          Info, Subobject, E->getSubExpr()) ||
         !HandleLValueArrayAdjustment(Info, E, Subobject,
                                      CAT->getElementType(), 1)) {
       if (!Info.noteFailure())
if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) {
     *Value = APValue(APValue::UninitArray(), N, N);
 
     if (HadZeroInit)
       for (unsigned I = 0; I != N; ++I)
         Value->getArrayInitializedElt(I) = Filler;
 
     // Initialize the elements.
     LValue ArrayElt = Subobject;
-    ArrayElt.addArray(Info, E, CAT);
+    if (!ArrayElt.addArray(Info, E, CAT))
+      return false;
     for (unsigned I = 0; I != N; ++I)
       if (!VisitCXXConstructExpr(E, ArrayElt, &Value->getArrayInitializedElt(I),
                                  CAT->getElementType()) ||
           !HandleLValueArrayAdjustment(Info, E, ArrayElt,
                                        CAT->getElementType(), 1))
         return false;
 
     return true;
public:
   bool VisitDeclRefExpr(const DeclRefExpr *E) {
     if (CheckReferencedDecl(E, E->getDecl()))
       return true;
 
     return ExprEvaluatorBaseTy::VisitDeclRefExpr(E);
   }
   bool VisitMemberExpr(const MemberExpr *E) {
     if (CheckReferencedDecl(E, E->getMemberDecl())) {
-      VisitIgnoredBaseExpression(E->getBase());
-      return true;
+      return VisitIgnoredBaseExpression(E->getBase());
     }
 
     return ExprEvaluatorBaseTy::VisitMemberExpr(E);
   }
 
   bool VisitCallExpr(const CallExpr *E);
   bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
   bool VisitBinaryOperator(const BinaryOperator *E);
   bool VisitOffsetOfExpr(const OffsetOfExpr *E);
bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
   case Builtin::BIwcslen:
     // A call to strlen is not a constant expression.
     if (Info.getLangOpts().CPlusPlus11)
       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
         << /*isConstexpr*/0 << /*isConstructor*/0
         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
     else
       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
     LLVM_FALLTHROUGH;
   case Builtin::BI__builtin_strlen:
   case Builtin::BI__builtin_wcslen: {
     // As an extension, we support __builtin_strlen() as a constant expression,
     // and support folding strlen() to a constant.
     LValue String;
     if (!EvaluatePointer(E->getArg(0), String, Info))
       return false;
bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
   case Builtin::BIwmemcmp:
     // A call to strlen is not a constant expression.
     if (Info.getLangOpts().CPlusPlus11)
       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
         << /*isConstexpr*/0 << /*isConstructor*/0
         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
     else
       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
     LLVM_FALLTHROUGH;
   case Builtin::BI__builtin_strcmp:
   case Builtin::BI__builtin_wcscmp:
   case Builtin::BI__builtin_strncmp:
   case Builtin::BI__builtin_wcsncmp:
   case Builtin::BI__builtin_memcmp:
   case Builtin::BI__builtin_wmemcmp: {
     LValue String1, String2;
private:
   }
   bool Error(const Expr *E) {
     return IntEval.Error(E);
   }
   bool Error(const Expr *E, diag::kind D) {
     return IntEval.Error(E, D);
   }
 
-  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
-    return Info.CCEDiag(E, D);
-  }
-
   // Returns true if visiting the RHS is necessary, false otherwise.
   bool VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
                          bool &SuppressRHSDiags);
 
   bool VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
                   const BinaryOperator *E, APValue &Result);
 
   void EvaluateExpr(const Expr *E, EvalResult &Result) {
if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
 
     // C++11 [expr.rel]p3:
     //   Pointers to void (after pointer conversions) can be compared, with a
     //   result defined as follows: If both pointers represent the same
     //   address or are both the null pointer value, the result is true if the
     //   operator is <= or >= and false otherwise; otherwise the result is
     //   unspecified.
     // We interpret this as applying to pointers to *cv* void.
-    if (LHSTy->isVoidPointerType() && LHSOffset != RHSOffset && IsRelational)
+    if (LHSTy->isVoidPointerType() && LHSOffset != RHSOffset && IsRelational) {
       Info.CCEDiag(E, diag::note_constexpr_void_comparison);
+      if (!Info.keepEvaluatingAfterNonConstexpr())
+        return false;
+    }
 
     // C++11 [expr.rel]p2:
     // - If two pointers point to non-static data members of the same object,
     //   or to subobjects or array elements fo such members, recursively, the
     //   pointer to the later declared member compares greater provided the
     //   two members have the same access control and provided their class is
     //   not a union.
     //   [...]
     // - Otherwise pointer comparisons are unspecified.
     if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && IsRelational) {
       bool WasArrayIndex;
       unsigned Mismatch = FindDesignatorMismatch(
           getType(LHSValue.Base), LHSDesignator, RHSDesignator, WasArrayIndex);
       // At the point where the designators diverge, the comparison has a
       // specified value if:
       //  - we are comparing array indices
       //  - we are comparing fields of a union, or fields with the same access
       // Otherwise, the result is unspecified and thus the comparison is not a
       // constant expression.
       if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() &&
           Mismatch < RHSDesignator.Entries.size()) {
         const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]);
         const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]);
-        if (!LF && !RF)
+        if (!LF && !RF) {
           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes);
-        else if (!LF)
+          if (!Info.keepEvaluatingAfterNonConstexpr())
+            return false;
+        } else if (!LF) {
           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
               << getAsBaseClass(LHSDesignator.Entries[Mismatch])
               << RF->getParent() << RF;
-        else if (!RF)
+          if (!Info.keepEvaluatingAfterNonConstexpr())
+            return false;
+        } else if (!RF) {
           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
               << getAsBaseClass(RHSDesignator.Entries[Mismatch])
               << LF->getParent() << LF;
-        else if (!LF->getParent()->isUnion() &&
-                 LF->getAccess() != RF->getAccess())
+          if (!Info.keepEvaluatingAfterNonConstexpr())
+            return false;
+        } else if (!LF->getParent()->isUnion() &&
+                   LF->getAccess() != RF->getAccess()) {
           Info.CCEDiag(E,
                        diag::note_constexpr_pointer_comparison_differing_access)
               << LF << LF->getAccess() << RF << RF->getAccess()
               << LF->getParent();
+          if (!Info.keepEvaluatingAfterNonConstexpr())
+            return false;
+        }
       }
     }
 
     // The comparison here must be unsigned, and performed with the same
     // width as the pointer.
     unsigned PtrSize = Info.Ctx.getTypeSize(LHSTy);
     uint64_t CompareLHS = LHSOffset.getQuantity();
     uint64_t CompareRHS = RHSOffset.getQuantity();
if (LHSTy->isMemberPointerType()) {
     if (!LHSValue.getDecl() || !RHSValue.getDecl()) {
       bool Equal = !LHSValue.getDecl() && !RHSValue.getDecl();
       return Success(Equal ? CCR::Equal : CCR::Nonequal, E);
     }
 
     //   Otherwise if either is a pointer to a virtual member function, the
     //   result is unspecified.
     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl()))
-      if (MD->isVirtual())
+      if (MD->isVirtual()) {
         Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
+        if (!Info.keepEvaluatingAfterNonConstexpr())
+          return false;
+      }
     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl()))
-      if (MD->isVirtual())
+      if (MD->isVirtual()) {
         Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
+        if (!Info.keepEvaluatingAfterNonConstexpr())
+          return false;
+      }
 
     //   Otherwise they compare equal if and only if they would refer to the
     //   same member of the same most derived object or the same subobject if
     //   they were dereferenced with a hypothetical object of the associated
     //   class type.
     bool Equal = LHSValue == RHSValue;
     return Success(Equal ? CCR::Equal : CCR::Nonequal, E);
   }
if (LHSTy->isPointerType() && RHSTy->isPointerType() &&
     SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
 
     // C++11 [expr.add]p6:
     //   Unless both pointers point to elements of the same array object, or
     //   one past the last element of the array object, the behavior is
     //   undefined.
     if (!LHSDesignator.Invalid && !RHSDesignator.Invalid &&
         !AreElementsOfSameArray(getType(LHSValue.Base), LHSDesignator,
-                                RHSDesignator))
+                                RHSDesignator)) {
       Info.CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array);
+      if (!Info.keepEvaluatingAfterNonConstexpr())
+        return false;
+    }
 
     QualType Type = E->getLHS()->getType();
     QualType ElementType = Type->getAs<PointerType>()->getPointeeType();
 
     CharUnits ElementSize;
     if (!HandleSizeof(Info, E->getExprLoc(), ElementType, ElementSize))
       return false;
 
if (!Result.isInt()) {
       return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
     }
 
     return Success(HandleIntToIntCast(Info, E, DestType, SrcType,
                                       Result.getInt()), E);
   }
 
   case CK_PointerToIntegral: {
-    CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
+    Info.CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
+    if (!Info.keepEvaluatingAfterNonConstexpr())
+      return false;
 
     LValue LV;
     if (!EvaluatePointer(SubExpr, LV, Info))
       return false;
 
     if (LV.getLValueBase()) {
       // Only allow based lvalue casts if they are lossless.
       // FIXME: Allow a larger integer size than the pointer size, and allow
if (E->getSubExpr()->getType()->isComplexIntegerType()) {
     ComplexValue LV;
     if (!EvaluateComplex(E->getSubExpr(), LV, Info))
       return false;
     if (!LV.isComplexInt())
       return Error(E);
     return Success(LV.getComplexIntImag(), E);
   }
 
-  VisitIgnoredValue(E->getSubExpr());
+  if (!VisitIgnoredValue(E->getSubExpr()))
+    return false;
   return Success(0, E);
 }
 
 bool IntExprEvaluator::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
   return Success(E->getPackLength(), E);
 }
 
 bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
   if (E->getSubExpr()->getType()->isAnyComplexType()) {
     ComplexValue CV;
     if (!EvaluateComplex(E->getSubExpr(), CV, Info))
       return false;
     Result = CV.FloatImag;
     return true;
   }
 
-  VisitIgnoredValue(E->getSubExpr());
+  if (!VisitIgnoredValue(E->getSubExpr()))
+    return false;
   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);
public:
 
   bool ZeroInitialization(const Expr *E) { return true; }
 
   bool VisitCastExpr(const CastExpr *E) {
     switch (E->getCastKind()) {
     default:
       return ExprEvaluatorBaseTy::VisitCastExpr(E);
     case CK_ToVoid:
-      VisitIgnoredValue(E->getSubExpr());
-      return true;
+      return VisitIgnoredValue(E->getSubExpr());
     }
   }
 
   bool VisitCallExpr(const CallExpr *E) {
     switch (E->getBuiltinCallee()) {
     default:
       return ExprEvaluatorBaseTy::VisitCallExpr(E);
     case Builtin::BI__assume:
if (E->isGLValue() || T->isFunctionType()) {
     Result = Value;
   } else if (T->isRecordType()) {
     LValue LV;
     APValue &Value = createTemporary(E, false, LV, *Info.CurrentCall);
     if (!EvaluateRecord(E, LV, Value, Info))
       return false;
     Result = Value;
   } else if (T->isVoidType()) {
-    if (!Info.getLangOpts().CPlusPlus11)
+    if (!Info.getLangOpts().CPlusPlus11) {
       Info.CCEDiag(E, diag::note_constexpr_nonliteral)
         << E->getType();
+      if (!Info.keepEvaluatingAfterNonConstexpr())
+        return false;
+    }
     if (!EvaluateVoid(E, Info))
       return false;
   } else if (T->isAtomicType()) {
     QualType Unqual = T.getAtomicUnqualifiedType();
     if (Unqual->isArrayType() || Unqual->isRecordType()) {
       LValue LV;
       APValue &Value = createTemporary(E, false, LV, *Info.CurrentCall);
       if (!EvaluateAtomic(E, &LV, Value, Info))

 /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
 /// constant folded, but discard the result.
 bool Expr::isEvaluatable(const ASTContext &Ctx, SideEffectsKind SEK) const {
   EvalResult Result;
   return EvaluateAsRValue(Result, Ctx) &&
          !hasUnacceptableSideEffect(Result, SEK);
 }
 
-APSInt Expr::EvaluateKnownConstInt(const ASTContext &Ctx,
-                    SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
+APSInt Expr::EvaluateKnownConstInt(const ASTContext &Ctx) const {
   EvalResult EvalResult;
-  EvalResult.Diag = Diag;
+
   bool Result = EvaluateAsRValue(EvalResult, Ctx);
   (void)Result;
   assert(Result && "Could not evaluate expression");
   assert(EvalResult.Val.isInt() && "Expression did not evaluate to integer");
 
   return EvalResult.Val.getInt();
 }
 
bool Expr::isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result,
   Expr::EvalStatus Status;
   SmallVector<PartialDiagnosticAt, 8> Diags;
   Status.Diag = &Diags;
   EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
 
   APValue Scratch;
   bool IsConstExpr = ::EvaluateAsRValue(Info, this, Result ? *Result : Scratch);
 
+  // Diags should always contain a message when the expression is determined to
+  // not be a constant expression, and should always be empty when the result
+  // _is_ a constant expression.  (Note: the above applies in
+  // EM_ConstantExpression mode, which we use here, but not in,
+  // e.g. EM_ConstantFold or others.)
+  assert(Diags.empty() == IsConstExpr);
+
   if (!Diags.empty()) {
-    IsConstExpr = false;
     if (Loc) *Loc = Diags[0].first;
-  } else if (!IsConstExpr) {
-    // FIXME: This shouldn't happen.
-    if (Loc) *Loc = getExprLoc();
   }
 
   return IsConstExpr;
 }
 
 bool Expr::EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,
                                     const FunctionDecl *Callee,
                                     ArrayRef<const Expr*> Args,
if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
     // of objects of non-literal types.
     Info.setEvaluatingDecl(This.getLValueBase(), Scratch);
     HandleConstructorCall(&VIE, This, Args, CD, Info, Scratch);
   } else {
     SourceLocation Loc = FD->getLocation();
     HandleFunctionCall(Loc, FD, (MD && MD->isInstance()) ? &This : nullptr,
                        Args, FD->getBody(), Info, Scratch, nullptr);
   }
-
+  // Note: the 'success' return value from the evaluation is not
+  // useful here: it's expected that it'll fail, due to argument
+  // values being missing. We just care if some diagnosable errors
+  // have been reported.
   return Diags.empty();
 }
 
 bool Expr::isPotentialConstantExprUnevaluated(Expr *E,
                                               const FunctionDecl *FD,
                                               SmallVectorImpl<
                                                 PartialDiagnosticAt> &Diags) {
   Expr::EvalStatus Status;
   Status.Diag = &Diags;
 
   EvalInfo Info(FD->getASTContext(), Status,
                 EvalInfo::EM_PotentialConstantExpressionUnevaluated);
 
   // Fabricate a call stack frame to give the arguments a plausible cover story.
   ArrayRef<const Expr*> Args;
   ArgVector ArgValues(0);
   bool Success = EvaluateArgs(Args, ArgValues, Info);
   (void)Success;
   assert(Success &&
          "Failed to set up arguments for potential constant evaluation");
   CallStackFrame Frame(Info, SourceLocation(), FD, nullptr, ArgValues.data());
 
   APValue ResultScratch;
   Evaluate(ResultScratch, Info, E);
+  // Note: the 'success' return value from the evaluation is not
+  // useful here: it's expected that it'll fail, due to argument
+  // values being missing. We just care if some diagnosable errors
+  // have been reported.
   return Diags.empty();
 }
 
 bool Expr::tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
                                  unsigned Type) const {
   if (!getType()->isPointerType())
     return false;
 
   Expr::EvalStatus Status;
   EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
   return tryEvaluateBuiltinObjectSize(this, Type, Info, Result);
 }