1 //===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Expr constant evaluator.
10 //
11 // Constant expression evaluation produces four main results:
12 //
13 //  * A success/failure flag indicating whether constant folding was successful.
14 //    This is the 'bool' return value used by most of the code in this file. A
15 //    'false' return value indicates that constant folding has failed, and any
16 //    appropriate diagnostic has already been produced.
17 //
18 //  * An evaluated result, valid only if constant folding has not failed.
19 //
20 //  * A flag indicating if evaluation encountered (unevaluated) side-effects.
21 //    These arise in cases such as (sideEffect(), 0) and (sideEffect() || 1),
22 //    where it is possible to determine the evaluated result regardless.
23 //
24 //  * A set of notes indicating why the evaluation was not a constant expression
25 //    (under the C++11 / C++1y rules only, at the moment), or, if folding failed
26 //    too, why the expression could not be folded.
27 //
28 // If we are checking for a potential constant expression, failure to constant
29 // fold a potential constant sub-expression will be indicated by a 'false'
30 // return value (the expression could not be folded) and no diagnostic (the
31 // expression is not necessarily non-constant).
32 //
33 //===----------------------------------------------------------------------===//
34 
35 #include "Interp/Context.h"
36 #include "Interp/Frame.h"
37 #include "Interp/State.h"
38 #include "clang/AST/APValue.h"
39 #include "clang/AST/ASTContext.h"
40 #include "clang/AST/ASTDiagnostic.h"
41 #include "clang/AST/ASTLambda.h"
42 #include "clang/AST/Attr.h"
43 #include "clang/AST/CXXInheritance.h"
44 #include "clang/AST/CharUnits.h"
45 #include "clang/AST/CurrentSourceLocExprScope.h"
46 #include "clang/AST/Expr.h"
47 #include "clang/AST/OSLog.h"
48 #include "clang/AST/OptionalDiagnostic.h"
49 #include "clang/AST/RecordLayout.h"
50 #include "clang/AST/StmtVisitor.h"
51 #include "clang/AST/TypeLoc.h"
52 #include "clang/Basic/Builtins.h"
53 #include "clang/Basic/FixedPoint.h"
54 #include "clang/Basic/TargetInfo.h"
55 #include "llvm/ADT/Optional.h"
56 #include "llvm/ADT/SmallBitVector.h"
57 #include "llvm/Support/SaveAndRestore.h"
58 #include "llvm/Support/raw_ostream.h"
59 #include <cstring>
60 #include <functional>
61 
62 #define DEBUG_TYPE "exprconstant"
63 
64 using namespace clang;
65 using llvm::APInt;
66 using llvm::APSInt;
67 using llvm::APFloat;
68 using llvm::Optional;
69 
70 namespace {
71   struct LValue;
72   class CallStackFrame;
73   class EvalInfo;
74 
75   using SourceLocExprScopeGuard =
76       CurrentSourceLocExprScope::SourceLocExprScopeGuard;
77 
78   static QualType getType(APValue::LValueBase B) {
79     if (!B) return QualType();
80     if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
81       // FIXME: It's unclear where we're supposed to take the type from, and
82       // this actually matters for arrays of unknown bound. Eg:
83       //
84       // extern int arr[]; void f() { extern int arr[3]; };
85       // constexpr int *p = &arr[1]; // valid?
86       //
87       // For now, we take the array bound from the most recent declaration.
88       for (auto *Redecl = cast<ValueDecl>(D->getMostRecentDecl()); Redecl;
89            Redecl = cast_or_null<ValueDecl>(Redecl->getPreviousDecl())) {
90         QualType T = Redecl->getType();
91         if (!T->isIncompleteArrayType())
92           return T;
93       }
94       return D->getType();
95     }
96 
97     if (B.is<TypeInfoLValue>())
98       return B.getTypeInfoType();
99 
100     if (B.is<DynamicAllocLValue>())
101       return B.getDynamicAllocType();
102 
103     const Expr *Base = B.get<const Expr*>();
104 
105     // For a materialized temporary, the type of the temporary we materialized
106     // may not be the type of the expression.
107     if (const MaterializeTemporaryExpr *MTE =
108             dyn_cast<MaterializeTemporaryExpr>(Base)) {
109       SmallVector<const Expr *, 2> CommaLHSs;
110       SmallVector<SubobjectAdjustment, 2> Adjustments;
111       const Expr *Temp = MTE->getSubExpr();
112       const Expr *Inner = Temp->skipRValueSubobjectAdjustments(CommaLHSs,
113                                                                Adjustments);
114       // Keep any cv-qualifiers from the reference if we generated a temporary
115       // for it directly. Otherwise use the type after adjustment.
116       if (!Adjustments.empty())
117         return Inner->getType();
118     }
119 
120     return Base->getType();
121   }
122 
123   /// Get an LValue path entry, which is known to not be an array index, as a
124   /// field declaration.
125   static const FieldDecl *getAsField(APValue::LValuePathEntry E) {
126     return dyn_cast_or_null<FieldDecl>(E.getAsBaseOrMember().getPointer());
127   }
128   /// Get an LValue path entry, which is known to not be an array index, as a
129   /// base class declaration.
130   static const CXXRecordDecl *getAsBaseClass(APValue::LValuePathEntry E) {
131     return dyn_cast_or_null<CXXRecordDecl>(E.getAsBaseOrMember().getPointer());
132   }
133   /// Determine whether this LValue path entry for a base class names a virtual
134   /// base class.
135   static bool isVirtualBaseClass(APValue::LValuePathEntry E) {
136     return E.getAsBaseOrMember().getInt();
137   }
138 
139   /// Given an expression, determine the type used to store the result of
140   /// evaluating that expression.
141   static QualType getStorageType(const ASTContext &Ctx, const Expr *E) {
142     if (E->isRValue())
143       return E->getType();
144     return Ctx.getLValueReferenceType(E->getType());
145   }
146 
147   /// Given a CallExpr, try to get the alloc_size attribute. May return null.
148   static const AllocSizeAttr *getAllocSizeAttr(const CallExpr *CE) {
149     const FunctionDecl *Callee = CE->getDirectCallee();
150     return Callee ? Callee->getAttr<AllocSizeAttr>() : nullptr;
151   }
152 
153   /// Attempts to unwrap a CallExpr (with an alloc_size attribute) from an Expr.
154   /// This will look through a single cast.
155   ///
156   /// Returns null if we couldn't unwrap a function with alloc_size.
157   static const CallExpr *tryUnwrapAllocSizeCall(const Expr *E) {
158     if (!E->getType()->isPointerType())
159       return nullptr;
160 
161     E = E->IgnoreParens();
162     // If we're doing a variable assignment from e.g. malloc(N), there will
163     // probably be a cast of some kind. In exotic cases, we might also see a
164     // top-level ExprWithCleanups. Ignore them either way.
165     if (const auto *FE = dyn_cast<FullExpr>(E))
166       E = FE->getSubExpr()->IgnoreParens();
167 
168     if (const auto *Cast = dyn_cast<CastExpr>(E))
169       E = Cast->getSubExpr()->IgnoreParens();
170 
171     if (const auto *CE = dyn_cast<CallExpr>(E))
172       return getAllocSizeAttr(CE) ? CE : nullptr;
173     return nullptr;
174   }
175 
176   /// Determines whether or not the given Base contains a call to a function
177   /// with the alloc_size attribute.
178   static bool isBaseAnAllocSizeCall(APValue::LValueBase Base) {
179     const auto *E = Base.dyn_cast<const Expr *>();
180     return E && E->getType()->isPointerType() && tryUnwrapAllocSizeCall(E);
181   }
182 
183   /// The bound to claim that an array of unknown bound has.
184   /// The value in MostDerivedArraySize is undefined in this case. So, set it
185   /// to an arbitrary value that's likely to loudly break things if it's used.
186   static const uint64_t AssumedSizeForUnsizedArray =
187       std::numeric_limits<uint64_t>::max() / 2;
188 
189   /// Determines if an LValue with the given LValueBase will have an unsized
190   /// array in its designator.
191   /// Find the path length and type of the most-derived subobject in the given
192   /// path, and find the size of the containing array, if any.
193   static unsigned
194   findMostDerivedSubobject(ASTContext &Ctx, APValue::LValueBase Base,
195                            ArrayRef<APValue::LValuePathEntry> Path,
196                            uint64_t &ArraySize, QualType &Type, bool &IsArray,
197                            bool &FirstEntryIsUnsizedArray) {
198     // This only accepts LValueBases from APValues, and APValues don't support
199     // arrays that lack size info.
200     assert(!isBaseAnAllocSizeCall(Base) &&
201            "Unsized arrays shouldn't appear here");
202     unsigned MostDerivedLength = 0;
203     Type = getType(Base);
204 
205     for (unsigned I = 0, N = Path.size(); I != N; ++I) {
206       if (Type->isArrayType()) {
207         const ArrayType *AT = Ctx.getAsArrayType(Type);
208         Type = AT->getElementType();
209         MostDerivedLength = I + 1;
210         IsArray = true;
211 
212         if (auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
213           ArraySize = CAT->getSize().getZExtValue();
214         } else {
215           assert(I == 0 && "unexpected unsized array designator");
216           FirstEntryIsUnsizedArray = true;
217           ArraySize = AssumedSizeForUnsizedArray;
218         }
219       } else if (Type->isAnyComplexType()) {
220         const ComplexType *CT = Type->castAs<ComplexType>();
221         Type = CT->getElementType();
222         ArraySize = 2;
223         MostDerivedLength = I + 1;
224         IsArray = true;
225       } else if (const FieldDecl *FD = getAsField(Path[I])) {
226         Type = FD->getType();
227         ArraySize = 0;
228         MostDerivedLength = I + 1;
229         IsArray = false;
230       } else {
231         // Path[I] describes a base class.
232         ArraySize = 0;
233         IsArray = false;
234       }
235     }
236     return MostDerivedLength;
237   }
238 
239   /// A path from a glvalue to a subobject of that glvalue.
240   struct SubobjectDesignator {
241     /// True if the subobject was named in a manner not supported by C++11. Such
242     /// lvalues can still be folded, but they are not core constant expressions
243     /// and we cannot perform lvalue-to-rvalue conversions on them.
244     unsigned Invalid : 1;
245 
246     /// Is this a pointer one past the end of an object?
247     unsigned IsOnePastTheEnd : 1;
248 
249     /// Indicator of whether the first entry is an unsized array.
250     unsigned FirstEntryIsAnUnsizedArray : 1;
251 
252     /// Indicator of whether the most-derived object is an array element.
253     unsigned MostDerivedIsArrayElement : 1;
254 
255     /// The length of the path to the most-derived object of which this is a
256     /// subobject.
257     unsigned MostDerivedPathLength : 28;
258 
259     /// The size of the array of which the most-derived object is an element.
260     /// This will always be 0 if the most-derived object is not an array
261     /// element. 0 is not an indicator of whether or not the most-derived object
262     /// is an array, however, because 0-length arrays are allowed.
263     ///
264     /// If the current array is an unsized array, the value of this is
265     /// undefined.
266     uint64_t MostDerivedArraySize;
267 
268     /// The type of the most derived object referred to by this address.
269     QualType MostDerivedType;
270 
271     typedef APValue::LValuePathEntry PathEntry;
272 
273     /// The entries on the path from the glvalue to the designated subobject.
274     SmallVector<PathEntry, 8> Entries;
275 
276     SubobjectDesignator() : Invalid(true) {}
277 
278     explicit SubobjectDesignator(QualType T)
279         : Invalid(false), IsOnePastTheEnd(false),
280           FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
281           MostDerivedPathLength(0), MostDerivedArraySize(0),
282           MostDerivedType(T) {}
283 
284     SubobjectDesignator(ASTContext &Ctx, const APValue &V)
285         : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false),
286           FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
287           MostDerivedPathLength(0), MostDerivedArraySize(0) {
288       assert(V.isLValue() && "Non-LValue used to make an LValue designator?");
289       if (!Invalid) {
290         IsOnePastTheEnd = V.isLValueOnePastTheEnd();
291         ArrayRef<PathEntry> VEntries = V.getLValuePath();
292         Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());
293         if (V.getLValueBase()) {
294           bool IsArray = false;
295           bool FirstIsUnsizedArray = false;
296           MostDerivedPathLength = findMostDerivedSubobject(
297               Ctx, V.getLValueBase(), V.getLValuePath(), MostDerivedArraySize,
298               MostDerivedType, IsArray, FirstIsUnsizedArray);
299           MostDerivedIsArrayElement = IsArray;
300           FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
301         }
302       }
303     }
304 
305     void truncate(ASTContext &Ctx, APValue::LValueBase Base,
306                   unsigned NewLength) {
307       if (Invalid)
308         return;
309 
310       assert(Base && "cannot truncate path for null pointer");
311       assert(NewLength <= Entries.size() && "not a truncation");
312 
313       if (NewLength == Entries.size())
314         return;
315       Entries.resize(NewLength);
316 
317       bool IsArray = false;
318       bool FirstIsUnsizedArray = false;
319       MostDerivedPathLength = findMostDerivedSubobject(
320           Ctx, Base, Entries, MostDerivedArraySize, MostDerivedType, IsArray,
321           FirstIsUnsizedArray);
322       MostDerivedIsArrayElement = IsArray;
323       FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
324     }
325 
326     void setInvalid() {
327       Invalid = true;
328       Entries.clear();
329     }
330 
331     /// Determine whether the most derived subobject is an array without a
332     /// known bound.
333     bool isMostDerivedAnUnsizedArray() const {
334       assert(!Invalid && "Calling this makes no sense on invalid designators");
335       return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;
336     }
337 
338     /// Determine what the most derived array's size is. Results in an assertion
339     /// failure if the most derived array lacks a size.
340     uint64_t getMostDerivedArraySize() const {
341       assert(!isMostDerivedAnUnsizedArray() && "Unsized array has no size");
342       return MostDerivedArraySize;
343     }
344 
345     /// Determine whether this is a one-past-the-end pointer.
346     bool isOnePastTheEnd() const {
347       assert(!Invalid);
348       if (IsOnePastTheEnd)
349         return true;
350       if (!isMostDerivedAnUnsizedArray() && MostDerivedIsArrayElement &&
351           Entries[MostDerivedPathLength - 1].getAsArrayIndex() ==
352               MostDerivedArraySize)
353         return true;
354       return false;
355     }
356 
357     /// Get the range of valid index adjustments in the form
358     ///   {maximum value that can be subtracted from this pointer,
359     ///    maximum value that can be added to this pointer}
360     std::pair<uint64_t, uint64_t> validIndexAdjustments() {
361       if (Invalid || isMostDerivedAnUnsizedArray())
362         return {0, 0};
363 
364       // [expr.add]p4: For the purposes of these operators, a pointer to a
365       // nonarray object behaves the same as a pointer to the first element of
366       // an array of length one with the type of the object as its element type.
367       bool IsArray = MostDerivedPathLength == Entries.size() &&
368                      MostDerivedIsArrayElement;
369       uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex()
370                                     : (uint64_t)IsOnePastTheEnd;
371       uint64_t ArraySize =
372           IsArray ? getMostDerivedArraySize() : (uint64_t)1;
373       return {ArrayIndex, ArraySize - ArrayIndex};
374     }
375 
376     /// Check that this refers to a valid subobject.
377     bool isValidSubobject() const {
378       if (Invalid)
379         return false;
380       return !isOnePastTheEnd();
381     }
382     /// Check that this refers to a valid subobject, and if not, produce a
383     /// relevant diagnostic and set the designator as invalid.
384     bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK);
385 
386     /// Get the type of the designated object.
387     QualType getType(ASTContext &Ctx) const {
388       assert(!Invalid && "invalid designator has no subobject type");
389       return MostDerivedPathLength == Entries.size()
390                  ? MostDerivedType
391                  : Ctx.getRecordType(getAsBaseClass(Entries.back()));
392     }
393 
394     /// Update this designator to refer to the first element within this array.
395     void addArrayUnchecked(const ConstantArrayType *CAT) {
396       Entries.push_back(PathEntry::ArrayIndex(0));
397 
398       // This is a most-derived object.
399       MostDerivedType = CAT->getElementType();
400       MostDerivedIsArrayElement = true;
401       MostDerivedArraySize = CAT->getSize().getZExtValue();
402       MostDerivedPathLength = Entries.size();
403     }
404     /// Update this designator to refer to the first element within the array of
405     /// elements of type T. This is an array of unknown size.
406     void addUnsizedArrayUnchecked(QualType ElemTy) {
407       Entries.push_back(PathEntry::ArrayIndex(0));
408 
409       MostDerivedType = ElemTy;
410       MostDerivedIsArrayElement = true;
411       // The value in MostDerivedArraySize is undefined in this case. So, set it
412       // to an arbitrary value that's likely to loudly break things if it's
413       // used.
414       MostDerivedArraySize = AssumedSizeForUnsizedArray;
415       MostDerivedPathLength = Entries.size();
416     }
417     /// Update this designator to refer to the given base or member of this
418     /// object.
419     void addDeclUnchecked(const Decl *D, bool Virtual = false) {
420       Entries.push_back(APValue::BaseOrMemberType(D, Virtual));
421 
422       // If this isn't a base class, it's a new most-derived object.
423       if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
424         MostDerivedType = FD->getType();
425         MostDerivedIsArrayElement = false;
426         MostDerivedArraySize = 0;
427         MostDerivedPathLength = Entries.size();
428       }
429     }
430     /// Update this designator to refer to the given complex component.
431     void addComplexUnchecked(QualType EltTy, bool Imag) {
432       Entries.push_back(PathEntry::ArrayIndex(Imag));
433 
434       // This is technically a most-derived object, though in practice this
435       // is unlikely to matter.
436       MostDerivedType = EltTy;
437       MostDerivedIsArrayElement = true;
438       MostDerivedArraySize = 2;
439       MostDerivedPathLength = Entries.size();
440     }
441     void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, const Expr *E);
442     void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
443                                    const APSInt &N);
444     /// Add N to the address of this subobject.
445     void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
446       if (Invalid || !N) return;
447       uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
448       if (isMostDerivedAnUnsizedArray()) {
449         diagnoseUnsizedArrayPointerArithmetic(Info, E);
450         // Can't verify -- trust that the user is doing the right thing (or if
451         // not, trust that the caller will catch the bad behavior).
452         // FIXME: Should we reject if this overflows, at least?
453         Entries.back() = PathEntry::ArrayIndex(
454             Entries.back().getAsArrayIndex() + TruncatedN);
455         return;
456       }
457 
458       // [expr.add]p4: For the purposes of these operators, a pointer to a
459       // nonarray object behaves the same as a pointer to the first element of
460       // an array of length one with the type of the object as its element type.
461       bool IsArray = MostDerivedPathLength == Entries.size() &&
462                      MostDerivedIsArrayElement;
463       uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex()
464                                     : (uint64_t)IsOnePastTheEnd;
465       uint64_t ArraySize =
466           IsArray ? getMostDerivedArraySize() : (uint64_t)1;
467 
468       if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
469         // Calculate the actual index in a wide enough type, so we can include
470         // it in the note.
471         N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
472         (llvm::APInt&)N += ArrayIndex;
473         assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index");
474         diagnosePointerArithmetic(Info, E, N);
475         setInvalid();
476         return;
477       }
478 
479       ArrayIndex += TruncatedN;
480       assert(ArrayIndex <= ArraySize &&
481              "bounds check succeeded for out-of-bounds index");
482 
483       if (IsArray)
484         Entries.back() = PathEntry::ArrayIndex(ArrayIndex);
485       else
486         IsOnePastTheEnd = (ArrayIndex != 0);
487     }
488   };
489 
490   /// A stack frame in the constexpr call stack.
491   class CallStackFrame : public interp::Frame {
492   public:
493     EvalInfo &Info;
494 
495     /// Parent - The caller of this stack frame.
496     CallStackFrame *Caller;
497 
498     /// Callee - The function which was called.
499     const FunctionDecl *Callee;
500 
501     /// This - The binding for the this pointer in this call, if any.
502     const LValue *This;
503 
504     /// Arguments - Parameter bindings for this function call, indexed by
505     /// parameters' function scope indices.
506     APValue *Arguments;
507 
508     /// Source location information about the default argument or default
509     /// initializer expression we're evaluating, if any.
510     CurrentSourceLocExprScope CurSourceLocExprScope;
511 
512     // Note that we intentionally use std::map here so that references to
513     // values are stable.
514     typedef std::pair<const void *, unsigned> MapKeyTy;
515     typedef std::map<MapKeyTy, APValue> MapTy;
516     /// Temporaries - Temporary lvalues materialized within this stack frame.
517     MapTy Temporaries;
518 
519     /// CallLoc - The location of the call expression for this call.
520     SourceLocation CallLoc;
521 
522     /// Index - The call index of this call.
523     unsigned Index;
524 
525     /// The stack of integers for tracking version numbers for temporaries.
526     SmallVector<unsigned, 2> TempVersionStack = {1};
527     unsigned CurTempVersion = TempVersionStack.back();
528 
529     unsigned getTempVersion() const { return TempVersionStack.back(); }
530 
531     void pushTempVersion() {
532       TempVersionStack.push_back(++CurTempVersion);
533     }
534 
535     void popTempVersion() {
536       TempVersionStack.pop_back();
537     }
538 
539     // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact
540     // on the overall stack usage of deeply-recursing constexpr evaluations.
541     // (We should cache this map rather than recomputing it repeatedly.)
542     // But let's try this and see how it goes; we can look into caching the map
543     // as a later change.
544 
545     /// LambdaCaptureFields - Mapping from captured variables/this to
546     /// corresponding data members in the closure class.
547     llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
548     FieldDecl *LambdaThisCaptureField;
549 
550     CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
551                    const FunctionDecl *Callee, const LValue *This,
552                    APValue *Arguments);
553     ~CallStackFrame();
554 
555     // Return the temporary for Key whose version number is Version.
556     APValue *getTemporary(const void *Key, unsigned Version) {
557       MapKeyTy KV(Key, Version);
558       auto LB = Temporaries.lower_bound(KV);
559       if (LB != Temporaries.end() && LB->first == KV)
560         return &LB->second;
561       // Pair (Key,Version) wasn't found in the map. Check that no elements
562       // in the map have 'Key' as their key.
563       assert((LB == Temporaries.end() || LB->first.first != Key) &&
564              (LB == Temporaries.begin() || std::prev(LB)->first.first != Key) &&
565              "Element with key 'Key' found in map");
566       return nullptr;
567     }
568 
569     // Return the current temporary for Key in the map.
570     APValue *getCurrentTemporary(const void *Key) {
571       auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
572       if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
573         return &std::prev(UB)->second;
574       return nullptr;
575     }
576 
577     // Return the version number of the current temporary for Key.
578     unsigned getCurrentTemporaryVersion(const void *Key) const {
579       auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
580       if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
581         return std::prev(UB)->first.second;
582       return 0;
583     }
584 
585     /// Allocate storage for an object of type T in this stack frame.
586     /// Populates LV with a handle to the created object. Key identifies
587     /// the temporary within the stack frame, and must not be reused without
588     /// bumping the temporary version number.
589     template<typename KeyT>
590     APValue &createTemporary(const KeyT *Key, QualType T,
591                              bool IsLifetimeExtended, LValue &LV);
592 
593     void describe(llvm::raw_ostream &OS) override;
594 
595     Frame *getCaller() const override { return Caller; }
596     SourceLocation getCallLocation() const override { return CallLoc; }
597     const FunctionDecl *getCallee() const override { return Callee; }
598 
599     bool isStdFunction() const {
600       for (const DeclContext *DC = Callee; DC; DC = DC->getParent())
601         if (DC->isStdNamespace())
602           return true;
603       return false;
604     }
605   };
606 
607   /// Temporarily override 'this'.
608   class ThisOverrideRAII {
609   public:
610     ThisOverrideRAII(CallStackFrame &Frame, const LValue *NewThis, bool Enable)
611         : Frame(Frame), OldThis(Frame.This) {
612       if (Enable)
613         Frame.This = NewThis;
614     }
615     ~ThisOverrideRAII() {
616       Frame.This = OldThis;
617     }
618   private:
619     CallStackFrame &Frame;
620     const LValue *OldThis;
621   };
622 }
623 
624 static bool HandleDestruction(EvalInfo &Info, const Expr *E,
625                               const LValue &This, QualType ThisType);
626 static bool HandleDestruction(EvalInfo &Info, SourceLocation Loc,
627                               APValue::LValueBase LVBase, APValue &Value,
628                               QualType T);
629 
630 namespace {
631   /// A cleanup, and a flag indicating whether it is lifetime-extended.
632   class Cleanup {
633     llvm::PointerIntPair<APValue*, 1, bool> Value;
634     APValue::LValueBase Base;
635     QualType T;
636 
637   public:
638     Cleanup(APValue *Val, APValue::LValueBase Base, QualType T,
639             bool IsLifetimeExtended)
640         : Value(Val, IsLifetimeExtended), Base(Base), T(T) {}
641 
642     bool isLifetimeExtended() const { return Value.getInt(); }
643     bool endLifetime(EvalInfo &Info, bool RunDestructors) {
644       if (RunDestructors) {
645         SourceLocation Loc;
646         if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
647           Loc = VD->getLocation();
648         else if (const Expr *E = Base.dyn_cast<const Expr*>())
649           Loc = E->getExprLoc();
650         return HandleDestruction(Info, Loc, Base, *Value.getPointer(), T);
651       }
652       *Value.getPointer() = APValue();
653       return true;
654     }
655 
656     bool hasSideEffect() {
657       return T.isDestructedType();
658     }
659   };
660 
661   /// A reference to an object whose construction we are currently evaluating.
662   struct ObjectUnderConstruction {
663     APValue::LValueBase Base;
664     ArrayRef<APValue::LValuePathEntry> Path;
665     friend bool operator==(const ObjectUnderConstruction &LHS,
666                            const ObjectUnderConstruction &RHS) {
667       return LHS.Base == RHS.Base && LHS.Path == RHS.Path;
668     }
669     friend llvm::hash_code hash_value(const ObjectUnderConstruction &Obj) {
670       return llvm::hash_combine(Obj.Base, Obj.Path);
671     }
672   };
673   enum class ConstructionPhase {
674     None,
675     Bases,
676     AfterBases,
677     Destroying,
678     DestroyingBases
679   };
680 }
681 
682 namespace llvm {
683 template<> struct DenseMapInfo<ObjectUnderConstruction> {
684   using Base = DenseMapInfo<APValue::LValueBase>;
685   static ObjectUnderConstruction getEmptyKey() {
686     return {Base::getEmptyKey(), {}}; }
687   static ObjectUnderConstruction getTombstoneKey() {
688     return {Base::getTombstoneKey(), {}};
689   }
690   static unsigned getHashValue(const ObjectUnderConstruction &Object) {
691     return hash_value(Object);
692   }
693   static bool isEqual(const ObjectUnderConstruction &LHS,
694                       const ObjectUnderConstruction &RHS) {
695     return LHS == RHS;
696   }
697 };
698 }
699 
700 namespace {
701   /// A dynamically-allocated heap object.
702   struct DynAlloc {
703     /// The value of this heap-allocated object.
704     APValue Value;
705     /// The allocating expression; used for diagnostics. Either a CXXNewExpr
706     /// or a CallExpr (the latter is for direct calls to operator new inside
707     /// std::allocator<T>::allocate).
708     const Expr *AllocExpr = nullptr;
709 
710     enum Kind {
711       New,
712       ArrayNew,
713       StdAllocator
714     };
715 
716     /// Get the kind of the allocation. This must match between allocation
717     /// and deallocation.
718     Kind getKind() const {
719       if (auto *NE = dyn_cast<CXXNewExpr>(AllocExpr))
720         return NE->isArray() ? ArrayNew : New;
721       assert(isa<CallExpr>(AllocExpr));
722       return StdAllocator;
723     }
724   };
725 
726   struct DynAllocOrder {
727     bool operator()(DynamicAllocLValue L, DynamicAllocLValue R) const {
728       return L.getIndex() < R.getIndex();
729     }
730   };
731 
732   /// EvalInfo - This is a private struct used by the evaluator to capture
733   /// information about a subexpression as it is folded.  It retains information
734   /// about the AST context, but also maintains information about the folded
735   /// expression.
736   ///
737   /// If an expression could be evaluated, it is still possible it is not a C
738   /// "integer constant expression" or constant expression.  If not, this struct
739   /// captures information about how and why not.
740   ///
741   /// One bit of information passed *into* the request for constant folding
742   /// indicates whether the subexpression is "evaluated" or not according to C
743   /// rules.  For example, the RHS of (0 && foo()) is not evaluated.  We can
744   /// evaluate the expression regardless of what the RHS is, but C only allows
745   /// certain things in certain situations.
746   class EvalInfo : public interp::State {
747   public:
748     ASTContext &Ctx;
749 
750     /// EvalStatus - Contains information about the evaluation.
751     Expr::EvalStatus &EvalStatus;
752 
753     /// CurrentCall - The top of the constexpr call stack.
754     CallStackFrame *CurrentCall;
755 
756     /// CallStackDepth - The number of calls in the call stack right now.
757     unsigned CallStackDepth;
758 
759     /// NextCallIndex - The next call index to assign.
760     unsigned NextCallIndex;
761 
762     /// StepsLeft - The remaining number of evaluation steps we're permitted
763     /// to perform. This is essentially a limit for the number of statements
764     /// we will evaluate.
765     unsigned StepsLeft;
766 
767     /// Enable the experimental new constant interpreter. If an expression is
768     /// not supported by the interpreter, an error is triggered.
769     bool EnableNewConstInterp;
770 
771     /// BottomFrame - The frame in which evaluation started. This must be
772     /// initialized after CurrentCall and CallStackDepth.
773     CallStackFrame BottomFrame;
774 
775     /// A stack of values whose lifetimes end at the end of some surrounding
776     /// evaluation frame.
777     llvm::SmallVector<Cleanup, 16> CleanupStack;
778 
779     /// EvaluatingDecl - This is the declaration whose initializer is being
780     /// evaluated, if any.
781     APValue::LValueBase EvaluatingDecl;
782 
783     enum class EvaluatingDeclKind {
784       None,
785       /// We're evaluating the construction of EvaluatingDecl.
786       Ctor,
787       /// We're evaluating the destruction of EvaluatingDecl.
788       Dtor,
789     };
790     EvaluatingDeclKind IsEvaluatingDecl = EvaluatingDeclKind::None;
791 
792     /// EvaluatingDeclValue - This is the value being constructed for the
793     /// declaration whose initializer is being evaluated, if any.
794     APValue *EvaluatingDeclValue;
795 
796     /// Set of objects that are currently being constructed.
797     llvm::DenseMap<ObjectUnderConstruction, ConstructionPhase>
798         ObjectsUnderConstruction;
799 
800     /// Current heap allocations, along with the location where each was
801     /// allocated. We use std::map here because we need stable addresses
802     /// for the stored APValues.
803     std::map<DynamicAllocLValue, DynAlloc, DynAllocOrder> HeapAllocs;
804 
805     /// The number of heap allocations performed so far in this evaluation.
806     unsigned NumHeapAllocs = 0;
807 
808     struct EvaluatingConstructorRAII {
809       EvalInfo &EI;
810       ObjectUnderConstruction Object;
811       bool DidInsert;
812       EvaluatingConstructorRAII(EvalInfo &EI, ObjectUnderConstruction Object,
813                                 bool HasBases)
814           : EI(EI), Object(Object) {
815         DidInsert =
816             EI.ObjectsUnderConstruction
817                 .insert({Object, HasBases ? ConstructionPhase::Bases
818                                           : ConstructionPhase::AfterBases})
819                 .second;
820       }
821       void finishedConstructingBases() {
822         EI.ObjectsUnderConstruction[Object] = ConstructionPhase::AfterBases;
823       }
824       ~EvaluatingConstructorRAII() {
825         if (DidInsert) EI.ObjectsUnderConstruction.erase(Object);
826       }
827     };
828 
829     struct EvaluatingDestructorRAII {
830       EvalInfo &EI;
831       ObjectUnderConstruction Object;
832       bool DidInsert;
833       EvaluatingDestructorRAII(EvalInfo &EI, ObjectUnderConstruction Object)
834           : EI(EI), Object(Object) {
835         DidInsert = EI.ObjectsUnderConstruction
836                         .insert({Object, ConstructionPhase::Destroying})
837                         .second;
838       }
839       void startedDestroyingBases() {
840         EI.ObjectsUnderConstruction[Object] =
841             ConstructionPhase::DestroyingBases;
842       }
843       ~EvaluatingDestructorRAII() {
844         if (DidInsert)
845           EI.ObjectsUnderConstruction.erase(Object);
846       }
847     };
848 
849     ConstructionPhase
850     isEvaluatingCtorDtor(APValue::LValueBase Base,
851                          ArrayRef<APValue::LValuePathEntry> Path) {
852       return ObjectsUnderConstruction.lookup({Base, Path});
853     }
854 
855     /// If we're currently speculatively evaluating, the outermost call stack
856     /// depth at which we can mutate state, otherwise 0.
857     unsigned SpeculativeEvaluationDepth = 0;
858 
859     /// The current array initialization index, if we're performing array
860     /// initialization.
861     uint64_t ArrayInitIndex = -1;
862 
863     /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further
864     /// notes attached to it will also be stored, otherwise they will not be.
865     bool HasActiveDiagnostic;
866 
867     /// Have we emitted a diagnostic explaining why we couldn't constant
868     /// fold (not just why it's not strictly a constant expression)?
869     bool HasFoldFailureDiagnostic;
870 
871     /// Whether or not we're in a context where the front end requires a
872     /// constant value.
873     bool InConstantContext;
874 
875     /// Whether we're checking that an expression is a potential constant
876     /// expression. If so, do not fail on constructs that could become constant
877     /// later on (such as a use of an undefined global).
878     bool CheckingPotentialConstantExpression = false;
879 
880     /// Whether we're checking for an expression that has undefined behavior.
881     /// If so, we will produce warnings if we encounter an operation that is
882     /// always undefined.
883     bool CheckingForUndefinedBehavior = false;
884 
885     enum EvaluationMode {
886       /// Evaluate as a constant expression. Stop if we find that the expression
887       /// is not a constant expression.
888       EM_ConstantExpression,
889 
890       /// Evaluate as a constant expression. Stop if we find that the expression
891       /// is not a constant expression. Some expressions can be retried in the
892       /// optimizer if we don't constant fold them here, but in an unevaluated
893       /// context we try to fold them immediately since the optimizer never
894       /// gets a chance to look at it.
895       EM_ConstantExpressionUnevaluated,
896 
897       /// Fold the expression to a constant. Stop if we hit a side-effect that
898       /// we can't model.
899       EM_ConstantFold,
900 
901       /// Evaluate in any way we know how. Don't worry about side-effects that
902       /// can't be modeled.
903       EM_IgnoreSideEffects,
904     } EvalMode;
905 
906     /// Are we checking whether the expression is a potential constant
907     /// expression?
908     bool checkingPotentialConstantExpression() const override  {
909       return CheckingPotentialConstantExpression;
910     }
911 
912     /// Are we checking an expression for overflow?
913     // FIXME: We should check for any kind of undefined or suspicious behavior
914     // in such constructs, not just overflow.
915     bool checkingForUndefinedBehavior() const override {
916       return CheckingForUndefinedBehavior;
917     }
918 
919     EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
920         : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
921           CallStackDepth(0), NextCallIndex(1),
922           StepsLeft(C.getLangOpts().ConstexprStepLimit),
923           EnableNewConstInterp(C.getLangOpts().EnableNewConstInterp),
924           BottomFrame(*this, SourceLocation(), nullptr, nullptr, nullptr),
925           EvaluatingDecl((const ValueDecl *)nullptr),
926           EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
927           HasFoldFailureDiagnostic(false), InConstantContext(false),
928           EvalMode(Mode) {}
929 
930     ~EvalInfo() {
931       discardCleanups();
932     }
933 
934     void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value,
935                            EvaluatingDeclKind EDK = EvaluatingDeclKind::Ctor) {
936       EvaluatingDecl = Base;
937       IsEvaluatingDecl = EDK;
938       EvaluatingDeclValue = &Value;
939     }
940 
941     bool CheckCallLimit(SourceLocation Loc) {
942       // Don't perform any constexpr calls (other than the call we're checking)
943       // when checking a potential constant expression.
944       if (checkingPotentialConstantExpression() && CallStackDepth > 1)
945         return false;
946       if (NextCallIndex == 0) {
947         // NextCallIndex has wrapped around.
948         FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);
949         return false;
950       }
951       if (CallStackDepth <= getLangOpts().ConstexprCallDepth)
952         return true;
953       FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded)
954         << getLangOpts().ConstexprCallDepth;
955       return false;
956     }
957 
958     std::pair<CallStackFrame *, unsigned>
959     getCallFrameAndDepth(unsigned CallIndex) {
960       assert(CallIndex && "no call index in getCallFrameAndDepth");
961       // We will eventually hit BottomFrame, which has Index 1, so Frame can't
962       // be null in this loop.
963       unsigned Depth = CallStackDepth;
964       CallStackFrame *Frame = CurrentCall;
965       while (Frame->Index > CallIndex) {
966         Frame = Frame->Caller;
967         --Depth;
968       }
969       if (Frame->Index == CallIndex)
970         return {Frame, Depth};
971       return {nullptr, 0};
972     }
973 
974     bool nextStep(const Stmt *S) {
975       if (!StepsLeft) {
976         FFDiag(S->getBeginLoc(), diag::note_constexpr_step_limit_exceeded);
977         return false;
978       }
979       --StepsLeft;
980       return true;
981     }
982 
983     APValue *createHeapAlloc(const Expr *E, QualType T, LValue &LV);
984 
985     Optional<DynAlloc*> lookupDynamicAlloc(DynamicAllocLValue DA) {
986       Optional<DynAlloc*> Result;
987       auto It = HeapAllocs.find(DA);
988       if (It != HeapAllocs.end())
989         Result = &It->second;
990       return Result;
991     }
992 
993     /// Information about a stack frame for std::allocator<T>::[de]allocate.
994     struct StdAllocatorCaller {
995       unsigned FrameIndex;
996       QualType ElemType;
997       explicit operator bool() const { return FrameIndex != 0; };
998     };
999 
1000     StdAllocatorCaller getStdAllocatorCaller(StringRef FnName) const {
1001       for (const CallStackFrame *Call = CurrentCall; Call != &BottomFrame;
1002            Call = Call->Caller) {
1003         const auto *MD = dyn_cast_or_null<CXXMethodDecl>(Call->Callee);
1004         if (!MD)
1005           continue;
1006         const IdentifierInfo *FnII = MD->getIdentifier();
1007         if (!FnII || !FnII->isStr(FnName))
1008           continue;
1009 
1010         const auto *CTSD =
1011             dyn_cast<ClassTemplateSpecializationDecl>(MD->getParent());
1012         if (!CTSD)
1013           continue;
1014 
1015         const IdentifierInfo *ClassII = CTSD->getIdentifier();
1016         const TemplateArgumentList &TAL = CTSD->getTemplateArgs();
1017         if (CTSD->isInStdNamespace() && ClassII &&
1018             ClassII->isStr("allocator") && TAL.size() >= 1 &&
1019             TAL[0].getKind() == TemplateArgument::Type)
1020           return {Call->Index, TAL[0].getAsType()};
1021       }
1022 
1023       return {};
1024     }
1025 
1026     void performLifetimeExtension() {
1027       // Disable the cleanups for lifetime-extended temporaries.
1028       CleanupStack.erase(
1029           std::remove_if(CleanupStack.begin(), CleanupStack.end(),
1030                          [](Cleanup &C) { return C.isLifetimeExtended(); }),
1031           CleanupStack.end());
1032      }
1033 
1034     /// Throw away any remaining cleanups at the end of evaluation. If any
1035     /// cleanups would have had a side-effect, note that as an unmodeled
1036     /// side-effect and return false. Otherwise, return true.
1037     bool discardCleanups() {
1038       for (Cleanup &C : CleanupStack) {
1039         if (C.hasSideEffect() && !noteSideEffect()) {
1040           CleanupStack.clear();
1041           return false;
1042         }
1043       }
1044       CleanupStack.clear();
1045       return true;
1046     }
1047 
1048   private:
1049     interp::Frame *getCurrentFrame() override { return CurrentCall; }
1050     const interp::Frame *getBottomFrame() const override { return &BottomFrame; }
1051 
1052     bool hasActiveDiagnostic() override { return HasActiveDiagnostic; }
1053     void setActiveDiagnostic(bool Flag) override { HasActiveDiagnostic = Flag; }
1054 
1055     void setFoldFailureDiagnostic(bool Flag) override {
1056       HasFoldFailureDiagnostic = Flag;
1057     }
1058 
1059     Expr::EvalStatus &getEvalStatus() const override { return EvalStatus; }
1060 
1061     ASTContext &getCtx() const override { return Ctx; }
1062 
1063     // If we have a prior diagnostic, it will be noting that the expression
1064     // isn't a constant expression. This diagnostic is more important,
1065     // unless we require this evaluation to produce a constant expression.
1066     //
1067     // FIXME: We might want to show both diagnostics to the user in
1068     // EM_ConstantFold mode.
1069     bool hasPriorDiagnostic() override {
1070       if (!EvalStatus.Diag->empty()) {
1071         switch (EvalMode) {
1072         case EM_ConstantFold:
1073         case EM_IgnoreSideEffects:
1074           if (!HasFoldFailureDiagnostic)
1075             break;
1076           // We've already failed to fold something. Keep that diagnostic.
1077           LLVM_FALLTHROUGH;
1078         case EM_ConstantExpression:
1079         case EM_ConstantExpressionUnevaluated:
1080           setActiveDiagnostic(false);
1081           return true;
1082         }
1083       }
1084       return false;
1085     }
1086 
1087     unsigned getCallStackDepth() override { return CallStackDepth; }
1088 
1089   public:
1090     /// Should we continue evaluation after encountering a side-effect that we
1091     /// couldn't model?
1092     bool keepEvaluatingAfterSideEffect() {
1093       switch (EvalMode) {
1094       case EM_IgnoreSideEffects:
1095         return true;
1096 
1097       case EM_ConstantExpression:
1098       case EM_ConstantExpressionUnevaluated:
1099       case EM_ConstantFold:
1100         // By default, assume any side effect might be valid in some other
1101         // evaluation of this expression from a different context.
1102         return checkingPotentialConstantExpression() ||
1103                checkingForUndefinedBehavior();
1104       }
1105       llvm_unreachable("Missed EvalMode case");
1106     }
1107 
1108     /// Note that we have had a side-effect, and determine whether we should
1109     /// keep evaluating.
1110     bool noteSideEffect() {
1111       EvalStatus.HasSideEffects = true;
1112       return keepEvaluatingAfterSideEffect();
1113     }
1114 
1115     /// Should we continue evaluation after encountering undefined behavior?
1116     bool keepEvaluatingAfterUndefinedBehavior() {
1117       switch (EvalMode) {
1118       case EM_IgnoreSideEffects:
1119       case EM_ConstantFold:
1120         return true;
1121 
1122       case EM_ConstantExpression:
1123       case EM_ConstantExpressionUnevaluated:
1124         return checkingForUndefinedBehavior();
1125       }
1126       llvm_unreachable("Missed EvalMode case");
1127     }
1128 
1129     /// Note that we hit something that was technically undefined behavior, but
1130     /// that we can evaluate past it (such as signed overflow or floating-point
1131     /// division by zero.)
1132     bool noteUndefinedBehavior() override {
1133       EvalStatus.HasUndefinedBehavior = true;
1134       return keepEvaluatingAfterUndefinedBehavior();
1135     }
1136 
1137     /// Should we continue evaluation as much as possible after encountering a
1138     /// construct which can't be reduced to a value?
1139     bool keepEvaluatingAfterFailure() const override {
1140       if (!StepsLeft)
1141         return false;
1142 
1143       switch (EvalMode) {
1144       case EM_ConstantExpression:
1145       case EM_ConstantExpressionUnevaluated:
1146       case EM_ConstantFold:
1147       case EM_IgnoreSideEffects:
1148         return checkingPotentialConstantExpression() ||
1149                checkingForUndefinedBehavior();
1150       }
1151       llvm_unreachable("Missed EvalMode case");
1152     }
1153 
1154     /// Notes that we failed to evaluate an expression that other expressions
1155     /// directly depend on, and determine if we should keep evaluating. This
1156     /// should only be called if we actually intend to keep evaluating.
1157     ///
1158     /// Call noteSideEffect() instead if we may be able to ignore the value that
1159     /// we failed to evaluate, e.g. if we failed to evaluate Foo() in:
1160     ///
1161     /// (Foo(), 1)      // use noteSideEffect
1162     /// (Foo() || true) // use noteSideEffect
1163     /// Foo() + 1       // use noteFailure
1164     LLVM_NODISCARD bool noteFailure() {
1165       // Failure when evaluating some expression often means there is some
1166       // subexpression whose evaluation was skipped. Therefore, (because we
1167       // don't track whether we skipped an expression when unwinding after an
1168       // evaluation failure) every evaluation failure that bubbles up from a
1169       // subexpression implies that a side-effect has potentially happened. We
1170       // skip setting the HasSideEffects flag to true until we decide to
1171       // continue evaluating after that point, which happens here.
1172       bool KeepGoing = keepEvaluatingAfterFailure();
1173       EvalStatus.HasSideEffects |= KeepGoing;
1174       return KeepGoing;
1175     }
1176 
1177     class ArrayInitLoopIndex {
1178       EvalInfo &Info;
1179       uint64_t OuterIndex;
1180 
1181     public:
1182       ArrayInitLoopIndex(EvalInfo &Info)
1183           : Info(Info), OuterIndex(Info.ArrayInitIndex) {
1184         Info.ArrayInitIndex = 0;
1185       }
1186       ~ArrayInitLoopIndex() { Info.ArrayInitIndex = OuterIndex; }
1187 
1188       operator uint64_t&() { return Info.ArrayInitIndex; }
1189     };
1190   };
1191 
1192   /// Object used to treat all foldable expressions as constant expressions.
1193   struct FoldConstant {
1194     EvalInfo &Info;
1195     bool Enabled;
1196     bool HadNoPriorDiags;
1197     EvalInfo::EvaluationMode OldMode;
1198 
1199     explicit FoldConstant(EvalInfo &Info, bool Enabled)
1200       : Info(Info),
1201         Enabled(Enabled),
1202         HadNoPriorDiags(Info.EvalStatus.Diag &&
1203                         Info.EvalStatus.Diag->empty() &&
1204                         !Info.EvalStatus.HasSideEffects),
1205         OldMode(Info.EvalMode) {
1206       if (Enabled)
1207         Info.EvalMode = EvalInfo::EM_ConstantFold;
1208     }
1209     void keepDiagnostics() { Enabled = false; }
1210     ~FoldConstant() {
1211       if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
1212           !Info.EvalStatus.HasSideEffects)
1213         Info.EvalStatus.Diag->clear();
1214       Info.EvalMode = OldMode;
1215     }
1216   };
1217 
1218   /// RAII object used to set the current evaluation mode to ignore
1219   /// side-effects.
1220   struct IgnoreSideEffectsRAII {
1221     EvalInfo &Info;
1222     EvalInfo::EvaluationMode OldMode;
1223     explicit IgnoreSideEffectsRAII(EvalInfo &Info)
1224         : Info(Info), OldMode(Info.EvalMode) {
1225       Info.EvalMode = EvalInfo::EM_IgnoreSideEffects;
1226     }
1227 
1228     ~IgnoreSideEffectsRAII() { Info.EvalMode = OldMode; }
1229   };
1230 
1231   /// RAII object used to optionally suppress diagnostics and side-effects from
1232   /// a speculative evaluation.
1233   class SpeculativeEvaluationRAII {
1234     EvalInfo *Info = nullptr;
1235     Expr::EvalStatus OldStatus;
1236     unsigned OldSpeculativeEvaluationDepth;
1237 
1238     void moveFromAndCancel(SpeculativeEvaluationRAII &&Other) {
1239       Info = Other.Info;
1240       OldStatus = Other.OldStatus;
1241       OldSpeculativeEvaluationDepth = Other.OldSpeculativeEvaluationDepth;
1242       Other.Info = nullptr;
1243     }
1244 
1245     void maybeRestoreState() {
1246       if (!Info)
1247         return;
1248 
1249       Info->EvalStatus = OldStatus;
1250       Info->SpeculativeEvaluationDepth = OldSpeculativeEvaluationDepth;
1251     }
1252 
1253   public:
1254     SpeculativeEvaluationRAII() = default;
1255 
1256     SpeculativeEvaluationRAII(
1257         EvalInfo &Info, SmallVectorImpl<PartialDiagnosticAt> *NewDiag = nullptr)
1258         : Info(&Info), OldStatus(Info.EvalStatus),
1259           OldSpeculativeEvaluationDepth(Info.SpeculativeEvaluationDepth) {
1260       Info.EvalStatus.Diag = NewDiag;
1261       Info.SpeculativeEvaluationDepth = Info.CallStackDepth + 1;
1262     }
1263 
1264     SpeculativeEvaluationRAII(const SpeculativeEvaluationRAII &Other) = delete;
1265     SpeculativeEvaluationRAII(SpeculativeEvaluationRAII &&Other) {
1266       moveFromAndCancel(std::move(Other));
1267     }
1268 
1269     SpeculativeEvaluationRAII &operator=(SpeculativeEvaluationRAII &&Other) {
1270       maybeRestoreState();
1271       moveFromAndCancel(std::move(Other));
1272       return *this;
1273     }
1274 
1275     ~SpeculativeEvaluationRAII() { maybeRestoreState(); }
1276   };
1277 
1278   /// RAII object wrapping a full-expression or block scope, and handling
1279   /// the ending of the lifetime of temporaries created within it.
1280   template<bool IsFullExpression>
1281   class ScopeRAII {
1282     EvalInfo &Info;
1283     unsigned OldStackSize;
1284   public:
1285     ScopeRAII(EvalInfo &Info)
1286         : Info(Info), OldStackSize(Info.CleanupStack.size()) {
1287       // Push a new temporary version. This is needed to distinguish between
1288       // temporaries created in different iterations of a loop.
1289       Info.CurrentCall->pushTempVersion();
1290     }
1291     bool destroy(bool RunDestructors = true) {
1292       bool OK = cleanup(Info, RunDestructors, OldStackSize);
1293       OldStackSize = -1U;
1294       return OK;
1295     }
1296     ~ScopeRAII() {
1297       if (OldStackSize != -1U)
1298         destroy(false);
1299       // Body moved to a static method to encourage the compiler to inline away
1300       // instances of this class.
1301       Info.CurrentCall->popTempVersion();
1302     }
1303   private:
1304     static bool cleanup(EvalInfo &Info, bool RunDestructors,
1305                         unsigned OldStackSize) {
1306       assert(OldStackSize <= Info.CleanupStack.size() &&
1307              "running cleanups out of order?");
1308 
1309       // Run all cleanups for a block scope, and non-lifetime-extended cleanups
1310       // for a full-expression scope.
1311       bool Success = true;
1312       for (unsigned I = Info.CleanupStack.size(); I > OldStackSize; --I) {
1313         if (!(IsFullExpression &&
1314               Info.CleanupStack[I - 1].isLifetimeExtended())) {
1315           if (!Info.CleanupStack[I - 1].endLifetime(Info, RunDestructors)) {
1316             Success = false;
1317             break;
1318           }
1319         }
1320       }
1321 
1322       // Compact lifetime-extended cleanups.
1323       auto NewEnd = Info.CleanupStack.begin() + OldStackSize;
1324       if (IsFullExpression)
1325         NewEnd =
1326             std::remove_if(NewEnd, Info.CleanupStack.end(),
1327                            [](Cleanup &C) { return !C.isLifetimeExtended(); });
1328       Info.CleanupStack.erase(NewEnd, Info.CleanupStack.end());
1329       return Success;
1330     }
1331   };
1332   typedef ScopeRAII<false> BlockScopeRAII;
1333   typedef ScopeRAII<true> FullExpressionRAII;
1334 }
1335 
1336 bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
1337                                          CheckSubobjectKind CSK) {
1338   if (Invalid)
1339     return false;
1340   if (isOnePastTheEnd()) {
1341     Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
1342       << CSK;
1343     setInvalid();
1344     return false;
1345   }
1346   // Note, we do not diagnose if isMostDerivedAnUnsizedArray(), because there
1347   // must actually be at least one array element; even a VLA cannot have a
1348   // bound of zero. And if our index is nonzero, we already had a CCEDiag.
1349   return true;
1350 }
1351 
1352 void SubobjectDesignator::diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info,
1353                                                                 const Expr *E) {
1354   Info.CCEDiag(E, diag::note_constexpr_unsized_array_indexed);
1355   // Do not set the designator as invalid: we can represent this situation,
1356   // and correct handling of __builtin_object_size requires us to do so.
1357 }
1358 
1359 void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
1360                                                     const Expr *E,
1361                                                     const APSInt &N) {
1362   // If we're complaining, we must be able to statically determine the size of
1363   // the most derived array.
1364   if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)
1365     Info.CCEDiag(E, diag::note_constexpr_array_index)
1366       << N << /*array*/ 0
1367       << static_cast<unsigned>(getMostDerivedArraySize());
1368   else
1369     Info.CCEDiag(E, diag::note_constexpr_array_index)
1370       << N << /*non-array*/ 1;
1371   setInvalid();
1372 }
1373 
1374 CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
1375                                const FunctionDecl *Callee, const LValue *This,
1376                                APValue *Arguments)
1377     : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This),
1378       Arguments(Arguments), CallLoc(CallLoc), Index(Info.NextCallIndex++) {
1379   Info.CurrentCall = this;
1380   ++Info.CallStackDepth;
1381 }
1382 
1383 CallStackFrame::~CallStackFrame() {
1384   assert(Info.CurrentCall == this && "calls retired out of order");
1385   --Info.CallStackDepth;
1386   Info.CurrentCall = Caller;
1387 }
1388 
1389 static bool isRead(AccessKinds AK) {
1390   return AK == AK_Read || AK == AK_ReadObjectRepresentation;
1391 }
1392 
1393 static bool isModification(AccessKinds AK) {
1394   switch (AK) {
1395   case AK_Read:
1396   case AK_ReadObjectRepresentation:
1397   case AK_MemberCall:
1398   case AK_DynamicCast:
1399   case AK_TypeId:
1400     return false;
1401   case AK_Assign:
1402   case AK_Increment:
1403   case AK_Decrement:
1404   case AK_Construct:
1405   case AK_Destroy:
1406     return true;
1407   }
1408   llvm_unreachable("unknown access kind");
1409 }
1410 
1411 static bool isAnyAccess(AccessKinds AK) {
1412   return isRead(AK) || isModification(AK);
1413 }
1414 
1415 /// Is this an access per the C++ definition?
1416 static bool isFormalAccess(AccessKinds AK) {
1417   return isAnyAccess(AK) && AK != AK_Construct && AK != AK_Destroy;
1418 }
1419 
1420 namespace {
1421   struct ComplexValue {
1422   private:
1423     bool IsInt;
1424 
1425   public:
1426     APSInt IntReal, IntImag;
1427     APFloat FloatReal, FloatImag;
1428 
1429     ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
1430 
1431     void makeComplexFloat() { IsInt = false; }
1432     bool isComplexFloat() const { return !IsInt; }
1433     APFloat &getComplexFloatReal() { return FloatReal; }
1434     APFloat &getComplexFloatImag() { return FloatImag; }
1435 
1436     void makeComplexInt() { IsInt = true; }
1437     bool isComplexInt() const { return IsInt; }
1438     APSInt &getComplexIntReal() { return IntReal; }
1439     APSInt &getComplexIntImag() { return IntImag; }
1440 
1441     void moveInto(APValue &v) const {
1442       if (isComplexFloat())
1443         v = APValue(FloatReal, FloatImag);
1444       else
1445         v = APValue(IntReal, IntImag);
1446     }
1447     void setFrom(const APValue &v) {
1448       assert(v.isComplexFloat() || v.isComplexInt());
1449       if (v.isComplexFloat()) {
1450         makeComplexFloat();
1451         FloatReal = v.getComplexFloatReal();
1452         FloatImag = v.getComplexFloatImag();
1453       } else {
1454         makeComplexInt();
1455         IntReal = v.getComplexIntReal();
1456         IntImag = v.getComplexIntImag();
1457       }
1458     }
1459   };
1460 
1461   struct LValue {
1462     APValue::LValueBase Base;
1463     CharUnits Offset;
1464     SubobjectDesignator Designator;
1465     bool IsNullPtr : 1;
1466     bool InvalidBase : 1;
1467 
1468     const APValue::LValueBase getLValueBase() const { return Base; }
1469     CharUnits &getLValueOffset() { return Offset; }
1470     const CharUnits &getLValueOffset() const { return Offset; }
1471     SubobjectDesignator &getLValueDesignator() { return Designator; }
1472     const SubobjectDesignator &getLValueDesignator() const { return Designator;}
1473     bool isNullPointer() const { return IsNullPtr;}
1474 
1475     unsigned getLValueCallIndex() const { return Base.getCallIndex(); }
1476     unsigned getLValueVersion() const { return Base.getVersion(); }
1477 
1478     void moveInto(APValue &V) const {
1479       if (Designator.Invalid)
1480         V = APValue(Base, Offset, APValue::NoLValuePath(), IsNullPtr);
1481       else {
1482         assert(!InvalidBase && "APValues can't handle invalid LValue bases");
1483         V = APValue(Base, Offset, Designator.Entries,
1484                     Designator.IsOnePastTheEnd, IsNullPtr);
1485       }
1486     }
1487     void setFrom(ASTContext &Ctx, const APValue &V) {
1488       assert(V.isLValue() && "Setting LValue from a non-LValue?");
1489       Base = V.getLValueBase();
1490       Offset = V.getLValueOffset();
1491       InvalidBase = false;
1492       Designator = SubobjectDesignator(Ctx, V);
1493       IsNullPtr = V.isNullPointer();
1494     }
1495 
1496     void set(APValue::LValueBase B, bool BInvalid = false) {
1497 #ifndef NDEBUG
1498       // We only allow a few types of invalid bases. Enforce that here.
1499       if (BInvalid) {
1500         const auto *E = B.get<const Expr *>();
1501         assert((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&
1502                "Unexpected type of invalid base");
1503       }
1504 #endif
1505 
1506       Base = B;
1507       Offset = CharUnits::fromQuantity(0);
1508       InvalidBase = BInvalid;
1509       Designator = SubobjectDesignator(getType(B));
1510       IsNullPtr = false;
1511     }
1512 
1513     void setNull(ASTContext &Ctx, QualType PointerTy) {
1514       Base = (Expr *)nullptr;
1515       Offset =
1516           CharUnits::fromQuantity(Ctx.getTargetNullPointerValue(PointerTy));
1517       InvalidBase = false;
1518       Designator = SubobjectDesignator(PointerTy->getPointeeType());
1519       IsNullPtr = true;
1520     }
1521 
1522     void setInvalid(APValue::LValueBase B, unsigned I = 0) {
1523       set(B, true);
1524     }
1525 
1526     std::string toString(ASTContext &Ctx, QualType T) const {
1527       APValue Printable;
1528       moveInto(Printable);
1529       return Printable.getAsString(Ctx, T);
1530     }
1531 
1532   private:
1533     // Check that this LValue is not based on a null pointer. If it is, produce
1534     // a diagnostic and mark the designator as invalid.
1535     template <typename GenDiagType>
1536     bool checkNullPointerDiagnosingWith(const GenDiagType &GenDiag) {
1537       if (Designator.Invalid)
1538         return false;
1539       if (IsNullPtr) {
1540         GenDiag();
1541         Designator.setInvalid();
1542         return false;
1543       }
1544       return true;
1545     }
1546 
1547   public:
1548     bool checkNullPointer(EvalInfo &Info, const Expr *E,
1549                           CheckSubobjectKind CSK) {
1550       return checkNullPointerDiagnosingWith([&Info, E, CSK] {
1551         Info.CCEDiag(E, diag::note_constexpr_null_subobject) << CSK;
1552       });
1553     }
1554 
1555     bool checkNullPointerForFoldAccess(EvalInfo &Info, const Expr *E,
1556                                        AccessKinds AK) {
1557       return checkNullPointerDiagnosingWith([&Info, E, AK] {
1558         Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
1559       });
1560     }
1561 
1562     // Check this LValue refers to an object. If not, set the designator to be
1563     // invalid and emit a diagnostic.
1564     bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {
1565       return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
1566              Designator.checkSubobject(Info, E, CSK);
1567     }
1568 
1569     void addDecl(EvalInfo &Info, const Expr *E,
1570                  const Decl *D, bool Virtual = false) {
1571       if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
1572         Designator.addDeclUnchecked(D, Virtual);
1573     }
1574     void addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) {
1575       if (!Designator.Entries.empty()) {
1576         Info.CCEDiag(E, diag::note_constexpr_unsupported_unsized_array);
1577         Designator.setInvalid();
1578         return;
1579       }
1580       if (checkSubobject(Info, E, CSK_ArrayToPointer)) {
1581         assert(getType(Base)->isPointerType() || getType(Base)->isArrayType());
1582         Designator.FirstEntryIsAnUnsizedArray = true;
1583         Designator.addUnsizedArrayUnchecked(ElemTy);
1584       }
1585     }
1586     void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
1587       if (checkSubobject(Info, E, CSK_ArrayToPointer))
1588         Designator.addArrayUnchecked(CAT);
1589     }
1590     void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
1591       if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
1592         Designator.addComplexUnchecked(EltTy, Imag);
1593     }
1594     void clearIsNullPointer() {
1595       IsNullPtr = false;
1596     }
1597     void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
1598                               const APSInt &Index, CharUnits ElementSize) {
1599       // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB,
1600       // but we're not required to diagnose it and it's valid in C++.)
1601       if (!Index)
1602         return;
1603 
1604       // Compute the new offset in the appropriate width, wrapping at 64 bits.
1605       // FIXME: When compiling for a 32-bit target, we should use 32-bit
1606       // offsets.
1607       uint64_t Offset64 = Offset.getQuantity();
1608       uint64_t ElemSize64 = ElementSize.getQuantity();
1609       uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
1610       Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64);
1611 
1612       if (checkNullPointer(Info, E, CSK_ArrayIndex))
1613         Designator.adjustIndex(Info, E, Index);
1614       clearIsNullPointer();
1615     }
1616     void adjustOffset(CharUnits N) {
1617       Offset += N;
1618       if (N.getQuantity())
1619         clearIsNullPointer();
1620     }
1621   };
1622 
1623   struct MemberPtr {
1624     MemberPtr() {}
1625     explicit MemberPtr(const ValueDecl *Decl) :
1626       DeclAndIsDerivedMember(Decl, false), Path() {}
1627 
1628     /// The member or (direct or indirect) field referred to by this member
1629     /// pointer, or 0 if this is a null member pointer.
1630     const ValueDecl *getDecl() const {
1631       return DeclAndIsDerivedMember.getPointer();
1632     }
1633     /// Is this actually a member of some type derived from the relevant class?
1634     bool isDerivedMember() const {
1635       return DeclAndIsDerivedMember.getInt();
1636     }
1637     /// Get the class which the declaration actually lives in.
1638     const CXXRecordDecl *getContainingRecord() const {
1639       return cast<CXXRecordDecl>(
1640           DeclAndIsDerivedMember.getPointer()->getDeclContext());
1641     }
1642 
1643     void moveInto(APValue &V) const {
1644       V = APValue(getDecl(), isDerivedMember(), Path);
1645     }
1646     void setFrom(const APValue &V) {
1647       assert(V.isMemberPointer());
1648       DeclAndIsDerivedMember.setPointer(V.getMemberPointerDecl());
1649       DeclAndIsDerivedMember.setInt(V.isMemberPointerToDerivedMember());
1650       Path.clear();
1651       ArrayRef<const CXXRecordDecl*> P = V.getMemberPointerPath();
1652       Path.insert(Path.end(), P.begin(), P.end());
1653     }
1654 
1655     /// DeclAndIsDerivedMember - The member declaration, and a flag indicating
1656     /// whether the member is a member of some class derived from the class type
1657     /// of the member pointer.
1658     llvm::PointerIntPair<const ValueDecl*, 1, bool> DeclAndIsDerivedMember;
1659     /// Path - The path of base/derived classes from the member declaration's
1660     /// class (exclusive) to the class type of the member pointer (inclusive).
1661     SmallVector<const CXXRecordDecl*, 4> Path;
1662 
1663     /// Perform a cast towards the class of the Decl (either up or down the
1664     /// hierarchy).
1665     bool castBack(const CXXRecordDecl *Class) {
1666       assert(!Path.empty());
1667       const CXXRecordDecl *Expected;
1668       if (Path.size() >= 2)
1669         Expected = Path[Path.size() - 2];
1670       else
1671         Expected = getContainingRecord();
1672       if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) {
1673         // C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*),
1674         // if B does not contain the original member and is not a base or
1675         // derived class of the class containing the original member, the result
1676         // of the cast is undefined.
1677         // C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to
1678         // (D::*). We consider that to be a language defect.
1679         return false;
1680       }
1681       Path.pop_back();
1682       return true;
1683     }
1684     /// Perform a base-to-derived member pointer cast.
1685     bool castToDerived(const CXXRecordDecl *Derived) {
1686       if (!getDecl())
1687         return true;
1688       if (!isDerivedMember()) {
1689         Path.push_back(Derived);
1690         return true;
1691       }
1692       if (!castBack(Derived))
1693         return false;
1694       if (Path.empty())
1695         DeclAndIsDerivedMember.setInt(false);
1696       return true;
1697     }
1698     /// Perform a derived-to-base member pointer cast.
1699     bool castToBase(const CXXRecordDecl *Base) {
1700       if (!getDecl())
1701         return true;
1702       if (Path.empty())
1703         DeclAndIsDerivedMember.setInt(true);
1704       if (isDerivedMember()) {
1705         Path.push_back(Base);
1706         return true;
1707       }
1708       return castBack(Base);
1709     }
1710   };
1711 
1712   /// Compare two member pointers, which are assumed to be of the same type.
1713   static bool operator==(const MemberPtr &LHS, const MemberPtr &RHS) {
1714     if (!LHS.getDecl() || !RHS.getDecl())
1715       return !LHS.getDecl() && !RHS.getDecl();
1716     if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl())
1717       return false;
1718     return LHS.Path == RHS.Path;
1719   }
1720 }
1721 
1722 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E);
1723 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info,
1724                             const LValue &This, const Expr *E,
1725                             bool AllowNonLiteralTypes = false);
1726 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
1727                            bool InvalidBaseOK = false);
1728 static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info,
1729                             bool InvalidBaseOK = false);
1730 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
1731                                   EvalInfo &Info);
1732 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info);
1733 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
1734 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
1735                                     EvalInfo &Info);
1736 static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
1737 static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info);
1738 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
1739                            EvalInfo &Info);
1740 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result);
1741 
1742 /// Evaluate an integer or fixed point expression into an APResult.
1743 static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
1744                                         EvalInfo &Info);
1745 
1746 /// Evaluate only a fixed point expression into an APResult.
1747 static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
1748                                EvalInfo &Info);
1749 
1750 //===----------------------------------------------------------------------===//
1751 // Misc utilities
1752 //===----------------------------------------------------------------------===//
1753 
1754 /// Negate an APSInt in place, converting it to a signed form if necessary, and
1755 /// preserving its value (by extending by up to one bit as needed).
1756 static void negateAsSigned(APSInt &Int) {
1757   if (Int.isUnsigned() || Int.isMinSignedValue()) {
1758     Int = Int.extend(Int.getBitWidth() + 1);
1759     Int.setIsSigned(true);
1760   }
1761   Int = -Int;
1762 }
1763 
1764 template<typename KeyT>
1765 APValue &CallStackFrame::createTemporary(const KeyT *Key, QualType T,
1766                                          bool IsLifetimeExtended, LValue &LV) {
1767   unsigned Version = getTempVersion();
1768   APValue::LValueBase Base(Key, Index, Version);
1769   LV.set(Base);
1770   APValue &Result = Temporaries[MapKeyTy(Key, Version)];
1771   assert(Result.isAbsent() && "temporary created multiple times");
1772 
1773   // If we're creating a temporary immediately in the operand of a speculative
1774   // evaluation, don't register a cleanup to be run outside the speculative
1775   // evaluation context, since we won't actually be able to initialize this
1776   // object.
1777   if (Index <= Info.SpeculativeEvaluationDepth) {
1778     if (T.isDestructedType())
1779       Info.noteSideEffect();
1780   } else {
1781     Info.CleanupStack.push_back(Cleanup(&Result, Base, T, IsLifetimeExtended));
1782   }
1783   return Result;
1784 }
1785 
1786 APValue *EvalInfo::createHeapAlloc(const Expr *E, QualType T, LValue &LV) {
1787   if (NumHeapAllocs > DynamicAllocLValue::getMaxIndex()) {
1788     FFDiag(E, diag::note_constexpr_heap_alloc_limit_exceeded);
1789     return nullptr;
1790   }
1791 
1792   DynamicAllocLValue DA(NumHeapAllocs++);
1793   LV.set(APValue::LValueBase::getDynamicAlloc(DA, T));
1794   auto Result = HeapAllocs.emplace(std::piecewise_construct,
1795                                    std::forward_as_tuple(DA), std::tuple<>());
1796   assert(Result.second && "reused a heap alloc index?");
1797   Result.first->second.AllocExpr = E;
1798   return &Result.first->second.Value;
1799 }
1800 
1801 /// Produce a string describing the given constexpr call.
1802 void CallStackFrame::describe(raw_ostream &Out) {
1803   unsigned ArgIndex = 0;
1804   bool IsMemberCall = isa<CXXMethodDecl>(Callee) &&
1805                       !isa<CXXConstructorDecl>(Callee) &&
1806                       cast<CXXMethodDecl>(Callee)->isInstance();
1807 
1808   if (!IsMemberCall)
1809     Out << *Callee << '(';
1810 
1811   if (This && IsMemberCall) {
1812     APValue Val;
1813     This->moveInto(Val);
1814     Val.printPretty(Out, Info.Ctx,
1815                     This->Designator.MostDerivedType);
1816     // FIXME: Add parens around Val if needed.
1817     Out << "->" << *Callee << '(';
1818     IsMemberCall = false;
1819   }
1820 
1821   for (FunctionDecl::param_const_iterator I = Callee->param_begin(),
1822        E = Callee->param_end(); I != E; ++I, ++ArgIndex) {
1823     if (ArgIndex > (unsigned)IsMemberCall)
1824       Out << ", ";
1825 
1826     const ParmVarDecl *Param = *I;
1827     const APValue &Arg = Arguments[ArgIndex];
1828     Arg.printPretty(Out, Info.Ctx, Param->getType());
1829 
1830     if (ArgIndex == 0 && IsMemberCall)
1831       Out << "->" << *Callee << '(';
1832   }
1833 
1834   Out << ')';
1835 }
1836 
1837 /// Evaluate an expression to see if it had side-effects, and discard its
1838 /// result.
1839 /// \return \c true if the caller should keep evaluating.
1840 static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
1841   APValue Scratch;
1842   if (!Evaluate(Scratch, Info, E))
1843     // We don't need the value, but we might have skipped a side effect here.
1844     return Info.noteSideEffect();
1845   return true;
1846 }
1847 
1848 /// Should this call expression be treated as a string literal?
1849 static bool IsStringLiteralCall(const CallExpr *E) {
1850   unsigned Builtin = E->getBuiltinCallee();
1851   return (Builtin == Builtin::BI__builtin___CFStringMakeConstantString ||
1852           Builtin == Builtin::BI__builtin___NSStringMakeConstantString);
1853 }
1854 
1855 static bool IsGlobalLValue(APValue::LValueBase B) {
1856   // C++11 [expr.const]p3 An address constant expression is a prvalue core
1857   // constant expression of pointer type that evaluates to...
1858 
1859   // ... a null pointer value, or a prvalue core constant expression of type
1860   // std::nullptr_t.
1861   if (!B) return true;
1862 
1863   if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
1864     // ... the address of an object with static storage duration,
1865     if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1866       return VD->hasGlobalStorage();
1867     // ... the address of a function,
1868     return isa<FunctionDecl>(D);
1869   }
1870 
1871   if (B.is<TypeInfoLValue>() || B.is<DynamicAllocLValue>())
1872     return true;
1873 
1874   const Expr *E = B.get<const Expr*>();
1875   switch (E->getStmtClass()) {
1876   default:
1877     return false;
1878   case Expr::CompoundLiteralExprClass: {
1879     const CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
1880     return CLE->isFileScope() && CLE->isLValue();
1881   }
1882   case Expr::MaterializeTemporaryExprClass:
1883     // A materialized temporary might have been lifetime-extended to static
1884     // storage duration.
1885     return cast<MaterializeTemporaryExpr>(E)->getStorageDuration() == SD_Static;
1886   // A string literal has static storage duration.
1887   case Expr::StringLiteralClass:
1888   case Expr::PredefinedExprClass:
1889   case Expr::ObjCStringLiteralClass:
1890   case Expr::ObjCEncodeExprClass:
1891   case Expr::CXXUuidofExprClass:
1892     return true;
1893   case Expr::ObjCBoxedExprClass:
1894     return cast<ObjCBoxedExpr>(E)->isExpressibleAsConstantInitializer();
1895   case Expr::CallExprClass:
1896     return IsStringLiteralCall(cast<CallExpr>(E));
1897   // For GCC compatibility, &&label has static storage duration.
1898   case Expr::AddrLabelExprClass:
1899     return true;
1900   // A Block literal expression may be used as the initialization value for
1901   // Block variables at global or local static scope.
1902   case Expr::BlockExprClass:
1903     return !cast<BlockExpr>(E)->getBlockDecl()->hasCaptures();
1904   case Expr::ImplicitValueInitExprClass:
1905     // FIXME:
1906     // We can never form an lvalue with an implicit value initialization as its
1907     // base through expression evaluation, so these only appear in one case: the
1908     // implicit variable declaration we invent when checking whether a constexpr
1909     // constructor can produce a constant expression. We must assume that such
1910     // an expression might be a global lvalue.
1911     return true;
1912   }
1913 }
1914 
1915 static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) {
1916   return LVal.Base.dyn_cast<const ValueDecl*>();
1917 }
1918 
1919 static bool IsLiteralLValue(const LValue &Value) {
1920   if (Value.getLValueCallIndex())
1921     return false;
1922   const Expr *E = Value.Base.dyn_cast<const Expr*>();
1923   return E && !isa<MaterializeTemporaryExpr>(E);
1924 }
1925 
1926 static bool IsWeakLValue(const LValue &Value) {
1927   const ValueDecl *Decl = GetLValueBaseDecl(Value);
1928   return Decl && Decl->isWeak();
1929 }
1930 
1931 static bool isZeroSized(const LValue &Value) {
1932   const ValueDecl *Decl = GetLValueBaseDecl(Value);
1933   if (Decl && isa<VarDecl>(Decl)) {
1934     QualType Ty = Decl->getType();
1935     if (Ty->isArrayType())
1936       return Ty->isIncompleteType() ||
1937              Decl->getASTContext().getTypeSize(Ty) == 0;
1938   }
1939   return false;
1940 }
1941 
1942 static bool HasSameBase(const LValue &A, const LValue &B) {
1943   if (!A.getLValueBase())
1944     return !B.getLValueBase();
1945   if (!B.getLValueBase())
1946     return false;
1947 
1948   if (A.getLValueBase().getOpaqueValue() !=
1949       B.getLValueBase().getOpaqueValue()) {
1950     const Decl *ADecl = GetLValueBaseDecl(A);
1951     if (!ADecl)
1952       return false;
1953     const Decl *BDecl = GetLValueBaseDecl(B);
1954     if (!BDecl || ADecl->getCanonicalDecl() != BDecl->getCanonicalDecl())
1955       return false;
1956   }
1957 
1958   return IsGlobalLValue(A.getLValueBase()) ||
1959          (A.getLValueCallIndex() == B.getLValueCallIndex() &&
1960           A.getLValueVersion() == B.getLValueVersion());
1961 }
1962 
1963 static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) {
1964   assert(Base && "no location for a null lvalue");
1965   const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1966   if (VD)
1967     Info.Note(VD->getLocation(), diag::note_declared_at);
1968   else if (const Expr *E = Base.dyn_cast<const Expr*>())
1969     Info.Note(E->getExprLoc(), diag::note_constexpr_temporary_here);
1970   else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
1971     // FIXME: Produce a note for dangling pointers too.
1972     if (Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA))
1973       Info.Note((*Alloc)->AllocExpr->getExprLoc(),
1974                 diag::note_constexpr_dynamic_alloc_here);
1975   }
1976   // We have no information to show for a typeid(T) object.
1977 }
1978 
1979 enum class CheckEvaluationResultKind {
1980   ConstantExpression,
1981   FullyInitialized,
1982 };
1983 
1984 /// Materialized temporaries that we've already checked to determine if they're
1985 /// initializsed by a constant expression.
1986 using CheckedTemporaries =
1987     llvm::SmallPtrSet<const MaterializeTemporaryExpr *, 8>;
1988 
1989 static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
1990                                   EvalInfo &Info, SourceLocation DiagLoc,
1991                                   QualType Type, const APValue &Value,
1992                                   Expr::ConstExprUsage Usage,
1993                                   SourceLocation SubobjectLoc,
1994                                   CheckedTemporaries &CheckedTemps);
1995 
1996 /// Check that this reference or pointer core constant expression is a valid
1997 /// value for an address or reference constant expression. Return true if we
1998 /// can fold this expression, whether or not it's a constant expression.
1999 static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
2000                                           QualType Type, const LValue &LVal,
2001                                           Expr::ConstExprUsage Usage,
2002                                           CheckedTemporaries &CheckedTemps) {
2003   bool IsReferenceType = Type->isReferenceType();
2004 
2005   APValue::LValueBase Base = LVal.getLValueBase();
2006   const SubobjectDesignator &Designator = LVal.getLValueDesignator();
2007 
2008   // Check that the object is a global. Note that the fake 'this' object we
2009   // manufacture when checking potential constant expressions is conservatively
2010   // assumed to be global here.
2011   if (!IsGlobalLValue(Base)) {
2012     if (Info.getLangOpts().CPlusPlus11) {
2013       const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
2014       Info.FFDiag(Loc, diag::note_constexpr_non_global, 1)
2015         << IsReferenceType << !Designator.Entries.empty()
2016         << !!VD << VD;
2017       NoteLValueLocation(Info, Base);
2018     } else {
2019       Info.FFDiag(Loc);
2020     }
2021     // Don't allow references to temporaries to escape.
2022     return false;
2023   }
2024   assert((Info.checkingPotentialConstantExpression() ||
2025           LVal.getLValueCallIndex() == 0) &&
2026          "have call index for global lvalue");
2027 
2028   if (Base.is<DynamicAllocLValue>()) {
2029     Info.FFDiag(Loc, diag::note_constexpr_dynamic_alloc)
2030         << IsReferenceType << !Designator.Entries.empty();
2031     NoteLValueLocation(Info, Base);
2032     return false;
2033   }
2034 
2035   if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
2036     if (const VarDecl *Var = dyn_cast<const VarDecl>(VD)) {
2037       // Check if this is a thread-local variable.
2038       if (Var->getTLSKind())
2039         // FIXME: Diagnostic!
2040         return false;
2041 
2042       // A dllimport variable never acts like a constant.
2043       if (Usage == Expr::EvaluateForCodeGen && Var->hasAttr<DLLImportAttr>())
2044         // FIXME: Diagnostic!
2045         return false;
2046     }
2047     if (const auto *FD = dyn_cast<const FunctionDecl>(VD)) {
2048       // __declspec(dllimport) must be handled very carefully:
2049       // We must never initialize an expression with the thunk in C++.
2050       // Doing otherwise would allow the same id-expression to yield
2051       // different addresses for the same function in different translation
2052       // units.  However, this means that we must dynamically initialize the
2053       // expression with the contents of the import address table at runtime.
2054       //
2055       // The C language has no notion of ODR; furthermore, it has no notion of
2056       // dynamic initialization.  This means that we are permitted to
2057       // perform initialization with the address of the thunk.
2058       if (Info.getLangOpts().CPlusPlus && Usage == Expr::EvaluateForCodeGen &&
2059           FD->hasAttr<DLLImportAttr>())
2060         // FIXME: Diagnostic!
2061         return false;
2062     }
2063   } else if (const auto *MTE = dyn_cast_or_null<MaterializeTemporaryExpr>(
2064                  Base.dyn_cast<const Expr *>())) {
2065     if (CheckedTemps.insert(MTE).second) {
2066       QualType TempType = getType(Base);
2067       if (TempType.isDestructedType()) {
2068         Info.FFDiag(MTE->getExprLoc(),
2069                     diag::note_constexpr_unsupported_tempoarary_nontrivial_dtor)
2070             << TempType;
2071         return false;
2072       }
2073 
2074       APValue *V = MTE->getOrCreateValue(false);
2075       assert(V && "evasluation result refers to uninitialised temporary");
2076       if (!CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression,
2077                                  Info, MTE->getExprLoc(), TempType, *V,
2078                                  Usage, SourceLocation(), CheckedTemps))
2079         return false;
2080     }
2081   }
2082 
2083   // Allow address constant expressions to be past-the-end pointers. This is
2084   // an extension: the standard requires them to point to an object.
2085   if (!IsReferenceType)
2086     return true;
2087 
2088   // A reference constant expression must refer to an object.
2089   if (!Base) {
2090     // FIXME: diagnostic
2091     Info.CCEDiag(Loc);
2092     return true;
2093   }
2094 
2095   // Does this refer one past the end of some object?
2096   if (!Designator.Invalid && Designator.isOnePastTheEnd()) {
2097     const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
2098     Info.FFDiag(Loc, diag::note_constexpr_past_end, 1)
2099       << !Designator.Entries.empty() << !!VD << VD;
2100     NoteLValueLocation(Info, Base);
2101   }
2102 
2103   return true;
2104 }
2105 
2106 /// Member pointers are constant expressions unless they point to a
2107 /// non-virtual dllimport member function.
2108 static bool CheckMemberPointerConstantExpression(EvalInfo &Info,
2109                                                  SourceLocation Loc,
2110                                                  QualType Type,
2111                                                  const APValue &Value,
2112                                                  Expr::ConstExprUsage Usage) {
2113   const ValueDecl *Member = Value.getMemberPointerDecl();
2114   const auto *FD = dyn_cast_or_null<CXXMethodDecl>(Member);
2115   if (!FD)
2116     return true;
2117   return Usage == Expr::EvaluateForMangling || FD->isVirtual() ||
2118          !FD->hasAttr<DLLImportAttr>();
2119 }
2120 
2121 /// Check that this core constant expression is of literal type, and if not,
2122 /// produce an appropriate diagnostic.
2123 static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
2124                              const LValue *This = nullptr) {
2125   if (!E->isRValue() || E->getType()->isLiteralType(Info.Ctx))
2126     return true;
2127 
2128   // C++1y: A constant initializer for an object o [...] may also invoke
2129   // constexpr constructors for o and its subobjects even if those objects
2130   // are of non-literal class types.
2131   //
2132   // C++11 missed this detail for aggregates, so classes like this:
2133   //   struct foo_t { union { int i; volatile int j; } u; };
2134   // are not (obviously) initializable like so:
2135   //   __attribute__((__require_constant_initialization__))
2136   //   static const foo_t x = {{0}};
2137   // because "i" is a subobject with non-literal initialization (due to the
2138   // volatile member of the union). See:
2139   //   http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1677
2140   // Therefore, we use the C++1y behavior.
2141   if (This && Info.EvaluatingDecl == This->getLValueBase())
2142     return true;
2143 
2144   // Prvalue constant expressions must be of literal types.
2145   if (Info.getLangOpts().CPlusPlus11)
2146     Info.FFDiag(E, diag::note_constexpr_nonliteral)
2147       << E->getType();
2148   else
2149     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2150   return false;
2151 }
2152 
2153 static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
2154                                   EvalInfo &Info, SourceLocation DiagLoc,
2155                                   QualType Type, const APValue &Value,
2156                                   Expr::ConstExprUsage Usage,
2157                                   SourceLocation SubobjectLoc,
2158                                   CheckedTemporaries &CheckedTemps) {
2159   if (!Value.hasValue()) {
2160     Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized)
2161       << true << Type;
2162     if (SubobjectLoc.isValid())
2163       Info.Note(SubobjectLoc, diag::note_constexpr_subobject_declared_here);
2164     return false;
2165   }
2166 
2167   // We allow _Atomic(T) to be initialized from anything that T can be
2168   // initialized from.
2169   if (const AtomicType *AT = Type->getAs<AtomicType>())
2170     Type = AT->getValueType();
2171 
2172   // Core issue 1454: For a literal constant expression of array or class type,
2173   // each subobject of its value shall have been initialized by a constant
2174   // expression.
2175   if (Value.isArray()) {
2176     QualType EltTy = Type->castAsArrayTypeUnsafe()->getElementType();
2177     for (unsigned I = 0, N = Value.getArrayInitializedElts(); I != N; ++I) {
2178       if (!CheckEvaluationResult(CERK, Info, DiagLoc, EltTy,
2179                                  Value.getArrayInitializedElt(I), Usage,
2180                                  SubobjectLoc, CheckedTemps))
2181         return false;
2182     }
2183     if (!Value.hasArrayFiller())
2184       return true;
2185     return CheckEvaluationResult(CERK, Info, DiagLoc, EltTy,
2186                                  Value.getArrayFiller(), Usage, SubobjectLoc,
2187                                  CheckedTemps);
2188   }
2189   if (Value.isUnion() && Value.getUnionField()) {
2190     return CheckEvaluationResult(
2191         CERK, Info, DiagLoc, Value.getUnionField()->getType(),
2192         Value.getUnionValue(), Usage, Value.getUnionField()->getLocation(),
2193         CheckedTemps);
2194   }
2195   if (Value.isStruct()) {
2196     RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
2197     if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
2198       unsigned BaseIndex = 0;
2199       for (const CXXBaseSpecifier &BS : CD->bases()) {
2200         if (!CheckEvaluationResult(CERK, Info, DiagLoc, BS.getType(),
2201                                    Value.getStructBase(BaseIndex), Usage,
2202                                    BS.getBeginLoc(), CheckedTemps))
2203           return false;
2204         ++BaseIndex;
2205       }
2206     }
2207     for (const auto *I : RD->fields()) {
2208       if (I->isUnnamedBitfield())
2209         continue;
2210 
2211       if (!CheckEvaluationResult(CERK, Info, DiagLoc, I->getType(),
2212                                  Value.getStructField(I->getFieldIndex()),
2213                                  Usage, I->getLocation(), CheckedTemps))
2214         return false;
2215     }
2216   }
2217 
2218   if (Value.isLValue() &&
2219       CERK == CheckEvaluationResultKind::ConstantExpression) {
2220     LValue LVal;
2221     LVal.setFrom(Info.Ctx, Value);
2222     return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal, Usage,
2223                                          CheckedTemps);
2224   }
2225 
2226   if (Value.isMemberPointer() &&
2227       CERK == CheckEvaluationResultKind::ConstantExpression)
2228     return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value, Usage);
2229 
2230   // Everything else is fine.
2231   return true;
2232 }
2233 
2234 /// Check that this core constant expression value is a valid value for a
2235 /// constant expression. If not, report an appropriate diagnostic. Does not
2236 /// check that the expression is of literal type.
2237 static bool
2238 CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc, QualType Type,
2239                         const APValue &Value,
2240                         Expr::ConstExprUsage Usage = Expr::EvaluateForCodeGen) {
2241   CheckedTemporaries CheckedTemps;
2242   return CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression,
2243                                Info, DiagLoc, Type, Value, Usage,
2244                                SourceLocation(), CheckedTemps);
2245 }
2246 
2247 /// Check that this evaluated value is fully-initialized and can be loaded by
2248 /// an lvalue-to-rvalue conversion.
2249 static bool CheckFullyInitialized(EvalInfo &Info, SourceLocation DiagLoc,
2250                                   QualType Type, const APValue &Value) {
2251   CheckedTemporaries CheckedTemps;
2252   return CheckEvaluationResult(
2253       CheckEvaluationResultKind::FullyInitialized, Info, DiagLoc, Type, Value,
2254       Expr::EvaluateForCodeGen, SourceLocation(), CheckedTemps);
2255 }
2256 
2257 /// Enforce C++2a [expr.const]/4.17, which disallows new-expressions unless
2258 /// "the allocated storage is deallocated within the evaluation".
2259 static bool CheckMemoryLeaks(EvalInfo &Info) {
2260   if (!Info.HeapAllocs.empty()) {
2261     // We can still fold to a constant despite a compile-time memory leak,
2262     // so long as the heap allocation isn't referenced in the result (we check
2263     // that in CheckConstantExpression).
2264     Info.CCEDiag(Info.HeapAllocs.begin()->second.AllocExpr,
2265                  diag::note_constexpr_memory_leak)
2266         << unsigned(Info.HeapAllocs.size() - 1);
2267   }
2268   return true;
2269 }
2270 
2271 static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) {
2272   // A null base expression indicates a null pointer.  These are always
2273   // evaluatable, and they are false unless the offset is zero.
2274   if (!Value.getLValueBase()) {
2275     Result = !Value.getLValueOffset().isZero();
2276     return true;
2277   }
2278 
2279   // We have a non-null base.  These are generally known to be true, but if it's
2280   // a weak declaration it can be null at runtime.
2281   Result = true;
2282   const ValueDecl *Decl = Value.getLValueBase().dyn_cast<const ValueDecl*>();
2283   return !Decl || !Decl->isWeak();
2284 }
2285 
2286 static bool HandleConversionToBool(const APValue &Val, bool &Result) {
2287   switch (Val.getKind()) {
2288   case APValue::None:
2289   case APValue::Indeterminate:
2290     return false;
2291   case APValue::Int:
2292     Result = Val.getInt().getBoolValue();
2293     return true;
2294   case APValue::FixedPoint:
2295     Result = Val.getFixedPoint().getBoolValue();
2296     return true;
2297   case APValue::Float:
2298     Result = !Val.getFloat().isZero();
2299     return true;
2300   case APValue::ComplexInt:
2301     Result = Val.getComplexIntReal().getBoolValue() ||
2302              Val.getComplexIntImag().getBoolValue();
2303     return true;
2304   case APValue::ComplexFloat:
2305     Result = !Val.getComplexFloatReal().isZero() ||
2306              !Val.getComplexFloatImag().isZero();
2307     return true;
2308   case APValue::LValue:
2309     return EvalPointerValueAsBool(Val, Result);
2310   case APValue::MemberPointer:
2311     Result = Val.getMemberPointerDecl();
2312     return true;
2313   case APValue::Vector:
2314   case APValue::Array:
2315   case APValue::Struct:
2316   case APValue::Union:
2317   case APValue::AddrLabelDiff:
2318     return false;
2319   }
2320 
2321   llvm_unreachable("unknown APValue kind");
2322 }
2323 
2324 static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
2325                                        EvalInfo &Info) {
2326   assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition");
2327   APValue Val;
2328   if (!Evaluate(Val, Info, E))
2329     return false;
2330   return HandleConversionToBool(Val, Result);
2331 }
2332 
2333 template<typename T>
2334 static bool HandleOverflow(EvalInfo &Info, const Expr *E,
2335                            const T &SrcValue, QualType DestType) {
2336   Info.CCEDiag(E, diag::note_constexpr_overflow)
2337     << SrcValue << DestType;
2338   return Info.noteUndefinedBehavior();
2339 }
2340 
2341 static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
2342                                  QualType SrcType, const APFloat &Value,
2343                                  QualType DestType, APSInt &Result) {
2344   unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
2345   // Determine whether we are converting to unsigned or signed.
2346   bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
2347 
2348   Result = APSInt(DestWidth, !DestSigned);
2349   bool ignored;
2350   if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
2351       & APFloat::opInvalidOp)
2352     return HandleOverflow(Info, E, Value, DestType);
2353   return true;
2354 }
2355 
2356 static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E,
2357                                    QualType SrcType, QualType DestType,
2358                                    APFloat &Result) {
2359   APFloat Value = Result;
2360   bool ignored;
2361   Result.convert(Info.Ctx.getFloatTypeSemantics(DestType),
2362                  APFloat::rmNearestTiesToEven, &ignored);
2363   return true;
2364 }
2365 
2366 static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E,
2367                                  QualType DestType, QualType SrcType,
2368                                  const APSInt &Value) {
2369   unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
2370   // Figure out if this is a truncate, extend or noop cast.
2371   // If the input is signed, do a sign extend, noop, or truncate.
2372   APSInt Result = Value.extOrTrunc(DestWidth);
2373   Result.setIsUnsigned(DestType->isUnsignedIntegerOrEnumerationType());
2374   if (DestType->isBooleanType())
2375     Result = Value.getBoolValue();
2376   return Result;
2377 }
2378 
2379 static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E,
2380                                  QualType SrcType, const APSInt &Value,
2381                                  QualType DestType, APFloat &Result) {
2382   Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
2383   Result.convertFromAPInt(Value, Value.isSigned(),
2384                           APFloat::rmNearestTiesToEven);
2385   return true;
2386 }
2387 
2388 static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E,
2389                                   APValue &Value, const FieldDecl *FD) {
2390   assert(FD->isBitField() && "truncateBitfieldValue on non-bitfield");
2391 
2392   if (!Value.isInt()) {
2393     // Trying to store a pointer-cast-to-integer into a bitfield.
2394     // FIXME: In this case, we should provide the diagnostic for casting
2395     // a pointer to an integer.
2396     assert(Value.isLValue() && "integral value neither int nor lvalue?");
2397     Info.FFDiag(E);
2398     return false;
2399   }
2400 
2401   APSInt &Int = Value.getInt();
2402   unsigned OldBitWidth = Int.getBitWidth();
2403   unsigned NewBitWidth = FD->getBitWidthValue(Info.Ctx);
2404   if (NewBitWidth < OldBitWidth)
2405     Int = Int.trunc(NewBitWidth).extend(OldBitWidth);
2406   return true;
2407 }
2408 
2409 static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E,
2410                                   llvm::APInt &Res) {
2411   APValue SVal;
2412   if (!Evaluate(SVal, Info, E))
2413     return false;
2414   if (SVal.isInt()) {
2415     Res = SVal.getInt();
2416     return true;
2417   }
2418   if (SVal.isFloat()) {
2419     Res = SVal.getFloat().bitcastToAPInt();
2420     return true;
2421   }
2422   if (SVal.isVector()) {
2423     QualType VecTy = E->getType();
2424     unsigned VecSize = Info.Ctx.getTypeSize(VecTy);
2425     QualType EltTy = VecTy->castAs<VectorType>()->getElementType();
2426     unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
2427     bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
2428     Res = llvm::APInt::getNullValue(VecSize);
2429     for (unsigned i = 0; i < SVal.getVectorLength(); i++) {
2430       APValue &Elt = SVal.getVectorElt(i);
2431       llvm::APInt EltAsInt;
2432       if (Elt.isInt()) {
2433         EltAsInt = Elt.getInt();
2434       } else if (Elt.isFloat()) {
2435         EltAsInt = Elt.getFloat().bitcastToAPInt();
2436       } else {
2437         // Don't try to handle vectors of anything other than int or float
2438         // (not sure if it's possible to hit this case).
2439         Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2440         return false;
2441       }
2442       unsigned BaseEltSize = EltAsInt.getBitWidth();
2443       if (BigEndian)
2444         Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i*EltSize+BaseEltSize);
2445       else
2446         Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i*EltSize);
2447     }
2448     return true;
2449   }
2450   // Give up if the input isn't an int, float, or vector.  For example, we
2451   // reject "(v4i16)(intptr_t)&a".
2452   Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2453   return false;
2454 }
2455 
2456 /// Perform the given integer operation, which is known to need at most BitWidth
2457 /// bits, and check for overflow in the original type (if that type was not an
2458 /// unsigned type).
2459 template<typename Operation>
2460 static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E,
2461                                  const APSInt &LHS, const APSInt &RHS,
2462                                  unsigned BitWidth, Operation Op,
2463                                  APSInt &Result) {
2464   if (LHS.isUnsigned()) {
2465     Result = Op(LHS, RHS);
2466     return true;
2467   }
2468 
2469   APSInt Value(Op(LHS.extend(BitWidth), RHS.extend(BitWidth)), false);
2470   Result = Value.trunc(LHS.getBitWidth());
2471   if (Result.extend(BitWidth) != Value) {
2472     if (Info.checkingForUndefinedBehavior())
2473       Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
2474                                        diag::warn_integer_constant_overflow)
2475           << Result.toString(10) << E->getType();
2476     else
2477       return HandleOverflow(Info, E, Value, E->getType());
2478   }
2479   return true;
2480 }
2481 
2482 /// Perform the given binary integer operation.
2483 static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS,
2484                               BinaryOperatorKind Opcode, APSInt RHS,
2485                               APSInt &Result) {
2486   switch (Opcode) {
2487   default:
2488     Info.FFDiag(E);
2489     return false;
2490   case BO_Mul:
2491     return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() * 2,
2492                                 std::multiplies<APSInt>(), Result);
2493   case BO_Add:
2494     return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2495                                 std::plus<APSInt>(), Result);
2496   case BO_Sub:
2497     return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2498                                 std::minus<APSInt>(), Result);
2499   case BO_And: Result = LHS & RHS; return true;
2500   case BO_Xor: Result = LHS ^ RHS; return true;
2501   case BO_Or:  Result = LHS | RHS; return true;
2502   case BO_Div:
2503   case BO_Rem:
2504     if (RHS == 0) {
2505       Info.FFDiag(E, diag::note_expr_divide_by_zero);
2506       return false;
2507     }
2508     Result = (Opcode == BO_Rem ? LHS % RHS : LHS / RHS);
2509     // Check for overflow case: INT_MIN / -1 or INT_MIN % -1. APSInt supports
2510     // this operation and gives the two's complement result.
2511     if (RHS.isNegative() && RHS.isAllOnesValue() &&
2512         LHS.isSigned() && LHS.isMinSignedValue())
2513       return HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1),
2514                             E->getType());
2515     return true;
2516   case BO_Shl: {
2517     if (Info.getLangOpts().OpenCL)
2518       // OpenCL 6.3j: shift values are effectively % word size of LHS.
2519       RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2520                     static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2521                     RHS.isUnsigned());
2522     else if (RHS.isSigned() && RHS.isNegative()) {
2523       // During constant-folding, a negative shift is an opposite shift. Such
2524       // a shift is not a constant expression.
2525       Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2526       RHS = -RHS;
2527       goto shift_right;
2528     }
2529   shift_left:
2530     // C++11 [expr.shift]p1: Shift width must be less than the bit width of
2531     // the shifted type.
2532     unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2533     if (SA != RHS) {
2534       Info.CCEDiag(E, diag::note_constexpr_large_shift)
2535         << RHS << E->getType() << LHS.getBitWidth();
2536     } else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus2a) {
2537       // C++11 [expr.shift]p2: A signed left shift must have a non-negative
2538       // operand, and must not overflow the corresponding unsigned type.
2539       // C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to
2540       // E1 x 2^E2 module 2^N.
2541       if (LHS.isNegative())
2542         Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
2543       else if (LHS.countLeadingZeros() < SA)
2544         Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
2545     }
2546     Result = LHS << SA;
2547     return true;
2548   }
2549   case BO_Shr: {
2550     if (Info.getLangOpts().OpenCL)
2551       // OpenCL 6.3j: shift values are effectively % word size of LHS.
2552       RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2553                     static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2554                     RHS.isUnsigned());
2555     else if (RHS.isSigned() && RHS.isNegative()) {
2556       // During constant-folding, a negative shift is an opposite shift. Such a
2557       // shift is not a constant expression.
2558       Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2559       RHS = -RHS;
2560       goto shift_left;
2561     }
2562   shift_right:
2563     // C++11 [expr.shift]p1: Shift width must be less than the bit width of the
2564     // shifted type.
2565     unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2566     if (SA != RHS)
2567       Info.CCEDiag(E, diag::note_constexpr_large_shift)
2568         << RHS << E->getType() << LHS.getBitWidth();
2569     Result = LHS >> SA;
2570     return true;
2571   }
2572 
2573   case BO_LT: Result = LHS < RHS; return true;
2574   case BO_GT: Result = LHS > RHS; return true;
2575   case BO_LE: Result = LHS <= RHS; return true;
2576   case BO_GE: Result = LHS >= RHS; return true;
2577   case BO_EQ: Result = LHS == RHS; return true;
2578   case BO_NE: Result = LHS != RHS; return true;
2579   case BO_Cmp:
2580     llvm_unreachable("BO_Cmp should be handled elsewhere");
2581   }
2582 }
2583 
2584 /// Perform the given binary floating-point operation, in-place, on LHS.
2585 static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E,
2586                                   APFloat &LHS, BinaryOperatorKind Opcode,
2587                                   const APFloat &RHS) {
2588   switch (Opcode) {
2589   default:
2590     Info.FFDiag(E);
2591     return false;
2592   case BO_Mul:
2593     LHS.multiply(RHS, APFloat::rmNearestTiesToEven);
2594     break;
2595   case BO_Add:
2596     LHS.add(RHS, APFloat::rmNearestTiesToEven);
2597     break;
2598   case BO_Sub:
2599     LHS.subtract(RHS, APFloat::rmNearestTiesToEven);
2600     break;
2601   case BO_Div:
2602     // [expr.mul]p4:
2603     //   If the second operand of / or % is zero the behavior is undefined.
2604     if (RHS.isZero())
2605       Info.CCEDiag(E, diag::note_expr_divide_by_zero);
2606     LHS.divide(RHS, APFloat::rmNearestTiesToEven);
2607     break;
2608   }
2609 
2610   // [expr.pre]p4:
2611   //   If during the evaluation of an expression, the result is not
2612   //   mathematically defined [...], the behavior is undefined.
2613   // FIXME: C++ rules require us to not conform to IEEE 754 here.
2614   if (LHS.isNaN()) {
2615     Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();
2616     return Info.noteUndefinedBehavior();
2617   }
2618   return true;
2619 }
2620 
2621 /// Cast an lvalue referring to a base subobject to a derived class, by
2622 /// truncating the lvalue's path to the given length.
2623 static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
2624                                const RecordDecl *TruncatedType,
2625                                unsigned TruncatedElements) {
2626   SubobjectDesignator &D = Result.Designator;
2627 
2628   // Check we actually point to a derived class object.
2629   if (TruncatedElements == D.Entries.size())
2630     return true;
2631   assert(TruncatedElements >= D.MostDerivedPathLength &&
2632          "not casting to a derived class");
2633   if (!Result.checkSubobject(Info, E, CSK_Derived))
2634     return false;
2635 
2636   // Truncate the path to the subobject, and remove any derived-to-base offsets.
2637   const RecordDecl *RD = TruncatedType;
2638   for (unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) {
2639     if (RD->isInvalidDecl()) return false;
2640     const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
2641     const CXXRecordDecl *Base = getAsBaseClass(D.Entries[I]);
2642     if (isVirtualBaseClass(D.Entries[I]))
2643       Result.Offset -= Layout.getVBaseClassOffset(Base);
2644     else
2645       Result.Offset -= Layout.getBaseClassOffset(Base);
2646     RD = Base;
2647   }
2648   D.Entries.resize(TruncatedElements);
2649   return true;
2650 }
2651 
2652 static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2653                                    const CXXRecordDecl *Derived,
2654                                    const CXXRecordDecl *Base,
2655                                    const ASTRecordLayout *RL = nullptr) {
2656   if (!RL) {
2657     if (Derived->isInvalidDecl()) return false;
2658     RL = &Info.Ctx.getASTRecordLayout(Derived);
2659   }
2660 
2661   Obj.getLValueOffset() += RL->getBaseClassOffset(Base);
2662   Obj.addDecl(Info, E, Base, /*Virtual*/ false);
2663   return true;
2664 }
2665 
2666 static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2667                              const CXXRecordDecl *DerivedDecl,
2668                              const CXXBaseSpecifier *Base) {
2669   const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl();
2670 
2671   if (!Base->isVirtual())
2672     return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl);
2673 
2674   SubobjectDesignator &D = Obj.Designator;
2675   if (D.Invalid)
2676     return false;
2677 
2678   // Extract most-derived object and corresponding type.
2679   DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl();
2680   if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength))
2681     return false;
2682 
2683   // Find the virtual base class.
2684   if (DerivedDecl->isInvalidDecl()) return false;
2685   const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
2686   Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl);
2687   Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
2688   return true;
2689 }
2690 
2691 static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E,
2692                                  QualType Type, LValue &Result) {
2693   for (CastExpr::path_const_iterator PathI = E->path_begin(),
2694                                      PathE = E->path_end();
2695        PathI != PathE; ++PathI) {
2696     if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(),
2697                           *PathI))
2698       return false;
2699     Type = (*PathI)->getType();
2700   }
2701   return true;
2702 }
2703 
2704 /// Cast an lvalue referring to a derived class to a known base subobject.
2705 static bool CastToBaseClass(EvalInfo &Info, const Expr *E, LValue &Result,
2706                             const CXXRecordDecl *DerivedRD,
2707                             const CXXRecordDecl *BaseRD) {
2708   CXXBasePaths Paths(/*FindAmbiguities=*/false,
2709                      /*RecordPaths=*/true, /*DetectVirtual=*/false);
2710   if (!DerivedRD->isDerivedFrom(BaseRD, Paths))
2711     llvm_unreachable("Class must be derived from the passed in base class!");
2712 
2713   for (CXXBasePathElement &Elem : Paths.front())
2714     if (!HandleLValueBase(Info, E, Result, Elem.Class, Elem.Base))
2715       return false;
2716   return true;
2717 }
2718 
2719 /// Update LVal to refer to the given field, which must be a member of the type
2720 /// currently described by LVal.
2721 static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal,
2722                                const FieldDecl *FD,
2723                                const ASTRecordLayout *RL = nullptr) {
2724   if (!RL) {
2725     if (FD->getParent()->isInvalidDecl()) return false;
2726     RL = &Info.Ctx.getASTRecordLayout(FD->getParent());
2727   }
2728 
2729   unsigned I = FD->getFieldIndex();
2730   LVal.adjustOffset(Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I)));
2731   LVal.addDecl(Info, E, FD);
2732   return true;
2733 }
2734 
2735 /// Update LVal to refer to the given indirect field.
2736 static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E,
2737                                        LValue &LVal,
2738                                        const IndirectFieldDecl *IFD) {
2739   for (const auto *C : IFD->chain())
2740     if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(C)))
2741       return false;
2742   return true;
2743 }
2744 
2745 /// Get the size of the given type in char units.
2746 static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc,
2747                          QualType Type, CharUnits &Size) {
2748   // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc
2749   // extension.
2750   if (Type->isVoidType() || Type->isFunctionType()) {
2751     Size = CharUnits::One();
2752     return true;
2753   }
2754 
2755   if (Type->isDependentType()) {
2756     Info.FFDiag(Loc);
2757     return false;
2758   }
2759 
2760   if (!Type->isConstantSizeType()) {
2761     // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
2762     // FIXME: Better diagnostic.
2763     Info.FFDiag(Loc);
2764     return false;
2765   }
2766 
2767   Size = Info.Ctx.getTypeSizeInChars(Type);
2768   return true;
2769 }
2770 
2771 /// Update a pointer value to model pointer arithmetic.
2772 /// \param Info - Information about the ongoing evaluation.
2773 /// \param E - The expression being evaluated, for diagnostic purposes.
2774 /// \param LVal - The pointer value to be updated.
2775 /// \param EltTy - The pointee type represented by LVal.
2776 /// \param Adjustment - The adjustment, in objects of type EltTy, to add.
2777 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2778                                         LValue &LVal, QualType EltTy,
2779                                         APSInt Adjustment) {
2780   CharUnits SizeOfPointee;
2781   if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfPointee))
2782     return false;
2783 
2784   LVal.adjustOffsetAndIndex(Info, E, Adjustment, SizeOfPointee);
2785   return true;
2786 }
2787 
2788 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2789                                         LValue &LVal, QualType EltTy,
2790                                         int64_t Adjustment) {
2791   return HandleLValueArrayAdjustment(Info, E, LVal, EltTy,
2792                                      APSInt::get(Adjustment));
2793 }
2794 
2795 /// Update an lvalue to refer to a component of a complex number.
2796 /// \param Info - Information about the ongoing evaluation.
2797 /// \param LVal - The lvalue to be updated.
2798 /// \param EltTy - The complex number's component type.
2799 /// \param Imag - False for the real component, true for the imaginary.
2800 static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E,
2801                                        LValue &LVal, QualType EltTy,
2802                                        bool Imag) {
2803   if (Imag) {
2804     CharUnits SizeOfComponent;
2805     if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent))
2806       return false;
2807     LVal.Offset += SizeOfComponent;
2808   }
2809   LVal.addComplex(Info, E, EltTy, Imag);
2810   return true;
2811 }
2812 
2813 /// Try to evaluate the initializer for a variable declaration.
2814 ///
2815 /// \param Info   Information about the ongoing evaluation.
2816 /// \param E      An expression to be used when printing diagnostics.
2817 /// \param VD     The variable whose initializer should be obtained.
2818 /// \param Frame  The frame in which the variable was created. Must be null
2819 ///               if this variable is not local to the evaluation.
2820 /// \param Result Filled in with a pointer to the value of the variable.
2821 static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
2822                                 const VarDecl *VD, CallStackFrame *Frame,
2823                                 APValue *&Result, const LValue *LVal) {
2824 
2825   // If this is a parameter to an active constexpr function call, perform
2826   // argument substitution.
2827   if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) {
2828     // Assume arguments of a potential constant expression are unknown
2829     // constant expressions.
2830     if (Info.checkingPotentialConstantExpression())
2831       return false;
2832     if (!Frame || !Frame->Arguments) {
2833       Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2834       return false;
2835     }
2836     Result = &Frame->Arguments[PVD->getFunctionScopeIndex()];
2837     return true;
2838   }
2839 
2840   // If this is a local variable, dig out its value.
2841   if (Frame) {
2842     Result = LVal ? Frame->getTemporary(VD, LVal->getLValueVersion())
2843                   : Frame->getCurrentTemporary(VD);
2844     if (!Result) {
2845       // Assume variables referenced within a lambda's call operator that were
2846       // not declared within the call operator are captures and during checking
2847       // of a potential constant expression, assume they are unknown constant
2848       // expressions.
2849       assert(isLambdaCallOperator(Frame->Callee) &&
2850              (VD->getDeclContext() != Frame->Callee || VD->isInitCapture()) &&
2851              "missing value for local variable");
2852       if (Info.checkingPotentialConstantExpression())
2853         return false;
2854       // FIXME: implement capture evaluation during constant expr evaluation.
2855       Info.FFDiag(E->getBeginLoc(),
2856                   diag::note_unimplemented_constexpr_lambda_feature_ast)
2857           << "captures not currently allowed";
2858       return false;
2859     }
2860     return true;
2861   }
2862 
2863   // Dig out the initializer, and use the declaration which it's attached to.
2864   const Expr *Init = VD->getAnyInitializer(VD);
2865   if (!Init || Init->isValueDependent()) {
2866     // If we're checking a potential constant expression, the variable could be
2867     // initialized later.
2868     if (!Info.checkingPotentialConstantExpression())
2869       Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2870     return false;
2871   }
2872 
2873   // If we're currently evaluating the initializer of this declaration, use that
2874   // in-flight value.
2875   if (Info.EvaluatingDecl.dyn_cast<const ValueDecl*>() == VD) {
2876     Result = Info.EvaluatingDeclValue;
2877     return true;
2878   }
2879 
2880   // Never evaluate the initializer of a weak variable. We can't be sure that
2881   // this is the definition which will be used.
2882   if (VD->isWeak()) {
2883     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2884     return false;
2885   }
2886 
2887   // Check that we can fold the initializer. In C++, we will have already done
2888   // this in the cases where it matters for conformance.
2889   SmallVector<PartialDiagnosticAt, 8> Notes;
2890   if (!VD->evaluateValue(Notes)) {
2891     Info.FFDiag(E, diag::note_constexpr_var_init_non_constant,
2892               Notes.size() + 1) << VD;
2893     Info.Note(VD->getLocation(), diag::note_declared_at);
2894     Info.addNotes(Notes);
2895     return false;
2896   } else if (!VD->checkInitIsICE()) {
2897     Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant,
2898                  Notes.size() + 1) << VD;
2899     Info.Note(VD->getLocation(), diag::note_declared_at);
2900     Info.addNotes(Notes);
2901   }
2902 
2903   Result = VD->getEvaluatedValue();
2904   return true;
2905 }
2906 
2907 static bool IsConstNonVolatile(QualType T) {
2908   Qualifiers Quals = T.getQualifiers();
2909   return Quals.hasConst() && !Quals.hasVolatile();
2910 }
2911 
2912 /// Get the base index of the given base class within an APValue representing
2913 /// the given derived class.
2914 static unsigned getBaseIndex(const CXXRecordDecl *Derived,
2915                              const CXXRecordDecl *Base) {
2916   Base = Base->getCanonicalDecl();
2917   unsigned Index = 0;
2918   for (CXXRecordDecl::base_class_const_iterator I = Derived->bases_begin(),
2919          E = Derived->bases_end(); I != E; ++I, ++Index) {
2920     if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == Base)
2921       return Index;
2922   }
2923 
2924   llvm_unreachable("base class missing from derived class's bases list");
2925 }
2926 
2927 /// Extract the value of a character from a string literal.
2928 static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
2929                                             uint64_t Index) {
2930   assert(!isa<SourceLocExpr>(Lit) &&
2931          "SourceLocExpr should have already been converted to a StringLiteral");
2932 
2933   // FIXME: Support MakeStringConstant
2934   if (const auto *ObjCEnc = dyn_cast<ObjCEncodeExpr>(Lit)) {
2935     std::string Str;
2936     Info.Ctx.getObjCEncodingForType(ObjCEnc->getEncodedType(), Str);
2937     assert(Index <= Str.size() && "Index too large");
2938     return APSInt::getUnsigned(Str.c_str()[Index]);
2939   }
2940 
2941   if (auto PE = dyn_cast<PredefinedExpr>(Lit))
2942     Lit = PE->getFunctionName();
2943   const StringLiteral *S = cast<StringLiteral>(Lit);
2944   const ConstantArrayType *CAT =
2945       Info.Ctx.getAsConstantArrayType(S->getType());
2946   assert(CAT && "string literal isn't an array");
2947   QualType CharType = CAT->getElementType();
2948   assert(CharType->isIntegerType() && "unexpected character type");
2949 
2950   APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2951                CharType->isUnsignedIntegerType());
2952   if (Index < S->getLength())
2953     Value = S->getCodeUnit(Index);
2954   return Value;
2955 }
2956 
2957 // Expand a string literal into an array of characters.
2958 //
2959 // FIXME: This is inefficient; we should probably introduce something similar
2960 // to the LLVM ConstantDataArray to make this cheaper.
2961 static void expandStringLiteral(EvalInfo &Info, const StringLiteral *S,
2962                                 APValue &Result,
2963                                 QualType AllocType = QualType()) {
2964   const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(
2965       AllocType.isNull() ? S->getType() : AllocType);
2966   assert(CAT && "string literal isn't an array");
2967   QualType CharType = CAT->getElementType();
2968   assert(CharType->isIntegerType() && "unexpected character type");
2969 
2970   unsigned Elts = CAT->getSize().getZExtValue();
2971   Result = APValue(APValue::UninitArray(),
2972                    std::min(S->getLength(), Elts), Elts);
2973   APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2974                CharType->isUnsignedIntegerType());
2975   if (Result.hasArrayFiller())
2976     Result.getArrayFiller() = APValue(Value);
2977   for (unsigned I = 0, N = Result.getArrayInitializedElts(); I != N; ++I) {
2978     Value = S->getCodeUnit(I);
2979     Result.getArrayInitializedElt(I) = APValue(Value);
2980   }
2981 }
2982 
2983 // Expand an array so that it has more than Index filled elements.
2984 static void expandArray(APValue &Array, unsigned Index) {
2985   unsigned Size = Array.getArraySize();
2986   assert(Index < Size);
2987 
2988   // Always at least double the number of elements for which we store a value.
2989   unsigned OldElts = Array.getArrayInitializedElts();
2990   unsigned NewElts = std::max(Index+1, OldElts * 2);
2991   NewElts = std::min(Size, std::max(NewElts, 8u));
2992 
2993   // Copy the data across.
2994   APValue NewValue(APValue::UninitArray(), NewElts, Size);
2995   for (unsigned I = 0; I != OldElts; ++I)
2996     NewValue.getArrayInitializedElt(I).swap(Array.getArrayInitializedElt(I));
2997   for (unsigned I = OldElts; I != NewElts; ++I)
2998     NewValue.getArrayInitializedElt(I) = Array.getArrayFiller();
2999   if (NewValue.hasArrayFiller())
3000     NewValue.getArrayFiller() = Array.getArrayFiller();
3001   Array.swap(NewValue);
3002 }
3003 
3004 /// Determine whether a type would actually be read by an lvalue-to-rvalue
3005 /// conversion. If it's of class type, we may assume that the copy operation
3006 /// is trivial. Note that this is never true for a union type with fields
3007 /// (because the copy always "reads" the active member) and always true for
3008 /// a non-class type.
3009 static bool isReadByLvalueToRvalueConversion(QualType T) {
3010   CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
3011   if (!RD || (RD->isUnion() && !RD->field_empty()))
3012     return true;
3013   if (RD->isEmpty())
3014     return false;
3015 
3016   for (auto *Field : RD->fields())
3017     if (isReadByLvalueToRvalueConversion(Field->getType()))
3018       return true;
3019 
3020   for (auto &BaseSpec : RD->bases())
3021     if (isReadByLvalueToRvalueConversion(BaseSpec.getType()))
3022       return true;
3023 
3024   return false;
3025 }
3026 
3027 /// Diagnose an attempt to read from any unreadable field within the specified
3028 /// type, which might be a class type.
3029 static bool diagnoseMutableFields(EvalInfo &Info, const Expr *E, AccessKinds AK,
3030                                   QualType T) {
3031   CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
3032   if (!RD)
3033     return false;
3034 
3035   if (!RD->hasMutableFields())
3036     return false;
3037 
3038   for (auto *Field : RD->fields()) {
3039     // If we're actually going to read this field in some way, then it can't
3040     // be mutable. If we're in a union, then assigning to a mutable field
3041     // (even an empty one) can change the active member, so that's not OK.
3042     // FIXME: Add core issue number for the union case.
3043     if (Field->isMutable() &&
3044         (RD->isUnion() || isReadByLvalueToRvalueConversion(Field->getType()))) {
3045       Info.FFDiag(E, diag::note_constexpr_access_mutable, 1) << AK << Field;
3046       Info.Note(Field->getLocation(), diag::note_declared_at);
3047       return true;
3048     }
3049 
3050     if (diagnoseMutableFields(Info, E, AK, Field->getType()))
3051       return true;
3052   }
3053 
3054   for (auto &BaseSpec : RD->bases())
3055     if (diagnoseMutableFields(Info, E, AK, BaseSpec.getType()))
3056       return true;
3057 
3058   // All mutable fields were empty, and thus not actually read.
3059   return false;
3060 }
3061 
3062 static bool lifetimeStartedInEvaluation(EvalInfo &Info,
3063                                         APValue::LValueBase Base,
3064                                         bool MutableSubobject = false) {
3065   // A temporary we created.
3066   if (Base.getCallIndex())
3067     return true;
3068 
3069   auto *Evaluating = Info.EvaluatingDecl.dyn_cast<const ValueDecl*>();
3070   if (!Evaluating)
3071     return false;
3072 
3073   auto *BaseD = Base.dyn_cast<const ValueDecl*>();
3074 
3075   switch (Info.IsEvaluatingDecl) {
3076   case EvalInfo::EvaluatingDeclKind::None:
3077     return false;
3078 
3079   case EvalInfo::EvaluatingDeclKind::Ctor:
3080     // The variable whose initializer we're evaluating.
3081     if (BaseD)
3082       return declaresSameEntity(Evaluating, BaseD);
3083 
3084     // A temporary lifetime-extended by the variable whose initializer we're
3085     // evaluating.
3086     if (auto *BaseE = Base.dyn_cast<const Expr *>())
3087       if (auto *BaseMTE = dyn_cast<MaterializeTemporaryExpr>(BaseE))
3088         return declaresSameEntity(BaseMTE->getExtendingDecl(), Evaluating);
3089     return false;
3090 
3091   case EvalInfo::EvaluatingDeclKind::Dtor:
3092     // C++2a [expr.const]p6:
3093     //   [during constant destruction] the lifetime of a and its non-mutable
3094     //   subobjects (but not its mutable subobjects) [are] considered to start
3095     //   within e.
3096     //
3097     // FIXME: We can meaningfully extend this to cover non-const objects, but
3098     // we will need special handling: we should be able to access only
3099     // subobjects of such objects that are themselves declared const.
3100     if (!BaseD ||
3101         !(BaseD->getType().isConstQualified() ||
3102           BaseD->getType()->isReferenceType()) ||
3103         MutableSubobject)
3104       return false;
3105     return declaresSameEntity(Evaluating, BaseD);
3106   }
3107 
3108   llvm_unreachable("unknown evaluating decl kind");
3109 }
3110 
3111 namespace {
3112 /// A handle to a complete object (an object that is not a subobject of
3113 /// another object).
3114 struct CompleteObject {
3115   /// The identity of the object.
3116   APValue::LValueBase Base;
3117   /// The value of the complete object.
3118   APValue *Value;
3119   /// The type of the complete object.
3120   QualType Type;
3121 
3122   CompleteObject() : Value(nullptr) {}
3123   CompleteObject(APValue::LValueBase Base, APValue *Value, QualType Type)
3124       : Base(Base), Value(Value), Type(Type) {}
3125 
3126   bool mayAccessMutableMembers(EvalInfo &Info, AccessKinds AK) const {
3127     // In C++14 onwards, it is permitted to read a mutable member whose
3128     // lifetime began within the evaluation.
3129     // FIXME: Should we also allow this in C++11?
3130     if (!Info.getLangOpts().CPlusPlus14)
3131       return false;
3132     return lifetimeStartedInEvaluation(Info, Base, /*MutableSubobject*/true);
3133   }
3134 
3135   explicit operator bool() const { return !Type.isNull(); }
3136 };
3137 } // end anonymous namespace
3138 
3139 static QualType getSubobjectType(QualType ObjType, QualType SubobjType,
3140                                  bool IsMutable = false) {
3141   // C++ [basic.type.qualifier]p1:
3142   // - A const object is an object of type const T or a non-mutable subobject
3143   //   of a const object.
3144   if (ObjType.isConstQualified() && !IsMutable)
3145     SubobjType.addConst();
3146   // - A volatile object is an object of type const T or a subobject of a
3147   //   volatile object.
3148   if (ObjType.isVolatileQualified())
3149     SubobjType.addVolatile();
3150   return SubobjType;
3151 }
3152 
3153 /// Find the designated sub-object of an rvalue.
3154 template<typename SubobjectHandler>
3155 typename SubobjectHandler::result_type
3156 findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj,
3157               const SubobjectDesignator &Sub, SubobjectHandler &handler) {
3158   if (Sub.Invalid)
3159     // A diagnostic will have already been produced.
3160     return handler.failed();
3161   if (Sub.isOnePastTheEnd() || Sub.isMostDerivedAnUnsizedArray()) {
3162     if (Info.getLangOpts().CPlusPlus11)
3163       Info.FFDiag(E, Sub.isOnePastTheEnd()
3164                          ? diag::note_constexpr_access_past_end
3165                          : diag::note_constexpr_access_unsized_array)
3166           << handler.AccessKind;
3167     else
3168       Info.FFDiag(E);
3169     return handler.failed();
3170   }
3171 
3172   APValue *O = Obj.Value;
3173   QualType ObjType = Obj.Type;
3174   const FieldDecl *LastField = nullptr;
3175   const FieldDecl *VolatileField = nullptr;
3176 
3177   // Walk the designator's path to find the subobject.
3178   for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {
3179     // Reading an indeterminate value is undefined, but assigning over one is OK.
3180     if ((O->isAbsent() && !(handler.AccessKind == AK_Construct && I == N)) ||
3181         (O->isIndeterminate() && handler.AccessKind != AK_Construct &&
3182          handler.AccessKind != AK_Assign &&
3183          handler.AccessKind != AK_ReadObjectRepresentation)) {
3184       if (!Info.checkingPotentialConstantExpression())
3185         Info.FFDiag(E, diag::note_constexpr_access_uninit)
3186             << handler.AccessKind << O->isIndeterminate();
3187       return handler.failed();
3188     }
3189 
3190     // C++ [class.ctor]p5, C++ [class.dtor]p5:
3191     //    const and volatile semantics are not applied on an object under
3192     //    {con,de}struction.
3193     if ((ObjType.isConstQualified() || ObjType.isVolatileQualified()) &&
3194         ObjType->isRecordType() &&
3195         Info.isEvaluatingCtorDtor(
3196             Obj.Base, llvm::makeArrayRef(Sub.Entries.begin(),
3197                                          Sub.Entries.begin() + I)) !=
3198                           ConstructionPhase::None) {
3199       ObjType = Info.Ctx.getCanonicalType(ObjType);
3200       ObjType.removeLocalConst();
3201       ObjType.removeLocalVolatile();
3202     }
3203 
3204     // If this is our last pass, check that the final object type is OK.
3205     if (I == N || (I == N - 1 && ObjType->isAnyComplexType())) {
3206       // Accesses to volatile objects are prohibited.
3207       if (ObjType.isVolatileQualified() && isFormalAccess(handler.AccessKind)) {
3208         if (Info.getLangOpts().CPlusPlus) {
3209           int DiagKind;
3210           SourceLocation Loc;
3211           const NamedDecl *Decl = nullptr;
3212           if (VolatileField) {
3213             DiagKind = 2;
3214             Loc = VolatileField->getLocation();
3215             Decl = VolatileField;
3216           } else if (auto *VD = Obj.Base.dyn_cast<const ValueDecl*>()) {
3217             DiagKind = 1;
3218             Loc = VD->getLocation();
3219             Decl = VD;
3220           } else {
3221             DiagKind = 0;
3222             if (auto *E = Obj.Base.dyn_cast<const Expr *>())
3223               Loc = E->getExprLoc();
3224           }
3225           Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
3226               << handler.AccessKind << DiagKind << Decl;
3227           Info.Note(Loc, diag::note_constexpr_volatile_here) << DiagKind;
3228         } else {
3229           Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
3230         }
3231         return handler.failed();
3232       }
3233 
3234       // If we are reading an object of class type, there may still be more
3235       // things we need to check: if there are any mutable subobjects, we
3236       // cannot perform this read. (This only happens when performing a trivial
3237       // copy or assignment.)
3238       if (ObjType->isRecordType() &&
3239           !Obj.mayAccessMutableMembers(Info, handler.AccessKind) &&
3240           diagnoseMutableFields(Info, E, handler.AccessKind, ObjType))
3241         return handler.failed();
3242     }
3243 
3244     if (I == N) {
3245       if (!handler.found(*O, ObjType))
3246         return false;
3247 
3248       // If we modified a bit-field, truncate it to the right width.
3249       if (isModification(handler.AccessKind) &&
3250           LastField && LastField->isBitField() &&
3251           !truncateBitfieldValue(Info, E, *O, LastField))
3252         return false;
3253 
3254       return true;
3255     }
3256 
3257     LastField = nullptr;
3258     if (ObjType->isArrayType()) {
3259       // Next subobject is an array element.
3260       const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType);
3261       assert(CAT && "vla in literal type?");
3262       uint64_t Index = Sub.Entries[I].getAsArrayIndex();
3263       if (CAT->getSize().ule(Index)) {
3264         // Note, it should not be possible to form a pointer with a valid
3265         // designator which points more than one past the end of the array.
3266         if (Info.getLangOpts().CPlusPlus11)
3267           Info.FFDiag(E, diag::note_constexpr_access_past_end)
3268             << handler.AccessKind;
3269         else
3270           Info.FFDiag(E);
3271         return handler.failed();
3272       }
3273 
3274       ObjType = CAT->getElementType();
3275 
3276       if (O->getArrayInitializedElts() > Index)
3277         O = &O->getArrayInitializedElt(Index);
3278       else if (!isRead(handler.AccessKind)) {
3279         expandArray(*O, Index);
3280         O = &O->getArrayInitializedElt(Index);
3281       } else
3282         O = &O->getArrayFiller();
3283     } else if (ObjType->isAnyComplexType()) {
3284       // Next subobject is a complex number.
3285       uint64_t Index = Sub.Entries[I].getAsArrayIndex();
3286       if (Index > 1) {
3287         if (Info.getLangOpts().CPlusPlus11)
3288           Info.FFDiag(E, diag::note_constexpr_access_past_end)
3289             << handler.AccessKind;
3290         else
3291           Info.FFDiag(E);
3292         return handler.failed();
3293       }
3294 
3295       ObjType = getSubobjectType(
3296           ObjType, ObjType->castAs<ComplexType>()->getElementType());
3297 
3298       assert(I == N - 1 && "extracting subobject of scalar?");
3299       if (O->isComplexInt()) {
3300         return handler.found(Index ? O->getComplexIntImag()
3301                                    : O->getComplexIntReal(), ObjType);
3302       } else {
3303         assert(O->isComplexFloat());
3304         return handler.found(Index ? O->getComplexFloatImag()
3305                                    : O->getComplexFloatReal(), ObjType);
3306       }
3307     } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
3308       if (Field->isMutable() &&
3309           !Obj.mayAccessMutableMembers(Info, handler.AccessKind)) {
3310         Info.FFDiag(E, diag::note_constexpr_access_mutable, 1)
3311           << handler.AccessKind << Field;
3312         Info.Note(Field->getLocation(), diag::note_declared_at);
3313         return handler.failed();
3314       }
3315 
3316       // Next subobject is a class, struct or union field.
3317       RecordDecl *RD = ObjType->castAs<RecordType>()->getDecl();
3318       if (RD->isUnion()) {
3319         const FieldDecl *UnionField = O->getUnionField();
3320         if (!UnionField ||
3321             UnionField->getCanonicalDecl() != Field->getCanonicalDecl()) {
3322           if (I == N - 1 && handler.AccessKind == AK_Construct) {
3323             // Placement new onto an inactive union member makes it active.
3324             O->setUnion(Field, APValue());
3325           } else {
3326             // FIXME: If O->getUnionValue() is absent, report that there's no
3327             // active union member rather than reporting the prior active union
3328             // member. We'll need to fix nullptr_t to not use APValue() as its
3329             // representation first.
3330             Info.FFDiag(E, diag::note_constexpr_access_inactive_union_member)
3331                 << handler.AccessKind << Field << !UnionField << UnionField;
3332             return handler.failed();
3333           }
3334         }
3335         O = &O->getUnionValue();
3336       } else
3337         O = &O->getStructField(Field->getFieldIndex());
3338 
3339       ObjType = getSubobjectType(ObjType, Field->getType(), Field->isMutable());
3340       LastField = Field;
3341       if (Field->getType().isVolatileQualified())
3342         VolatileField = Field;
3343     } else {
3344       // Next subobject is a base class.
3345       const CXXRecordDecl *Derived = ObjType->getAsCXXRecordDecl();
3346       const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]);
3347       O = &O->getStructBase(getBaseIndex(Derived, Base));
3348 
3349       ObjType = getSubobjectType(ObjType, Info.Ctx.getRecordType(Base));
3350     }
3351   }
3352 }
3353 
3354 namespace {
3355 struct ExtractSubobjectHandler {
3356   EvalInfo &Info;
3357   const Expr *E;
3358   APValue &Result;
3359   const AccessKinds AccessKind;
3360 
3361   typedef bool result_type;
3362   bool failed() { return false; }
3363   bool found(APValue &Subobj, QualType SubobjType) {
3364     Result = Subobj;
3365     if (AccessKind == AK_ReadObjectRepresentation)
3366       return true;
3367     return CheckFullyInitialized(Info, E->getExprLoc(), SubobjType, Result);
3368   }
3369   bool found(APSInt &Value, QualType SubobjType) {
3370     Result = APValue(Value);
3371     return true;
3372   }
3373   bool found(APFloat &Value, QualType SubobjType) {
3374     Result = APValue(Value);
3375     return true;
3376   }
3377 };
3378 } // end anonymous namespace
3379 
3380 /// Extract the designated sub-object of an rvalue.
3381 static bool extractSubobject(EvalInfo &Info, const Expr *E,
3382                              const CompleteObject &Obj,
3383                              const SubobjectDesignator &Sub, APValue &Result,
3384                              AccessKinds AK = AK_Read) {
3385   assert(AK == AK_Read || AK == AK_ReadObjectRepresentation);
3386   ExtractSubobjectHandler Handler = {Info, E, Result, AK};
3387   return findSubobject(Info, E, Obj, Sub, Handler);
3388 }
3389 
3390 namespace {
3391 struct ModifySubobjectHandler {
3392   EvalInfo &Info;
3393   APValue &NewVal;
3394   const Expr *E;
3395 
3396   typedef bool result_type;
3397   static const AccessKinds AccessKind = AK_Assign;
3398 
3399   bool checkConst(QualType QT) {
3400     // Assigning to a const object has undefined behavior.
3401     if (QT.isConstQualified()) {
3402       Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3403       return false;
3404     }
3405     return true;
3406   }
3407 
3408   bool failed() { return false; }
3409   bool found(APValue &Subobj, QualType SubobjType) {
3410     if (!checkConst(SubobjType))
3411       return false;
3412     // We've been given ownership of NewVal, so just swap it in.
3413     Subobj.swap(NewVal);
3414     return true;
3415   }
3416   bool found(APSInt &Value, QualType SubobjType) {
3417     if (!checkConst(SubobjType))
3418       return false;
3419     if (!NewVal.isInt()) {
3420       // Maybe trying to write a cast pointer value into a complex?
3421       Info.FFDiag(E);
3422       return false;
3423     }
3424     Value = NewVal.getInt();
3425     return true;
3426   }
3427   bool found(APFloat &Value, QualType SubobjType) {
3428     if (!checkConst(SubobjType))
3429       return false;
3430     Value = NewVal.getFloat();
3431     return true;
3432   }
3433 };
3434 } // end anonymous namespace
3435 
3436 const AccessKinds ModifySubobjectHandler::AccessKind;
3437 
3438 /// Update the designated sub-object of an rvalue to the given value.
3439 static bool modifySubobject(EvalInfo &Info, const Expr *E,
3440                             const CompleteObject &Obj,
3441                             const SubobjectDesignator &Sub,
3442                             APValue &NewVal) {
3443   ModifySubobjectHandler Handler = { Info, NewVal, E };
3444   return findSubobject(Info, E, Obj, Sub, Handler);
3445 }
3446 
3447 /// Find the position where two subobject designators diverge, or equivalently
3448 /// the length of the common initial subsequence.
3449 static unsigned FindDesignatorMismatch(QualType ObjType,
3450                                        const SubobjectDesignator &A,
3451                                        const SubobjectDesignator &B,
3452                                        bool &WasArrayIndex) {
3453   unsigned I = 0, N = std::min(A.Entries.size(), B.Entries.size());
3454   for (/**/; I != N; ++I) {
3455     if (!ObjType.isNull() &&
3456         (ObjType->isArrayType() || ObjType->isAnyComplexType())) {
3457       // Next subobject is an array element.
3458       if (A.Entries[I].getAsArrayIndex() != B.Entries[I].getAsArrayIndex()) {
3459         WasArrayIndex = true;
3460         return I;
3461       }
3462       if (ObjType->isAnyComplexType())
3463         ObjType = ObjType->castAs<ComplexType>()->getElementType();
3464       else
3465         ObjType = ObjType->castAsArrayTypeUnsafe()->getElementType();
3466     } else {
3467       if (A.Entries[I].getAsBaseOrMember() !=
3468           B.Entries[I].getAsBaseOrMember()) {
3469         WasArrayIndex = false;
3470         return I;
3471       }
3472       if (const FieldDecl *FD = getAsField(A.Entries[I]))
3473         // Next subobject is a field.
3474         ObjType = FD->getType();
3475       else
3476         // Next subobject is a base class.
3477         ObjType = QualType();
3478     }
3479   }
3480   WasArrayIndex = false;
3481   return I;
3482 }
3483 
3484 /// Determine whether the given subobject designators refer to elements of the
3485 /// same array object.
3486 static bool AreElementsOfSameArray(QualType ObjType,
3487                                    const SubobjectDesignator &A,
3488                                    const SubobjectDesignator &B) {
3489   if (A.Entries.size() != B.Entries.size())
3490     return false;
3491 
3492   bool IsArray = A.MostDerivedIsArrayElement;
3493   if (IsArray && A.MostDerivedPathLength != A.Entries.size())
3494     // A is a subobject of the array element.
3495     return false;
3496 
3497   // If A (and B) designates an array element, the last entry will be the array
3498   // index. That doesn't have to match. Otherwise, we're in the 'implicit array
3499   // of length 1' case, and the entire path must match.
3500   bool WasArrayIndex;
3501   unsigned CommonLength = FindDesignatorMismatch(ObjType, A, B, WasArrayIndex);
3502   return CommonLength >= A.Entries.size() - IsArray;
3503 }
3504 
3505 /// Find the complete object to which an LValue refers.
3506 static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
3507                                          AccessKinds AK, const LValue &LVal,
3508                                          QualType LValType) {
3509   if (LVal.InvalidBase) {
3510     Info.FFDiag(E);
3511     return CompleteObject();
3512   }
3513 
3514   if (!LVal.Base) {
3515     Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
3516     return CompleteObject();
3517   }
3518 
3519   CallStackFrame *Frame = nullptr;
3520   unsigned Depth = 0;
3521   if (LVal.getLValueCallIndex()) {
3522     std::tie(Frame, Depth) =
3523         Info.getCallFrameAndDepth(LVal.getLValueCallIndex());
3524     if (!Frame) {
3525       Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1)
3526         << AK << LVal.Base.is<const ValueDecl*>();
3527       NoteLValueLocation(Info, LVal.Base);
3528       return CompleteObject();
3529     }
3530   }
3531 
3532   bool IsAccess = isAnyAccess(AK);
3533 
3534   // C++11 DR1311: An lvalue-to-rvalue conversion on a volatile-qualified type
3535   // is not a constant expression (even if the object is non-volatile). We also
3536   // apply this rule to C++98, in order to conform to the expected 'volatile'
3537   // semantics.
3538   if (isFormalAccess(AK) && LValType.isVolatileQualified()) {
3539     if (Info.getLangOpts().CPlusPlus)
3540       Info.FFDiag(E, diag::note_constexpr_access_volatile_type)
3541         << AK << LValType;
3542     else
3543       Info.FFDiag(E);
3544     return CompleteObject();
3545   }
3546 
3547   // Compute value storage location and type of base object.
3548   APValue *BaseVal = nullptr;
3549   QualType BaseType = getType(LVal.Base);
3550 
3551   if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl*>()) {
3552     // In C++98, const, non-volatile integers initialized with ICEs are ICEs.
3553     // In C++11, constexpr, non-volatile variables initialized with constant
3554     // expressions are constant expressions too. Inside constexpr functions,
3555     // parameters are constant expressions even if they're non-const.
3556     // In C++1y, objects local to a constant expression (those with a Frame) are
3557     // both readable and writable inside constant expressions.
3558     // In C, such things can also be folded, although they are not ICEs.
3559     const VarDecl *VD = dyn_cast<VarDecl>(D);
3560     if (VD) {
3561       if (const VarDecl *VDef = VD->getDefinition(Info.Ctx))
3562         VD = VDef;
3563     }
3564     if (!VD || VD->isInvalidDecl()) {
3565       Info.FFDiag(E);
3566       return CompleteObject();
3567     }
3568 
3569     // Unless we're looking at a local variable or argument in a constexpr call,
3570     // the variable we're reading must be const.
3571     if (!Frame) {
3572       if (Info.getLangOpts().CPlusPlus14 &&
3573           lifetimeStartedInEvaluation(Info, LVal.Base)) {
3574         // OK, we can read and modify an object if we're in the process of
3575         // evaluating its initializer, because its lifetime began in this
3576         // evaluation.
3577       } else if (isModification(AK)) {
3578         // All the remaining cases do not permit modification of the object.
3579         Info.FFDiag(E, diag::note_constexpr_modify_global);
3580         return CompleteObject();
3581       } else if (VD->isConstexpr()) {
3582         // OK, we can read this variable.
3583       } else if (BaseType->isIntegralOrEnumerationType()) {
3584         // In OpenCL if a variable is in constant address space it is a const
3585         // value.
3586         if (!(BaseType.isConstQualified() ||
3587               (Info.getLangOpts().OpenCL &&
3588                BaseType.getAddressSpace() == LangAS::opencl_constant))) {
3589           if (!IsAccess)
3590             return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
3591           if (Info.getLangOpts().CPlusPlus) {
3592             Info.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;
3593             Info.Note(VD->getLocation(), diag::note_declared_at);
3594           } else {
3595             Info.FFDiag(E);
3596           }
3597           return CompleteObject();
3598         }
3599       } else if (!IsAccess) {
3600         return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
3601       } else if (BaseType->isFloatingType() && BaseType.isConstQualified()) {
3602         // We support folding of const floating-point types, in order to make
3603         // static const data members of such types (supported as an extension)
3604         // more useful.
3605         if (Info.getLangOpts().CPlusPlus11) {
3606           Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
3607           Info.Note(VD->getLocation(), diag::note_declared_at);
3608         } else {
3609           Info.CCEDiag(E);
3610         }
3611       } else if (BaseType.isConstQualified() && VD->hasDefinition(Info.Ctx)) {
3612         Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr) << VD;
3613         // Keep evaluating to see what we can do.
3614       } else {
3615         // FIXME: Allow folding of values of any literal type in all languages.
3616         if (Info.checkingPotentialConstantExpression() &&
3617             VD->getType().isConstQualified() && !VD->hasDefinition(Info.Ctx)) {
3618           // The definition of this variable could be constexpr. We can't
3619           // access it right now, but may be able to in future.
3620         } else if (Info.getLangOpts().CPlusPlus11) {
3621           Info.FFDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
3622           Info.Note(VD->getLocation(), diag::note_declared_at);
3623         } else {
3624           Info.FFDiag(E);
3625         }
3626         return CompleteObject();
3627       }
3628     }
3629 
3630     if (!evaluateVarDeclInit(Info, E, VD, Frame, BaseVal, &LVal))
3631       return CompleteObject();
3632   } else if (DynamicAllocLValue DA = LVal.Base.dyn_cast<DynamicAllocLValue>()) {
3633     Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA);
3634     if (!Alloc) {
3635       Info.FFDiag(E, diag::note_constexpr_access_deleted_object) << AK;
3636       return CompleteObject();
3637     }
3638     return CompleteObject(LVal.Base, &(*Alloc)->Value,
3639                           LVal.Base.getDynamicAllocType());
3640   } else {
3641     const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3642 
3643     if (!Frame) {
3644       if (const MaterializeTemporaryExpr *MTE =
3645               dyn_cast_or_null<MaterializeTemporaryExpr>(Base)) {
3646         assert(MTE->getStorageDuration() == SD_Static &&
3647                "should have a frame for a non-global materialized temporary");
3648 
3649         // Per C++1y [expr.const]p2:
3650         //  an lvalue-to-rvalue conversion [is not allowed unless it applies to]
3651         //   - a [...] glvalue of integral or enumeration type that refers to
3652         //     a non-volatile const object [...]
3653         //   [...]
3654         //   - a [...] glvalue of literal type that refers to a non-volatile
3655         //     object whose lifetime began within the evaluation of e.
3656         //
3657         // C++11 misses the 'began within the evaluation of e' check and
3658         // instead allows all temporaries, including things like:
3659         //   int &&r = 1;
3660         //   int x = ++r;
3661         //   constexpr int k = r;
3662         // Therefore we use the C++14 rules in C++11 too.
3663         //
3664         // Note that temporaries whose lifetimes began while evaluating a
3665         // variable's constructor are not usable while evaluating the
3666         // corresponding destructor, not even if they're of const-qualified
3667         // types.
3668         if (!(BaseType.isConstQualified() &&
3669               BaseType->isIntegralOrEnumerationType()) &&
3670             !lifetimeStartedInEvaluation(Info, LVal.Base)) {
3671           if (!IsAccess)
3672             return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
3673           Info.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
3674           Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here);
3675           return CompleteObject();
3676         }
3677 
3678         BaseVal = MTE->getOrCreateValue(false);
3679         assert(BaseVal && "got reference to unevaluated temporary");
3680       } else {
3681         if (!IsAccess)
3682           return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
3683         APValue Val;
3684         LVal.moveInto(Val);
3685         Info.FFDiag(E, diag::note_constexpr_access_unreadable_object)
3686             << AK
3687             << Val.getAsString(Info.Ctx,
3688                                Info.Ctx.getLValueReferenceType(LValType));
3689         NoteLValueLocation(Info, LVal.Base);
3690         return CompleteObject();
3691       }
3692     } else {
3693       BaseVal = Frame->getTemporary(Base, LVal.Base.getVersion());
3694       assert(BaseVal && "missing value for temporary");
3695     }
3696   }
3697 
3698   // In C++14, we can't safely access any mutable state when we might be
3699   // evaluating after an unmodeled side effect.
3700   //
3701   // FIXME: Not all local state is mutable. Allow local constant subobjects
3702   // to be read here (but take care with 'mutable' fields).
3703   if ((Frame && Info.getLangOpts().CPlusPlus14 &&
3704        Info.EvalStatus.HasSideEffects) ||
3705       (isModification(AK) && Depth < Info.SpeculativeEvaluationDepth))
3706     return CompleteObject();
3707 
3708   return CompleteObject(LVal.getLValueBase(), BaseVal, BaseType);
3709 }
3710 
3711 /// Perform an lvalue-to-rvalue conversion on the given glvalue. This
3712 /// can also be used for 'lvalue-to-lvalue' conversions for looking up the
3713 /// glvalue referred to by an entity of reference type.
3714 ///
3715 /// \param Info - Information about the ongoing evaluation.
3716 /// \param Conv - The expression for which we are performing the conversion.
3717 ///               Used for diagnostics.
3718 /// \param Type - The type of the glvalue (before stripping cv-qualifiers in the
3719 ///               case of a non-class type).
3720 /// \param LVal - The glvalue on which we are attempting to perform this action.
3721 /// \param RVal - The produced value will be placed here.
3722 /// \param WantObjectRepresentation - If true, we're looking for the object
3723 ///               representation rather than the value, and in particular,
3724 ///               there is no requirement that the result be fully initialized.
3725 static bool
3726 handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, QualType Type,
3727                                const LValue &LVal, APValue &RVal,
3728                                bool WantObjectRepresentation = false) {
3729   if (LVal.Designator.Invalid)
3730     return false;
3731 
3732   // Check for special cases where there is no existing APValue to look at.
3733   const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3734 
3735   AccessKinds AK =
3736       WantObjectRepresentation ? AK_ReadObjectRepresentation : AK_Read;
3737 
3738   if (Base && !LVal.getLValueCallIndex() && !Type.isVolatileQualified()) {
3739     if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
3740       // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the
3741       // initializer until now for such expressions. Such an expression can't be
3742       // an ICE in C, so this only matters for fold.
3743       if (Type.isVolatileQualified()) {
3744         Info.FFDiag(Conv);
3745         return false;
3746       }
3747       APValue Lit;
3748       if (!Evaluate(Lit, Info, CLE->getInitializer()))
3749         return false;
3750       CompleteObject LitObj(LVal.Base, &Lit, Base->getType());
3751       return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal, AK);
3752     } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) {
3753       // Special-case character extraction so we don't have to construct an
3754       // APValue for the whole string.
3755       assert(LVal.Designator.Entries.size() <= 1 &&
3756              "Can only read characters from string literals");
3757       if (LVal.Designator.Entries.empty()) {
3758         // Fail for now for LValue to RValue conversion of an array.
3759         // (This shouldn't show up in C/C++, but it could be triggered by a
3760         // weird EvaluateAsRValue call from a tool.)
3761         Info.FFDiag(Conv);
3762         return false;
3763       }
3764       if (LVal.Designator.isOnePastTheEnd()) {
3765         if (Info.getLangOpts().CPlusPlus11)
3766           Info.FFDiag(Conv, diag::note_constexpr_access_past_end) << AK;
3767         else
3768           Info.FFDiag(Conv);
3769         return false;
3770       }
3771       uint64_t CharIndex = LVal.Designator.Entries[0].getAsArrayIndex();
3772       RVal = APValue(extractStringLiteralCharacter(Info, Base, CharIndex));
3773       return true;
3774     }
3775   }
3776 
3777   CompleteObject Obj = findCompleteObject(Info, Conv, AK, LVal, Type);
3778   return Obj && extractSubobject(Info, Conv, Obj, LVal.Designator, RVal, AK);
3779 }
3780 
3781 /// Perform an assignment of Val to LVal. Takes ownership of Val.
3782 static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal,
3783                              QualType LValType, APValue &Val) {
3784   if (LVal.Designator.Invalid)
3785     return false;
3786 
3787   if (!Info.getLangOpts().CPlusPlus14) {
3788     Info.FFDiag(E);
3789     return false;
3790   }
3791 
3792   CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
3793   return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val);
3794 }
3795 
3796 namespace {
3797 struct CompoundAssignSubobjectHandler {
3798   EvalInfo &Info;
3799   const Expr *E;
3800   QualType PromotedLHSType;
3801   BinaryOperatorKind Opcode;
3802   const APValue &RHS;
3803 
3804   static const AccessKinds AccessKind = AK_Assign;
3805 
3806   typedef bool result_type;
3807 
3808   bool checkConst(QualType QT) {
3809     // Assigning to a const object has undefined behavior.
3810     if (QT.isConstQualified()) {
3811       Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3812       return false;
3813     }
3814     return true;
3815   }
3816 
3817   bool failed() { return false; }
3818   bool found(APValue &Subobj, QualType SubobjType) {
3819     switch (Subobj.getKind()) {
3820     case APValue::Int:
3821       return found(Subobj.getInt(), SubobjType);
3822     case APValue::Float:
3823       return found(Subobj.getFloat(), SubobjType);
3824     case APValue::ComplexInt:
3825     case APValue::ComplexFloat:
3826       // FIXME: Implement complex compound assignment.
3827       Info.FFDiag(E);
3828       return false;
3829     case APValue::LValue:
3830       return foundPointer(Subobj, SubobjType);
3831     default:
3832       // FIXME: can this happen?
3833       Info.FFDiag(E);
3834       return false;
3835     }
3836   }
3837   bool found(APSInt &Value, QualType SubobjType) {
3838     if (!checkConst(SubobjType))
3839       return false;
3840 
3841     if (!SubobjType->isIntegerType()) {
3842       // We don't support compound assignment on integer-cast-to-pointer
3843       // values.
3844       Info.FFDiag(E);
3845       return false;
3846     }
3847 
3848     if (RHS.isInt()) {
3849       APSInt LHS =
3850           HandleIntToIntCast(Info, E, PromotedLHSType, SubobjType, Value);
3851       if (!handleIntIntBinOp(Info, E, LHS, Opcode, RHS.getInt(), LHS))
3852         return false;
3853       Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS);
3854       return true;
3855     } else if (RHS.isFloat()) {
3856       APFloat FValue(0.0);
3857       return HandleIntToFloatCast(Info, E, SubobjType, Value, PromotedLHSType,
3858                                   FValue) &&
3859              handleFloatFloatBinOp(Info, E, FValue, Opcode, RHS.getFloat()) &&
3860              HandleFloatToIntCast(Info, E, PromotedLHSType, FValue, SubobjType,
3861                                   Value);
3862     }
3863 
3864     Info.FFDiag(E);
3865     return false;
3866   }
3867   bool found(APFloat &Value, QualType SubobjType) {
3868     return checkConst(SubobjType) &&
3869            HandleFloatToFloatCast(Info, E, SubobjType, PromotedLHSType,
3870                                   Value) &&
3871            handleFloatFloatBinOp(Info, E, Value, Opcode, RHS.getFloat()) &&
3872            HandleFloatToFloatCast(Info, E, PromotedLHSType, SubobjType, Value);
3873   }
3874   bool foundPointer(APValue &Subobj, QualType SubobjType) {
3875     if (!checkConst(SubobjType))
3876       return false;
3877 
3878     QualType PointeeType;
3879     if (const PointerType *PT = SubobjType->getAs<PointerType>())
3880       PointeeType = PT->getPointeeType();
3881 
3882     if (PointeeType.isNull() || !RHS.isInt() ||
3883         (Opcode != BO_Add && Opcode != BO_Sub)) {
3884       Info.FFDiag(E);
3885       return false;
3886     }
3887 
3888     APSInt Offset = RHS.getInt();
3889     if (Opcode == BO_Sub)
3890       negateAsSigned(Offset);
3891 
3892     LValue LVal;
3893     LVal.setFrom(Info.Ctx, Subobj);
3894     if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, Offset))
3895       return false;
3896     LVal.moveInto(Subobj);
3897     return true;
3898   }
3899 };
3900 } // end anonymous namespace
3901 
3902 const AccessKinds CompoundAssignSubobjectHandler::AccessKind;
3903 
3904 /// Perform a compound assignment of LVal <op>= RVal.
3905 static bool handleCompoundAssignment(
3906     EvalInfo &Info, const Expr *E,
3907     const LValue &LVal, QualType LValType, QualType PromotedLValType,
3908     BinaryOperatorKind Opcode, const APValue &RVal) {
3909   if (LVal.Designator.Invalid)
3910     return false;
3911 
3912   if (!Info.getLangOpts().CPlusPlus14) {
3913     Info.FFDiag(E);
3914     return false;
3915   }
3916 
3917   CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
3918   CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode,
3919                                              RVal };
3920   return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
3921 }
3922 
3923 namespace {
3924 struct IncDecSubobjectHandler {
3925   EvalInfo &Info;
3926   const UnaryOperator *E;
3927   AccessKinds AccessKind;
3928   APValue *Old;
3929 
3930   typedef bool result_type;
3931 
3932   bool checkConst(QualType QT) {
3933     // Assigning to a const object has undefined behavior.
3934     if (QT.isConstQualified()) {
3935       Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3936       return false;
3937     }
3938     return true;
3939   }
3940 
3941   bool failed() { return false; }
3942   bool found(APValue &Subobj, QualType SubobjType) {
3943     // Stash the old value. Also clear Old, so we don't clobber it later
3944     // if we're post-incrementing a complex.
3945     if (Old) {
3946       *Old = Subobj;
3947       Old = nullptr;
3948     }
3949 
3950     switch (Subobj.getKind()) {
3951     case APValue::Int:
3952       return found(Subobj.getInt(), SubobjType);
3953     case APValue::Float:
3954       return found(Subobj.getFloat(), SubobjType);
3955     case APValue::ComplexInt:
3956       return found(Subobj.getComplexIntReal(),
3957                    SubobjType->castAs<ComplexType>()->getElementType()
3958                      .withCVRQualifiers(SubobjType.getCVRQualifiers()));
3959     case APValue::ComplexFloat:
3960       return found(Subobj.getComplexFloatReal(),
3961                    SubobjType->castAs<ComplexType>()->getElementType()
3962                      .withCVRQualifiers(SubobjType.getCVRQualifiers()));
3963     case APValue::LValue:
3964       return foundPointer(Subobj, SubobjType);
3965     default:
3966       // FIXME: can this happen?
3967       Info.FFDiag(E);
3968       return false;
3969     }
3970   }
3971   bool found(APSInt &Value, QualType SubobjType) {
3972     if (!checkConst(SubobjType))
3973       return false;
3974 
3975     if (!SubobjType->isIntegerType()) {
3976       // We don't support increment / decrement on integer-cast-to-pointer
3977       // values.
3978       Info.FFDiag(E);
3979       return false;
3980     }
3981 
3982     if (Old) *Old = APValue(Value);
3983 
3984     // bool arithmetic promotes to int, and the conversion back to bool
3985     // doesn't reduce mod 2^n, so special-case it.
3986     if (SubobjType->isBooleanType()) {
3987       if (AccessKind == AK_Increment)
3988         Value = 1;
3989       else
3990         Value = !Value;
3991       return true;
3992     }
3993 
3994     bool WasNegative = Value.isNegative();
3995     if (AccessKind == AK_Increment) {
3996       ++Value;
3997 
3998       if (!WasNegative && Value.isNegative() && E->canOverflow()) {
3999         APSInt ActualValue(Value, /*IsUnsigned*/true);
4000         return HandleOverflow(Info, E, ActualValue, SubobjType);
4001       }
4002     } else {
4003       --Value;
4004 
4005       if (WasNegative && !Value.isNegative() && E->canOverflow()) {
4006         unsigned BitWidth = Value.getBitWidth();
4007         APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false);
4008         ActualValue.setBit(BitWidth);
4009         return HandleOverflow(Info, E, ActualValue, SubobjType);
4010       }
4011     }
4012     return true;
4013   }
4014   bool found(APFloat &Value, QualType SubobjType) {
4015     if (!checkConst(SubobjType))
4016       return false;
4017 
4018     if (Old) *Old = APValue(Value);
4019 
4020     APFloat One(Value.getSemantics(), 1);
4021     if (AccessKind == AK_Increment)
4022       Value.add(One, APFloat::rmNearestTiesToEven);
4023     else
4024       Value.subtract(One, APFloat::rmNearestTiesToEven);
4025     return true;
4026   }
4027   bool foundPointer(APValue &Subobj, QualType SubobjType) {
4028     if (!checkConst(SubobjType))
4029       return false;
4030 
4031     QualType PointeeType;
4032     if (const PointerType *PT = SubobjType->getAs<PointerType>())
4033       PointeeType = PT->getPointeeType();
4034     else {
4035       Info.FFDiag(E);
4036       return false;
4037     }
4038 
4039     LValue LVal;
4040     LVal.setFrom(Info.Ctx, Subobj);
4041     if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType,
4042                                      AccessKind == AK_Increment ? 1 : -1))
4043       return false;
4044     LVal.moveInto(Subobj);
4045     return true;
4046   }
4047 };
4048 } // end anonymous namespace
4049 
4050 /// Perform an increment or decrement on LVal.
4051 static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal,
4052                          QualType LValType, bool IsIncrement, APValue *Old) {
4053   if (LVal.Designator.Invalid)
4054     return false;
4055 
4056   if (!Info.getLangOpts().CPlusPlus14) {
4057     Info.FFDiag(E);
4058     return false;
4059   }
4060 
4061   AccessKinds AK = IsIncrement ? AK_Increment : AK_Decrement;
4062   CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType);
4063   IncDecSubobjectHandler Handler = {Info, cast<UnaryOperator>(E), AK, Old};
4064   return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
4065 }
4066 
4067 /// Build an lvalue for the object argument of a member function call.
4068 static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
4069                                    LValue &This) {
4070   if (Object->getType()->isPointerType() && Object->isRValue())
4071     return EvaluatePointer(Object, This, Info);
4072 
4073   if (Object->isGLValue())
4074     return EvaluateLValue(Object, This, Info);
4075 
4076   if (Object->getType()->isLiteralType(Info.Ctx))
4077     return EvaluateTemporary(Object, This, Info);
4078 
4079   Info.FFDiag(Object, diag::note_constexpr_nonliteral) << Object->getType();
4080   return false;
4081 }
4082 
4083 /// HandleMemberPointerAccess - Evaluate a member access operation and build an
4084 /// lvalue referring to the result.
4085 ///
4086 /// \param Info - Information about the ongoing evaluation.
4087 /// \param LV - An lvalue referring to the base of the member pointer.
4088 /// \param RHS - The member pointer expression.
4089 /// \param IncludeMember - Specifies whether the member itself is included in
4090 ///        the resulting LValue subobject designator. This is not possible when
4091 ///        creating a bound member function.
4092 /// \return The field or method declaration to which the member pointer refers,
4093 ///         or 0 if evaluation fails.
4094 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
4095                                                   QualType LVType,
4096                                                   LValue &LV,
4097                                                   const Expr *RHS,
4098                                                   bool IncludeMember = true) {
4099   MemberPtr MemPtr;
4100   if (!EvaluateMemberPointer(RHS, MemPtr, Info))
4101     return nullptr;
4102 
4103   // C++11 [expr.mptr.oper]p6: If the second operand is the null pointer to
4104   // member value, the behavior is undefined.
4105   if (!MemPtr.getDecl()) {
4106     // FIXME: Specific diagnostic.
4107     Info.FFDiag(RHS);
4108     return nullptr;
4109   }
4110 
4111   if (MemPtr.isDerivedMember()) {
4112     // This is a member of some derived class. Truncate LV appropriately.
4113     // The end of the derived-to-base path for the base object must match the
4114     // derived-to-base path for the member pointer.
4115     if (LV.Designator.MostDerivedPathLength + MemPtr.Path.size() >
4116         LV.Designator.Entries.size()) {
4117       Info.FFDiag(RHS);
4118       return nullptr;
4119     }
4120     unsigned PathLengthToMember =
4121         LV.Designator.Entries.size() - MemPtr.Path.size();
4122     for (unsigned I = 0, N = MemPtr.Path.size(); I != N; ++I) {
4123       const CXXRecordDecl *LVDecl = getAsBaseClass(
4124           LV.Designator.Entries[PathLengthToMember + I]);
4125       const CXXRecordDecl *MPDecl = MemPtr.Path[I];
4126       if (LVDecl->getCanonicalDecl() != MPDecl->getCanonicalDecl()) {
4127         Info.FFDiag(RHS);
4128         return nullptr;
4129       }
4130     }
4131 
4132     // Truncate the lvalue to the appropriate derived class.
4133     if (!CastToDerivedClass(Info, RHS, LV, MemPtr.getContainingRecord(),
4134                             PathLengthToMember))
4135       return nullptr;
4136   } else if (!MemPtr.Path.empty()) {
4137     // Extend the LValue path with the member pointer's path.
4138     LV.Designator.Entries.reserve(LV.Designator.Entries.size() +
4139                                   MemPtr.Path.size() + IncludeMember);
4140 
4141     // Walk down to the appropriate base class.
4142     if (const PointerType *PT = LVType->getAs<PointerType>())
4143       LVType = PT->getPointeeType();
4144     const CXXRecordDecl *RD = LVType->getAsCXXRecordDecl();
4145     assert(RD && "member pointer access on non-class-type expression");
4146     // The first class in the path is that of the lvalue.
4147     for (unsigned I = 1, N = MemPtr.Path.size(); I != N; ++I) {
4148       const CXXRecordDecl *Base = MemPtr.Path[N - I - 1];
4149       if (!HandleLValueDirectBase(Info, RHS, LV, RD, Base))
4150         return nullptr;
4151       RD = Base;
4152     }
4153     // Finally cast to the class containing the member.
4154     if (!HandleLValueDirectBase(Info, RHS, LV, RD,
4155                                 MemPtr.getContainingRecord()))
4156       return nullptr;
4157   }
4158 
4159   // Add the member. Note that we cannot build bound member functions here.
4160   if (IncludeMember) {
4161     if (const FieldDecl *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) {
4162       if (!HandleLValueMember(Info, RHS, LV, FD))
4163         return nullptr;
4164     } else if (const IndirectFieldDecl *IFD =
4165                  dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) {
4166       if (!HandleLValueIndirectMember(Info, RHS, LV, IFD))
4167         return nullptr;
4168     } else {
4169       llvm_unreachable("can't construct reference to bound member function");
4170     }
4171   }
4172 
4173   return MemPtr.getDecl();
4174 }
4175 
4176 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
4177                                                   const BinaryOperator *BO,
4178                                                   LValue &LV,
4179                                                   bool IncludeMember = true) {
4180   assert(BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI);
4181 
4182   if (!EvaluateObjectArgument(Info, BO->getLHS(), LV)) {
4183     if (Info.noteFailure()) {
4184       MemberPtr MemPtr;
4185       EvaluateMemberPointer(BO->getRHS(), MemPtr, Info);
4186     }
4187     return nullptr;
4188   }
4189 
4190   return HandleMemberPointerAccess(Info, BO->getLHS()->getType(), LV,
4191                                    BO->getRHS(), IncludeMember);
4192 }
4193 
4194 /// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on
4195 /// the provided lvalue, which currently refers to the base object.
4196 static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E,
4197                                     LValue &Result) {
4198   SubobjectDesignator &D = Result.Designator;
4199   if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
4200     return false;
4201 
4202   QualType TargetQT = E->getType();
4203   if (const PointerType *PT = TargetQT->getAs<PointerType>())
4204     TargetQT = PT->getPointeeType();
4205 
4206   // Check this cast lands within the final derived-to-base subobject path.
4207   if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) {
4208     Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
4209       << D.MostDerivedType << TargetQT;
4210     return false;
4211   }
4212 
4213   // Check the type of the final cast. We don't need to check the path,
4214   // since a cast can only be formed if the path is unique.
4215   unsigned NewEntriesSize = D.Entries.size() - E->path_size();
4216   const CXXRecordDecl *TargetType = TargetQT->getAsCXXRecordDecl();
4217   const CXXRecordDecl *FinalType;
4218   if (NewEntriesSize == D.MostDerivedPathLength)
4219     FinalType = D.MostDerivedType->getAsCXXRecordDecl();
4220   else
4221     FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
4222   if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) {
4223     Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
4224       << D.MostDerivedType << TargetQT;
4225     return false;
4226   }
4227 
4228   // Truncate the lvalue to the appropriate derived class.
4229   return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize);
4230 }
4231 
4232 /// Get the value to use for a default-initialized object of type T.
4233 static APValue getDefaultInitValue(QualType T) {
4234   if (auto *RD = T->getAsCXXRecordDecl()) {
4235     if (RD->isUnion())
4236       return APValue((const FieldDecl*)nullptr);
4237 
4238     APValue Struct(APValue::UninitStruct(), RD->getNumBases(),
4239                    std::distance(RD->field_begin(), RD->field_end()));
4240 
4241     unsigned Index = 0;
4242     for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
4243            End = RD->bases_end(); I != End; ++I, ++Index)
4244       Struct.getStructBase(Index) = getDefaultInitValue(I->getType());
4245 
4246     for (const auto *I : RD->fields()) {
4247       if (I->isUnnamedBitfield())
4248         continue;
4249       Struct.getStructField(I->getFieldIndex()) =
4250           getDefaultInitValue(I->getType());
4251     }
4252     return Struct;
4253   }
4254 
4255   if (auto *AT =
4256           dyn_cast_or_null<ConstantArrayType>(T->getAsArrayTypeUnsafe())) {
4257     APValue Array(APValue::UninitArray(), 0, AT->getSize().getZExtValue());
4258     if (Array.hasArrayFiller())
4259       Array.getArrayFiller() = getDefaultInitValue(AT->getElementType());
4260     return Array;
4261   }
4262 
4263   return APValue::IndeterminateValue();
4264 }
4265 
4266 namespace {
4267 enum EvalStmtResult {
4268   /// Evaluation failed.
4269   ESR_Failed,
4270   /// Hit a 'return' statement.
4271   ESR_Returned,
4272   /// Evaluation succeeded.
4273   ESR_Succeeded,
4274   /// Hit a 'continue' statement.
4275   ESR_Continue,
4276   /// Hit a 'break' statement.
4277   ESR_Break,
4278   /// Still scanning for 'case' or 'default' statement.
4279   ESR_CaseNotFound
4280 };
4281 }
4282 
4283 static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD) {
4284   // We don't need to evaluate the initializer for a static local.
4285   if (!VD->hasLocalStorage())
4286     return true;
4287 
4288   LValue Result;
4289   APValue &Val =
4290       Info.CurrentCall->createTemporary(VD, VD->getType(), true, Result);
4291 
4292   const Expr *InitE = VD->getInit();
4293   if (!InitE) {
4294     Val = getDefaultInitValue(VD->getType());
4295     return true;
4296   }
4297 
4298   if (InitE->isValueDependent())
4299     return false;
4300 
4301   if (!EvaluateInPlace(Val, Info, Result, InitE)) {
4302     // Wipe out any partially-computed value, to allow tracking that this
4303     // evaluation failed.
4304     Val = APValue();
4305     return false;
4306   }
4307 
4308   return true;
4309 }
4310 
4311 static bool EvaluateDecl(EvalInfo &Info, const Decl *D) {
4312   bool OK = true;
4313 
4314   if (const VarDecl *VD = dyn_cast<VarDecl>(D))
4315     OK &= EvaluateVarDecl(Info, VD);
4316 
4317   if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(D))
4318     for (auto *BD : DD->bindings())
4319       if (auto *VD = BD->getHoldingVar())
4320         OK &= EvaluateDecl(Info, VD);
4321 
4322   return OK;
4323 }
4324 
4325 
4326 /// Evaluate a condition (either a variable declaration or an expression).
4327 static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
4328                          const Expr *Cond, bool &Result) {
4329   FullExpressionRAII Scope(Info);
4330   if (CondDecl && !EvaluateDecl(Info, CondDecl))
4331     return false;
4332   if (!EvaluateAsBooleanCondition(Cond, Result, Info))
4333     return false;
4334   return Scope.destroy();
4335 }
4336 
4337 namespace {
4338 /// A location where the result (returned value) of evaluating a
4339 /// statement should be stored.
4340 struct StmtResult {
4341   /// The APValue that should be filled in with the returned value.
4342   APValue &Value;
4343   /// The location containing the result, if any (used to support RVO).
4344   const LValue *Slot;
4345 };
4346 
4347 struct TempVersionRAII {
4348   CallStackFrame &Frame;
4349 
4350   TempVersionRAII(CallStackFrame &Frame) : Frame(Frame) {
4351     Frame.pushTempVersion();
4352   }
4353 
4354   ~TempVersionRAII() {
4355     Frame.popTempVersion();
4356   }
4357 };
4358 
4359 }
4360 
4361 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
4362                                    const Stmt *S,
4363                                    const SwitchCase *SC = nullptr);
4364 
4365 /// Evaluate the body of a loop, and translate the result as appropriate.
4366 static EvalStmtResult EvaluateLoopBody(StmtResult &Result, EvalInfo &Info,
4367                                        const Stmt *Body,
4368                                        const SwitchCase *Case = nullptr) {
4369   BlockScopeRAII Scope(Info);
4370 
4371   EvalStmtResult ESR = EvaluateStmt(Result, Info, Body, Case);
4372   if (ESR != ESR_Failed && ESR != ESR_CaseNotFound && !Scope.destroy())
4373     ESR = ESR_Failed;
4374 
4375   switch (ESR) {
4376   case ESR_Break:
4377     return ESR_Succeeded;
4378   case ESR_Succeeded:
4379   case ESR_Continue:
4380     return ESR_Continue;
4381   case ESR_Failed:
4382   case ESR_Returned:
4383   case ESR_CaseNotFound:
4384     return ESR;
4385   }
4386   llvm_unreachable("Invalid EvalStmtResult!");
4387 }
4388 
4389 /// Evaluate a switch statement.
4390 static EvalStmtResult EvaluateSwitch(StmtResult &Result, EvalInfo &Info,
4391                                      const SwitchStmt *SS) {
4392   BlockScopeRAII Scope(Info);
4393 
4394   // Evaluate the switch condition.
4395   APSInt Value;
4396   {
4397     if (const Stmt *Init = SS->getInit()) {
4398       EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
4399       if (ESR != ESR_Succeeded) {
4400         if (ESR != ESR_Failed && !Scope.destroy())
4401           ESR = ESR_Failed;
4402         return ESR;
4403       }
4404     }
4405 
4406     FullExpressionRAII CondScope(Info);
4407     if (SS->getConditionVariable() &&
4408         !EvaluateDecl(Info, SS->getConditionVariable()))
4409       return ESR_Failed;
4410     if (!EvaluateInteger(SS->getCond(), Value, Info))
4411       return ESR_Failed;
4412     if (!CondScope.destroy())
4413       return ESR_Failed;
4414   }
4415 
4416   // Find the switch case corresponding to the value of the condition.
4417   // FIXME: Cache this lookup.
4418   const SwitchCase *Found = nullptr;
4419   for (const SwitchCase *SC = SS->getSwitchCaseList(); SC;
4420        SC = SC->getNextSwitchCase()) {
4421     if (isa<DefaultStmt>(SC)) {
4422       Found = SC;
4423       continue;
4424     }
4425 
4426     const CaseStmt *CS = cast<CaseStmt>(SC);
4427     APSInt LHS = CS->getLHS()->EvaluateKnownConstInt(Info.Ctx);
4428     APSInt RHS = CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx)
4429                               : LHS;
4430     if (LHS <= Value && Value <= RHS) {
4431       Found = SC;
4432       break;
4433     }
4434   }
4435 
4436   if (!Found)
4437     return Scope.destroy() ? ESR_Succeeded : ESR_Failed;
4438 
4439   // Search the switch body for the switch case and evaluate it from there.
4440   EvalStmtResult ESR = EvaluateStmt(Result, Info, SS->getBody(), Found);
4441   if (ESR != ESR_Failed && ESR != ESR_CaseNotFound && !Scope.destroy())
4442     return ESR_Failed;
4443 
4444   switch (ESR) {
4445   case ESR_Break:
4446     return ESR_Succeeded;
4447   case ESR_Succeeded:
4448   case ESR_Continue:
4449   case ESR_Failed:
4450   case ESR_Returned:
4451     return ESR;
4452   case ESR_CaseNotFound:
4453     // This can only happen if the switch case is nested within a statement
4454     // expression. We have no intention of supporting that.
4455     Info.FFDiag(Found->getBeginLoc(),
4456                 diag::note_constexpr_stmt_expr_unsupported);
4457     return ESR_Failed;
4458   }
4459   llvm_unreachable("Invalid EvalStmtResult!");
4460 }
4461 
4462 // Evaluate a statement.
4463 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
4464                                    const Stmt *S, const SwitchCase *Case) {
4465   if (!Info.nextStep(S))
4466     return ESR_Failed;
4467 
4468   // If we're hunting down a 'case' or 'default' label, recurse through
4469   // substatements until we hit the label.
4470   if (Case) {
4471     switch (S->getStmtClass()) {
4472     case Stmt::CompoundStmtClass:
4473       // FIXME: Precompute which substatement of a compound statement we
4474       // would jump to, and go straight there rather than performing a
4475       // linear scan each time.
4476     case Stmt::LabelStmtClass:
4477     case Stmt::AttributedStmtClass:
4478     case Stmt::DoStmtClass:
4479       break;
4480 
4481     case Stmt::CaseStmtClass:
4482     case Stmt::DefaultStmtClass:
4483       if (Case == S)
4484         Case = nullptr;
4485       break;
4486 
4487     case Stmt::IfStmtClass: {
4488       // FIXME: Precompute which side of an 'if' we would jump to, and go
4489       // straight there rather than scanning both sides.
4490       const IfStmt *IS = cast<IfStmt>(S);
4491 
4492       // Wrap the evaluation in a block scope, in case it's a DeclStmt
4493       // preceded by our switch label.
4494       BlockScopeRAII Scope(Info);
4495 
4496       // Step into the init statement in case it brings an (uninitialized)
4497       // variable into scope.
4498       if (const Stmt *Init = IS->getInit()) {
4499         EvalStmtResult ESR = EvaluateStmt(Result, Info, Init, Case);
4500         if (ESR != ESR_CaseNotFound) {
4501           assert(ESR != ESR_Succeeded);
4502           return ESR;
4503         }
4504       }
4505 
4506       // Condition variable must be initialized if it exists.
4507       // FIXME: We can skip evaluating the body if there's a condition
4508       // variable, as there can't be any case labels within it.
4509       // (The same is true for 'for' statements.)
4510 
4511       EvalStmtResult ESR = EvaluateStmt(Result, Info, IS->getThen(), Case);
4512       if (ESR == ESR_Failed)
4513         return ESR;
4514       if (ESR != ESR_CaseNotFound)
4515         return Scope.destroy() ? ESR : ESR_Failed;
4516       if (!IS->getElse())
4517         return ESR_CaseNotFound;
4518 
4519       ESR = EvaluateStmt(Result, Info, IS->getElse(), Case);
4520       if (ESR == ESR_Failed)
4521         return ESR;
4522       if (ESR != ESR_CaseNotFound)
4523         return Scope.destroy() ? ESR : ESR_Failed;
4524       return ESR_CaseNotFound;
4525     }
4526 
4527     case Stmt::WhileStmtClass: {
4528       EvalStmtResult ESR =
4529           EvaluateLoopBody(Result, Info, cast<WhileStmt>(S)->getBody(), Case);
4530       if (ESR != ESR_Continue)
4531         return ESR;
4532       break;
4533     }
4534 
4535     case Stmt::ForStmtClass: {
4536       const ForStmt *FS = cast<ForStmt>(S);
4537       BlockScopeRAII Scope(Info);
4538 
4539       // Step into the init statement in case it brings an (uninitialized)
4540       // variable into scope.
4541       if (const Stmt *Init = FS->getInit()) {
4542         EvalStmtResult ESR = EvaluateStmt(Result, Info, Init, Case);
4543         if (ESR != ESR_CaseNotFound) {
4544           assert(ESR != ESR_Succeeded);
4545           return ESR;
4546         }
4547       }
4548 
4549       EvalStmtResult ESR =
4550           EvaluateLoopBody(Result, Info, FS->getBody(), Case);
4551       if (ESR != ESR_Continue)
4552         return ESR;
4553       if (FS->getInc()) {
4554         FullExpressionRAII IncScope(Info);
4555         if (!EvaluateIgnoredValue(Info, FS->getInc()) || !IncScope.destroy())
4556           return ESR_Failed;
4557       }
4558       break;
4559     }
4560 
4561     case Stmt::DeclStmtClass: {
4562       // Start the lifetime of any uninitialized variables we encounter. They
4563       // might be used by the selected branch of the switch.
4564       const DeclStmt *DS = cast<DeclStmt>(S);
4565       for (const auto *D : DS->decls()) {
4566         if (const auto *VD = dyn_cast<VarDecl>(D)) {
4567           if (VD->hasLocalStorage() && !VD->getInit())
4568             if (!EvaluateVarDecl(Info, VD))
4569               return ESR_Failed;
4570           // FIXME: If the variable has initialization that can't be jumped
4571           // over, bail out of any immediately-surrounding compound-statement
4572           // too. There can't be any case labels here.
4573         }
4574       }
4575       return ESR_CaseNotFound;
4576     }
4577 
4578     default:
4579       return ESR_CaseNotFound;
4580     }
4581   }
4582 
4583   switch (S->getStmtClass()) {
4584   default:
4585     if (const Expr *E = dyn_cast<Expr>(S)) {
4586       // Don't bother evaluating beyond an expression-statement which couldn't
4587       // be evaluated.
4588       // FIXME: Do we need the FullExpressionRAII object here?
4589       // VisitExprWithCleanups should create one when necessary.
4590       FullExpressionRAII Scope(Info);
4591       if (!EvaluateIgnoredValue(Info, E) || !Scope.destroy())
4592         return ESR_Failed;
4593       return ESR_Succeeded;
4594     }
4595 
4596     Info.FFDiag(S->getBeginLoc());
4597     return ESR_Failed;
4598 
4599   case Stmt::NullStmtClass:
4600     return ESR_Succeeded;
4601 
4602   case Stmt::DeclStmtClass: {
4603     const DeclStmt *DS = cast<DeclStmt>(S);
4604     for (const auto *D : DS->decls()) {
4605       // Each declaration initialization is its own full-expression.
4606       FullExpressionRAII Scope(Info);
4607       if (!EvaluateDecl(Info, D) && !Info.noteFailure())
4608         return ESR_Failed;
4609       if (!Scope.destroy())
4610         return ESR_Failed;
4611     }
4612     return ESR_Succeeded;
4613   }
4614 
4615   case Stmt::ReturnStmtClass: {
4616     const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
4617     FullExpressionRAII Scope(Info);
4618     if (RetExpr &&
4619         !(Result.Slot
4620               ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
4621               : Evaluate(Result.Value, Info, RetExpr)))
4622       return ESR_Failed;
4623     return Scope.destroy() ? ESR_Returned : ESR_Failed;
4624   }
4625 
4626   case Stmt::CompoundStmtClass: {
4627     BlockScopeRAII Scope(Info);
4628 
4629     const CompoundStmt *CS = cast<CompoundStmt>(S);
4630     for (const auto *BI : CS->body()) {
4631       EvalStmtResult ESR = EvaluateStmt(Result, Info, BI, Case);
4632       if (ESR == ESR_Succeeded)
4633         Case = nullptr;
4634       else if (ESR != ESR_CaseNotFound) {
4635         if (ESR != ESR_Failed && !Scope.destroy())
4636           return ESR_Failed;
4637         return ESR;
4638       }
4639     }
4640     if (Case)
4641       return ESR_CaseNotFound;
4642     return Scope.destroy() ? ESR_Succeeded : ESR_Failed;
4643   }
4644 
4645   case Stmt::IfStmtClass: {
4646     const IfStmt *IS = cast<IfStmt>(S);
4647 
4648     // Evaluate the condition, as either a var decl or as an expression.
4649     BlockScopeRAII Scope(Info);
4650     if (const Stmt *Init = IS->getInit()) {
4651       EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
4652       if (ESR != ESR_Succeeded) {
4653         if (ESR != ESR_Failed && !Scope.destroy())
4654           return ESR_Failed;
4655         return ESR;
4656       }
4657     }
4658     bool Cond;
4659     if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
4660       return ESR_Failed;
4661 
4662     if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
4663       EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt);
4664       if (ESR != ESR_Succeeded) {
4665         if (ESR != ESR_Failed && !Scope.destroy())
4666           return ESR_Failed;
4667         return ESR;
4668       }
4669     }
4670     return Scope.destroy() ? ESR_Succeeded : ESR_Failed;
4671   }
4672 
4673   case Stmt::WhileStmtClass: {
4674     const WhileStmt *WS = cast<WhileStmt>(S);
4675     while (true) {
4676       BlockScopeRAII Scope(Info);
4677       bool Continue;
4678       if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(),
4679                         Continue))
4680         return ESR_Failed;
4681       if (!Continue)
4682         break;
4683 
4684       EvalStmtResult ESR = EvaluateLoopBody(Result, Info, WS->getBody());
4685       if (ESR != ESR_Continue) {
4686         if (ESR != ESR_Failed && !Scope.destroy())
4687           return ESR_Failed;
4688         return ESR;
4689       }
4690       if (!Scope.destroy())
4691         return ESR_Failed;
4692     }
4693     return ESR_Succeeded;
4694   }
4695 
4696   case Stmt::DoStmtClass: {
4697     const DoStmt *DS = cast<DoStmt>(S);
4698     bool Continue;
4699     do {
4700       EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case);
4701       if (ESR != ESR_Continue)
4702         return ESR;
4703       Case = nullptr;
4704 
4705       FullExpressionRAII CondScope(Info);
4706       if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info) ||
4707           !CondScope.destroy())
4708         return ESR_Failed;
4709     } while (Continue);
4710     return ESR_Succeeded;
4711   }
4712 
4713   case Stmt::ForStmtClass: {
4714     const ForStmt *FS = cast<ForStmt>(S);
4715     BlockScopeRAII ForScope(Info);
4716     if (FS->getInit()) {
4717       EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
4718       if (ESR != ESR_Succeeded) {
4719         if (ESR != ESR_Failed && !ForScope.destroy())
4720           return ESR_Failed;
4721         return ESR;
4722       }
4723     }
4724     while (true) {
4725       BlockScopeRAII IterScope(Info);
4726       bool Continue = true;
4727       if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(),
4728                                          FS->getCond(), Continue))
4729         return ESR_Failed;
4730       if (!Continue)
4731         break;
4732 
4733       EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody());
4734       if (ESR != ESR_Continue) {
4735         if (ESR != ESR_Failed && (!IterScope.destroy() || !ForScope.destroy()))
4736           return ESR_Failed;
4737         return ESR;
4738       }
4739 
4740       if (FS->getInc()) {
4741         FullExpressionRAII IncScope(Info);
4742         if (!EvaluateIgnoredValue(Info, FS->getInc()) || !IncScope.destroy())
4743           return ESR_Failed;
4744       }
4745 
4746       if (!IterScope.destroy())
4747         return ESR_Failed;
4748     }
4749     return ForScope.destroy() ? ESR_Succeeded : ESR_Failed;
4750   }
4751 
4752   case Stmt::CXXForRangeStmtClass: {
4753     const CXXForRangeStmt *FS = cast<CXXForRangeStmt>(S);
4754     BlockScopeRAII Scope(Info);
4755 
4756     // Evaluate the init-statement if present.
4757     if (FS->getInit()) {
4758       EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
4759       if (ESR != ESR_Succeeded) {
4760         if (ESR != ESR_Failed && !Scope.destroy())
4761           return ESR_Failed;
4762         return ESR;
4763       }
4764     }
4765 
4766     // Initialize the __range variable.
4767     EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getRangeStmt());
4768     if (ESR != ESR_Succeeded) {
4769       if (ESR != ESR_Failed && !Scope.destroy())
4770         return ESR_Failed;
4771       return ESR;
4772     }
4773 
4774     // Create the __begin and __end iterators.
4775     ESR = EvaluateStmt(Result, Info, FS->getBeginStmt());
4776     if (ESR != ESR_Succeeded) {
4777       if (ESR != ESR_Failed && !Scope.destroy())
4778         return ESR_Failed;
4779       return ESR;
4780     }
4781     ESR = EvaluateStmt(Result, Info, FS->getEndStmt());
4782     if (ESR != ESR_Succeeded) {
4783       if (ESR != ESR_Failed && !Scope.destroy())
4784         return ESR_Failed;
4785       return ESR;
4786     }
4787 
4788     while (true) {
4789       // Condition: __begin != __end.
4790       {
4791         bool Continue = true;
4792         FullExpressionRAII CondExpr(Info);
4793         if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info))
4794           return ESR_Failed;
4795         if (!Continue)
4796           break;
4797       }
4798 
4799       // User's variable declaration, initialized by *__begin.
4800       BlockScopeRAII InnerScope(Info);
4801       ESR = EvaluateStmt(Result, Info, FS->getLoopVarStmt());
4802       if (ESR != ESR_Succeeded) {
4803         if (ESR != ESR_Failed && (!InnerScope.destroy() || !Scope.destroy()))
4804           return ESR_Failed;
4805         return ESR;
4806       }
4807 
4808       // Loop body.
4809       ESR = EvaluateLoopBody(Result, Info, FS->getBody());
4810       if (ESR != ESR_Continue) {
4811         if (ESR != ESR_Failed && (!InnerScope.destroy() || !Scope.destroy()))
4812           return ESR_Failed;
4813         return ESR;
4814       }
4815 
4816       // Increment: ++__begin
4817       if (!EvaluateIgnoredValue(Info, FS->getInc()))
4818         return ESR_Failed;
4819 
4820       if (!InnerScope.destroy())
4821         return ESR_Failed;
4822     }
4823 
4824     return Scope.destroy() ? ESR_Succeeded : ESR_Failed;
4825   }
4826 
4827   case Stmt::SwitchStmtClass:
4828     return EvaluateSwitch(Result, Info, cast<SwitchStmt>(S));
4829 
4830   case Stmt::ContinueStmtClass:
4831     return ESR_Continue;
4832 
4833   case Stmt::BreakStmtClass:
4834     return ESR_Break;
4835 
4836   case Stmt::LabelStmtClass:
4837     return EvaluateStmt(Result, Info, cast<LabelStmt>(S)->getSubStmt(), Case);
4838 
4839   case Stmt::AttributedStmtClass:
4840     // As a general principle, C++11 attributes can be ignored without
4841     // any semantic impact.
4842     return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(),
4843                         Case);
4844 
4845   case Stmt::CaseStmtClass:
4846   case Stmt::DefaultStmtClass:
4847     return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case);
4848   case Stmt::CXXTryStmtClass:
4849     // Evaluate try blocks by evaluating all sub statements.
4850     return EvaluateStmt(Result, Info, cast<CXXTryStmt>(S)->getTryBlock(), Case);
4851   }
4852 }
4853 
4854 /// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial
4855 /// default constructor. If so, we'll fold it whether or not it's marked as
4856 /// constexpr. If it is marked as constexpr, we will never implicitly define it,
4857 /// so we need special handling.
4858 static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,
4859                                            const CXXConstructorDecl *CD,
4860                                            bool IsValueInitialization) {
4861   if (!CD->isTrivial() || !CD->isDefaultConstructor())
4862     return false;
4863 
4864   // Value-initialization does not call a trivial default constructor, so such a
4865   // call is a core constant expression whether or not the constructor is
4866   // constexpr.
4867   if (!CD->isConstexpr() && !IsValueInitialization) {
4868     if (Info.getLangOpts().CPlusPlus11) {
4869       // FIXME: If DiagDecl is an implicitly-declared special member function,
4870       // we should be much more explicit about why it's not constexpr.
4871       Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
4872         << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD;
4873       Info.Note(CD->getLocation(), diag::note_declared_at);
4874     } else {
4875       Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
4876     }
4877   }
4878   return true;
4879 }
4880 
4881 /// CheckConstexprFunction - Check that a function can be called in a constant
4882 /// expression.
4883 static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc,
4884                                    const FunctionDecl *Declaration,
4885                                    const FunctionDecl *Definition,
4886                                    const Stmt *Body) {
4887   // Potential constant expressions can contain calls to declared, but not yet
4888   // defined, constexpr functions.
4889   if (Info.checkingPotentialConstantExpression() && !Definition &&
4890       Declaration->isConstexpr())
4891     return false;
4892 
4893   // Bail out if the function declaration itself is invalid.  We will
4894   // have produced a relevant diagnostic while parsing it, so just
4895   // note the problematic sub-expression.
4896   if (Declaration->isInvalidDecl()) {
4897     Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
4898     return false;
4899   }
4900 
4901   // DR1872: An instantiated virtual constexpr function can't be called in a
4902   // constant expression (prior to C++20). We can still constant-fold such a
4903   // call.
4904   if (!Info.Ctx.getLangOpts().CPlusPlus2a && isa<CXXMethodDecl>(Declaration) &&
4905       cast<CXXMethodDecl>(Declaration)->isVirtual())
4906     Info.CCEDiag(CallLoc, diag::note_constexpr_virtual_call);
4907 
4908   if (Definition && Definition->isInvalidDecl()) {
4909     Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
4910     return false;
4911   }
4912 
4913   // Can we evaluate this function call?
4914   if (Definition && Definition->isConstexpr() && Body)
4915     return true;
4916 
4917   if (Info.getLangOpts().CPlusPlus11) {
4918     const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;
4919 
4920     // If this function is not constexpr because it is an inherited
4921     // non-constexpr constructor, diagnose that directly.
4922     auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
4923     if (CD && CD->isInheritingConstructor()) {
4924       auto *Inherited = CD->getInheritedConstructor().getConstructor();
4925       if (!Inherited->isConstexpr())
4926         DiagDecl = CD = Inherited;
4927     }
4928 
4929     // FIXME: If DiagDecl is an implicitly-declared special member function
4930     // or an inheriting constructor, we should be much more explicit about why
4931     // it's not constexpr.
4932     if (CD && CD->isInheritingConstructor())
4933       Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1)
4934         << CD->getInheritedConstructor().getConstructor()->getParent();
4935     else
4936       Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1)
4937         << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
4938     Info.Note(DiagDecl->getLocation(), diag::note_declared_at);
4939   } else {
4940     Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
4941   }
4942   return false;
4943 }
4944 
4945 namespace {
4946 struct CheckDynamicTypeHandler {
4947   AccessKinds AccessKind;
4948   typedef bool result_type;
4949   bool failed() { return false; }
4950   bool found(APValue &Subobj, QualType SubobjType) { return true; }
4951   bool found(APSInt &Value, QualType SubobjType) { return true; }
4952   bool found(APFloat &Value, QualType SubobjType) { return true; }
4953 };
4954 } // end anonymous namespace
4955 
4956 /// Check that we can access the notional vptr of an object / determine its
4957 /// dynamic type.
4958 static bool checkDynamicType(EvalInfo &Info, const Expr *E, const LValue &This,
4959                              AccessKinds AK, bool Polymorphic) {
4960   if (This.Designator.Invalid)
4961     return false;
4962 
4963   CompleteObject Obj = findCompleteObject(Info, E, AK, This, QualType());
4964 
4965   if (!Obj)
4966     return false;
4967 
4968   if (!Obj.Value) {
4969     // The object is not usable in constant expressions, so we can't inspect
4970     // its value to see if it's in-lifetime or what the active union members
4971     // are. We can still check for a one-past-the-end lvalue.
4972     if (This.Designator.isOnePastTheEnd() ||
4973         This.Designator.isMostDerivedAnUnsizedArray()) {
4974       Info.FFDiag(E, This.Designator.isOnePastTheEnd()
4975                          ? diag::note_constexpr_access_past_end
4976                          : diag::note_constexpr_access_unsized_array)
4977           << AK;
4978       return false;
4979     } else if (Polymorphic) {
4980       // Conservatively refuse to perform a polymorphic operation if we would
4981       // not be able to read a notional 'vptr' value.
4982       APValue Val;
4983       This.moveInto(Val);
4984       QualType StarThisType =
4985           Info.Ctx.getLValueReferenceType(This.Designator.getType(Info.Ctx));
4986       Info.FFDiag(E, diag::note_constexpr_polymorphic_unknown_dynamic_type)
4987           << AK << Val.getAsString(Info.Ctx, StarThisType);
4988       return false;
4989     }
4990     return true;
4991   }
4992 
4993   CheckDynamicTypeHandler Handler{AK};
4994   return Obj && findSubobject(Info, E, Obj, This.Designator, Handler);
4995 }
4996 
4997 /// Check that the pointee of the 'this' pointer in a member function call is
4998 /// either within its lifetime or in its period of construction or destruction.
4999 static bool
5000 checkNonVirtualMemberCallThisPointer(EvalInfo &Info, const Expr *E,
5001                                      const LValue &This,
5002                                      const CXXMethodDecl *NamedMember) {
5003   return checkDynamicType(
5004       Info, E, This,
5005       isa<CXXDestructorDecl>(NamedMember) ? AK_Destroy : AK_MemberCall, false);
5006 }
5007 
5008 struct DynamicType {
5009   /// The dynamic class type of the object.
5010   const CXXRecordDecl *Type;
5011   /// The corresponding path length in the lvalue.
5012   unsigned PathLength;
5013 };
5014 
5015 static const CXXRecordDecl *getBaseClassType(SubobjectDesignator &Designator,
5016                                              unsigned PathLength) {
5017   assert(PathLength >= Designator.MostDerivedPathLength && PathLength <=
5018       Designator.Entries.size() && "invalid path length");
5019   return (PathLength == Designator.MostDerivedPathLength)
5020              ? Designator.MostDerivedType->getAsCXXRecordDecl()
5021              : getAsBaseClass(Designator.Entries[PathLength - 1]);
5022 }
5023 
5024 /// Determine the dynamic type of an object.
5025 static Optional<DynamicType> ComputeDynamicType(EvalInfo &Info, const Expr *E,
5026                                                 LValue &This, AccessKinds AK) {
5027   // If we don't have an lvalue denoting an object of class type, there is no
5028   // meaningful dynamic type. (We consider objects of non-class type to have no
5029   // dynamic type.)
5030   if (!checkDynamicType(Info, E, This, AK, true))
5031     return None;
5032 
5033   // Refuse to compute a dynamic type in the presence of virtual bases. This
5034   // shouldn't happen other than in constant-folding situations, since literal
5035   // types can't have virtual bases.
5036   //
5037   // Note that consumers of DynamicType assume that the type has no virtual
5038   // bases, and will need modifications if this restriction is relaxed.
5039   const CXXRecordDecl *Class =
5040       This.Designator.MostDerivedType->getAsCXXRecordDecl();
5041   if (!Class || Class->getNumVBases()) {
5042     Info.FFDiag(E);
5043     return None;
5044   }
5045 
5046   // FIXME: For very deep class hierarchies, it might be beneficial to use a
5047   // binary search here instead. But the overwhelmingly common case is that
5048   // we're not in the middle of a constructor, so it probably doesn't matter
5049   // in practice.
5050   ArrayRef<APValue::LValuePathEntry> Path = This.Designator.Entries;
5051   for (unsigned PathLength = This.Designator.MostDerivedPathLength;
5052        PathLength <= Path.size(); ++PathLength) {
5053     switch (Info.isEvaluatingCtorDtor(This.getLValueBase(),
5054                                       Path.slice(0, PathLength))) {
5055     case ConstructionPhase::Bases:
5056     case ConstructionPhase::DestroyingBases:
5057       // We're constructing or destroying a base class. This is not the dynamic
5058       // type.
5059       break;
5060 
5061     case ConstructionPhase::None:
5062     case ConstructionPhase::AfterBases:
5063     case ConstructionPhase::Destroying:
5064       // We've finished constructing the base classes and not yet started
5065       // destroying them again, so this is the dynamic type.
5066       return DynamicType{getBaseClassType(This.Designator, PathLength),
5067                          PathLength};
5068     }
5069   }
5070 
5071   // CWG issue 1517: we're constructing a base class of the object described by
5072   // 'This', so that object has not yet begun its period of construction and
5073   // any polymorphic operation on it results in undefined behavior.
5074   Info.FFDiag(E);
5075   return None;
5076 }
5077 
5078 /// Perform virtual dispatch.
5079 static const CXXMethodDecl *HandleVirtualDispatch(
5080     EvalInfo &Info, const Expr *E, LValue &This, const CXXMethodDecl *Found,
5081     llvm::SmallVectorImpl<QualType> &CovariantAdjustmentPath) {
5082   Optional<DynamicType> DynType = ComputeDynamicType(
5083       Info, E, This,
5084       isa<CXXDestructorDecl>(Found) ? AK_Destroy : AK_MemberCall);
5085   if (!DynType)
5086     return nullptr;
5087 
5088   // Find the final overrider. It must be declared in one of the classes on the
5089   // path from the dynamic type to the static type.
5090   // FIXME: If we ever allow literal types to have virtual base classes, that
5091   // won't be true.
5092   const CXXMethodDecl *Callee = Found;
5093   unsigned PathLength = DynType->PathLength;
5094   for (/**/; PathLength <= This.Designator.Entries.size(); ++PathLength) {
5095     const CXXRecordDecl *Class = getBaseClassType(This.Designator, PathLength);
5096     const CXXMethodDecl *Overrider =
5097         Found->getCorrespondingMethodDeclaredInClass(Class, false);
5098     if (Overrider) {
5099       Callee = Overrider;
5100       break;
5101     }
5102   }
5103 
5104   // C++2a [class.abstract]p6:
5105   //   the effect of making a virtual call to a pure virtual function [...] is
5106   //   undefined
5107   if (Callee->isPure()) {
5108     Info.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << Callee;
5109     Info.Note(Callee->getLocation(), diag::note_declared_at);
5110     return nullptr;
5111   }
5112 
5113   // If necessary, walk the rest of the path to determine the sequence of
5114   // covariant adjustment steps to apply.
5115   if (!Info.Ctx.hasSameUnqualifiedType(Callee->getReturnType(),
5116                                        Found->getReturnType())) {
5117     CovariantAdjustmentPath.push_back(Callee->getReturnType());
5118     for (unsigned CovariantPathLength = PathLength + 1;
5119          CovariantPathLength != This.Designator.Entries.size();
5120          ++CovariantPathLength) {
5121       const CXXRecordDecl *NextClass =
5122           getBaseClassType(This.Designator, CovariantPathLength);
5123       const CXXMethodDecl *Next =
5124           Found->getCorrespondingMethodDeclaredInClass(NextClass, false);
5125       if (Next && !Info.Ctx.hasSameUnqualifiedType(
5126                       Next->getReturnType(), CovariantAdjustmentPath.back()))
5127         CovariantAdjustmentPath.push_back(Next->getReturnType());
5128     }
5129     if (!Info.Ctx.hasSameUnqualifiedType(Found->getReturnType(),
5130                                          CovariantAdjustmentPath.back()))
5131       CovariantAdjustmentPath.push_back(Found->getReturnType());
5132   }
5133 
5134   // Perform 'this' adjustment.
5135   if (!CastToDerivedClass(Info, E, This, Callee->getParent(), PathLength))
5136     return nullptr;
5137 
5138   return Callee;
5139 }
5140 
5141 /// Perform the adjustment from a value returned by a virtual function to
5142 /// a value of the statically expected type, which may be a pointer or
5143 /// reference to a base class of the returned type.
5144 static bool HandleCovariantReturnAdjustment(EvalInfo &Info, const Expr *E,
5145                                             APValue &Result,
5146                                             ArrayRef<QualType> Path) {
5147   assert(Result.isLValue() &&
5148          "unexpected kind of APValue for covariant return");
5149   if (Result.isNullPointer())
5150     return true;
5151 
5152   LValue LVal;
5153   LVal.setFrom(Info.Ctx, Result);
5154 
5155   const CXXRecordDecl *OldClass = Path[0]->getPointeeCXXRecordDecl();
5156   for (unsigned I = 1; I != Path.size(); ++I) {
5157     const CXXRecordDecl *NewClass = Path[I]->getPointeeCXXRecordDecl();
5158     assert(OldClass && NewClass && "unexpected kind of covariant return");
5159     if (OldClass != NewClass &&
5160         !CastToBaseClass(Info, E, LVal, OldClass, NewClass))
5161       return false;
5162     OldClass = NewClass;
5163   }
5164 
5165   LVal.moveInto(Result);
5166   return true;
5167 }
5168 
5169 /// Determine whether \p Base, which is known to be a direct base class of
5170 /// \p Derived, is a public base class.
5171 static bool isBaseClassPublic(const CXXRecordDecl *Derived,
5172                               const CXXRecordDecl *Base) {
5173   for (const CXXBaseSpecifier &BaseSpec : Derived->bases()) {
5174     auto *BaseClass = BaseSpec.getType()->getAsCXXRecordDecl();
5175     if (BaseClass && declaresSameEntity(BaseClass, Base))
5176       return BaseSpec.getAccessSpecifier() == AS_public;
5177   }
5178   llvm_unreachable("Base is not a direct base of Derived");
5179 }
5180 
5181 /// Apply the given dynamic cast operation on the provided lvalue.
5182 ///
5183 /// This implements the hard case of dynamic_cast, requiring a "runtime check"
5184 /// to find a suitable target subobject.
5185 static bool HandleDynamicCast(EvalInfo &Info, const ExplicitCastExpr *E,
5186                               LValue &Ptr) {
5187   // We can't do anything with a non-symbolic pointer value.
5188   SubobjectDesignator &D = Ptr.Designator;
5189   if (D.Invalid)
5190     return false;
5191 
5192   // C++ [expr.dynamic.cast]p6:
5193   //   If v is a null pointer value, the result is a null pointer value.
5194   if (Ptr.isNullPointer() && !E->isGLValue())
5195     return true;
5196 
5197   // For all the other cases, we need the pointer to point to an object within
5198   // its lifetime / period of construction / destruction, and we need to know
5199   // its dynamic type.
5200   Optional<DynamicType> DynType =
5201       ComputeDynamicType(Info, E, Ptr, AK_DynamicCast);
5202   if (!DynType)
5203     return false;
5204 
5205   // C++ [expr.dynamic.cast]p7:
5206   //   If T is "pointer to cv void", then the result is a pointer to the most
5207   //   derived object
5208   if (E->getType()->isVoidPointerType())
5209     return CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength);
5210 
5211   const CXXRecordDecl *C = E->getTypeAsWritten()->getPointeeCXXRecordDecl();
5212   assert(C && "dynamic_cast target is not void pointer nor class");
5213   CanQualType CQT = Info.Ctx.getCanonicalType(Info.Ctx.getRecordType(C));
5214 
5215   auto RuntimeCheckFailed = [&] (CXXBasePaths *Paths) {
5216     // C++ [expr.dynamic.cast]p9:
5217     if (!E->isGLValue()) {
5218       //   The value of a failed cast to pointer type is the null pointer value
5219       //   of the required result type.
5220       Ptr.setNull(Info.Ctx, E->getType());
5221       return true;
5222     }
5223 
5224     //   A failed cast to reference type throws [...] std::bad_cast.
5225     unsigned DiagKind;
5226     if (!Paths && (declaresSameEntity(DynType->Type, C) ||
5227                    DynType->Type->isDerivedFrom(C)))
5228       DiagKind = 0;
5229     else if (!Paths || Paths->begin() == Paths->end())
5230       DiagKind = 1;
5231     else if (Paths->isAmbiguous(CQT))
5232       DiagKind = 2;
5233     else {
5234       assert(Paths->front().Access != AS_public && "why did the cast fail?");
5235       DiagKind = 3;
5236     }
5237     Info.FFDiag(E, diag::note_constexpr_dynamic_cast_to_reference_failed)
5238         << DiagKind << Ptr.Designator.getType(Info.Ctx)
5239         << Info.Ctx.getRecordType(DynType->Type)
5240         << E->getType().getUnqualifiedType();
5241     return false;
5242   };
5243 
5244   // Runtime check, phase 1:
5245   //   Walk from the base subobject towards the derived object looking for the
5246   //   target type.
5247   for (int PathLength = Ptr.Designator.Entries.size();
5248        PathLength >= (int)DynType->PathLength; --PathLength) {
5249     const CXXRecordDecl *Class = getBaseClassType(Ptr.Designator, PathLength);
5250     if (declaresSameEntity(Class, C))
5251       return CastToDerivedClass(Info, E, Ptr, Class, PathLength);
5252     // We can only walk across public inheritance edges.
5253     if (PathLength > (int)DynType->PathLength &&
5254         !isBaseClassPublic(getBaseClassType(Ptr.Designator, PathLength - 1),
5255                            Class))
5256       return RuntimeCheckFailed(nullptr);
5257   }
5258 
5259   // Runtime check, phase 2:
5260   //   Search the dynamic type for an unambiguous public base of type C.
5261   CXXBasePaths Paths(/*FindAmbiguities=*/true,
5262                      /*RecordPaths=*/true, /*DetectVirtual=*/false);
5263   if (DynType->Type->isDerivedFrom(C, Paths) && !Paths.isAmbiguous(CQT) &&
5264       Paths.front().Access == AS_public) {
5265     // Downcast to the dynamic type...
5266     if (!CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength))
5267       return false;
5268     // ... then upcast to the chosen base class subobject.
5269     for (CXXBasePathElement &Elem : Paths.front())
5270       if (!HandleLValueBase(Info, E, Ptr, Elem.Class, Elem.Base))
5271         return false;
5272     return true;
5273   }
5274 
5275   // Otherwise, the runtime check fails.
5276   return RuntimeCheckFailed(&Paths);
5277 }
5278 
5279 namespace {
5280 struct StartLifetimeOfUnionMemberHandler {
5281   const FieldDecl *Field;
5282 
5283   static const AccessKinds AccessKind = AK_Assign;
5284 
5285   typedef bool result_type;
5286   bool failed() { return false; }
5287   bool found(APValue &Subobj, QualType SubobjType) {
5288     // We are supposed to perform no initialization but begin the lifetime of
5289     // the object. We interpret that as meaning to do what default
5290     // initialization of the object would do if all constructors involved were
5291     // trivial:
5292     //  * All base, non-variant member, and array element subobjects' lifetimes
5293     //    begin
5294     //  * No variant members' lifetimes begin
5295     //  * All scalar subobjects whose lifetimes begin have indeterminate values
5296     assert(SubobjType->isUnionType());
5297     if (!declaresSameEntity(Subobj.getUnionField(), Field) ||
5298         !Subobj.getUnionValue().hasValue())
5299       Subobj.setUnion(Field, getDefaultInitValue(Field->getType()));
5300     return true;
5301   }
5302   bool found(APSInt &Value, QualType SubobjType) {
5303     llvm_unreachable("wrong value kind for union object");
5304   }
5305   bool found(APFloat &Value, QualType SubobjType) {
5306     llvm_unreachable("wrong value kind for union object");
5307   }
5308 };
5309 } // end anonymous namespace
5310 
5311 const AccessKinds StartLifetimeOfUnionMemberHandler::AccessKind;
5312 
5313 /// Handle a builtin simple-assignment or a call to a trivial assignment
5314 /// operator whose left-hand side might involve a union member access. If it
5315 /// does, implicitly start the lifetime of any accessed union elements per
5316 /// C++20 [class.union]5.
5317 static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *LHSExpr,
5318                                           const LValue &LHS) {
5319   if (LHS.InvalidBase || LHS.Designator.Invalid)
5320     return false;
5321 
5322   llvm::SmallVector<std::pair<unsigned, const FieldDecl*>, 4> UnionPathLengths;
5323   // C++ [class.union]p5:
5324   //   define the set S(E) of subexpressions of E as follows:
5325   unsigned PathLength = LHS.Designator.Entries.size();
5326   for (const Expr *E = LHSExpr; E != nullptr;) {
5327     //   -- If E is of the form A.B, S(E) contains the elements of S(A)...
5328     if (auto *ME = dyn_cast<MemberExpr>(E)) {
5329       auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
5330       // Note that we can't implicitly start the lifetime of a reference,
5331       // so we don't need to proceed any further if we reach one.
5332       if (!FD || FD->getType()->isReferenceType())
5333         break;
5334 
5335       //    ... and also contains A.B if B names a union member ...
5336       if (FD->getParent()->isUnion()) {
5337         //    ... of a non-class, non-array type, or of a class type with a
5338         //    trivial default constructor that is not deleted, or an array of
5339         //    such types.
5340         auto *RD =
5341             FD->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
5342         if (!RD || RD->hasTrivialDefaultConstructor())
5343           UnionPathLengths.push_back({PathLength - 1, FD});
5344       }
5345 
5346       E = ME->getBase();
5347       --PathLength;
5348       assert(declaresSameEntity(FD,
5349                                 LHS.Designator.Entries[PathLength]
5350                                     .getAsBaseOrMember().getPointer()));
5351 
5352       //   -- If E is of the form A[B] and is interpreted as a built-in array
5353       //      subscripting operator, S(E) is [S(the array operand, if any)].
5354     } else if (auto *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
5355       // Step over an ArrayToPointerDecay implicit cast.
5356       auto *Base = ASE->getBase()->IgnoreImplicit();
5357       if (!Base->getType()->isArrayType())
5358         break;
5359 
5360       E = Base;
5361       --PathLength;
5362 
5363     } else if (auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
5364       // Step over a derived-to-base conversion.
5365       E = ICE->getSubExpr();
5366       if (ICE->getCastKind() == CK_NoOp)
5367         continue;
5368       if (ICE->getCastKind() != CK_DerivedToBase &&
5369           ICE->getCastKind() != CK_UncheckedDerivedToBase)
5370         break;
5371       // Walk path backwards as we walk up from the base to the derived class.
5372       for (const CXXBaseSpecifier *Elt : llvm::reverse(ICE->path())) {
5373         --PathLength;
5374         (void)Elt;
5375         assert(declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(),
5376                                   LHS.Designator.Entries[PathLength]
5377                                       .getAsBaseOrMember().getPointer()));
5378       }
5379 
5380     //   -- Otherwise, S(E) is empty.
5381     } else {
5382       break;
5383     }
5384   }
5385 
5386   // Common case: no unions' lifetimes are started.
5387   if (UnionPathLengths.empty())
5388     return true;
5389 
5390   //   if modification of X [would access an inactive union member], an object
5391   //   of the type of X is implicitly created
5392   CompleteObject Obj =
5393       findCompleteObject(Info, LHSExpr, AK_Assign, LHS, LHSExpr->getType());
5394   if (!Obj)
5395     return false;
5396   for (std::pair<unsigned, const FieldDecl *> LengthAndField :
5397            llvm::reverse(UnionPathLengths)) {
5398     // Form a designator for the union object.
5399     SubobjectDesignator D = LHS.Designator;
5400     D.truncate(Info.Ctx, LHS.Base, LengthAndField.first);
5401 
5402     StartLifetimeOfUnionMemberHandler StartLifetime{LengthAndField.second};
5403     if (!findSubobject(Info, LHSExpr, Obj, D, StartLifetime))
5404       return false;
5405   }
5406 
5407   return true;
5408 }
5409 
5410 /// Determine if a class has any fields that might need to be copied by a
5411 /// trivial copy or move operation.
5412 static bool hasFields(const CXXRecordDecl *RD) {
5413   if (!RD || RD->isEmpty())
5414     return false;
5415   for (auto *FD : RD->fields()) {
5416     if (FD->isUnnamedBitfield())
5417       continue;
5418     return true;
5419   }
5420   for (auto &Base : RD->bases())
5421     if (hasFields(Base.getType()->getAsCXXRecordDecl()))
5422       return true;
5423   return false;
5424 }
5425 
5426 namespace {
5427 typedef SmallVector<APValue, 8> ArgVector;
5428 }
5429 
5430 /// EvaluateArgs - Evaluate the arguments to a function call.
5431 static bool EvaluateArgs(ArrayRef<const Expr *> Args, ArgVector &ArgValues,
5432                          EvalInfo &Info, const FunctionDecl *Callee) {
5433   bool Success = true;
5434   llvm::SmallBitVector ForbiddenNullArgs;
5435   if (Callee->hasAttr<NonNullAttr>()) {
5436     ForbiddenNullArgs.resize(Args.size());
5437     for (const auto *Attr : Callee->specific_attrs<NonNullAttr>()) {
5438       if (!Attr->args_size()) {
5439         ForbiddenNullArgs.set();
5440         break;
5441       } else
5442         for (auto Idx : Attr->args()) {
5443           unsigned ASTIdx = Idx.getASTIndex();
5444           if (ASTIdx >= Args.size())
5445             continue;
5446           ForbiddenNullArgs[ASTIdx] = 1;
5447         }
5448     }
5449   }
5450   for (unsigned Idx = 0; Idx < Args.size(); Idx++) {
5451     if (!Evaluate(ArgValues[Idx], Info, Args[Idx])) {
5452       // If we're checking for a potential constant expression, evaluate all
5453       // initializers even if some of them fail.
5454       if (!Info.noteFailure())
5455         return false;
5456       Success = false;
5457     } else if (!ForbiddenNullArgs.empty() &&
5458                ForbiddenNullArgs[Idx] &&
5459                ArgValues[Idx].isLValue() &&
5460                ArgValues[Idx].isNullPointer()) {
5461       Info.CCEDiag(Args[Idx], diag::note_non_null_attribute_failed);
5462       if (!Info.noteFailure())
5463         return false;
5464       Success = false;
5465     }
5466   }
5467   return Success;
5468 }
5469 
5470 /// Evaluate a function call.
5471 static bool HandleFunctionCall(SourceLocation CallLoc,
5472                                const FunctionDecl *Callee, const LValue *This,
5473                                ArrayRef<const Expr*> Args, const Stmt *Body,
5474                                EvalInfo &Info, APValue &Result,
5475                                const LValue *ResultSlot) {
5476   ArgVector ArgValues(Args.size());
5477   if (!EvaluateArgs(Args, ArgValues, Info, Callee))
5478     return false;
5479 
5480   if (!Info.CheckCallLimit(CallLoc))
5481     return false;
5482 
5483   CallStackFrame Frame(Info, CallLoc, Callee, This, ArgValues.data());
5484 
5485   // For a trivial copy or move assignment, perform an APValue copy. This is
5486   // essential for unions, where the operations performed by the assignment
5487   // operator cannot be represented as statements.
5488   //
5489   // Skip this for non-union classes with no fields; in that case, the defaulted
5490   // copy/move does not actually read the object.
5491   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee);
5492   if (MD && MD->isDefaulted() &&
5493       (MD->getParent()->isUnion() ||
5494        (MD->isTrivial() && hasFields(MD->getParent())))) {
5495     assert(This &&
5496            (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()));
5497     LValue RHS;
5498     RHS.setFrom(Info.Ctx, ArgValues[0]);
5499     APValue RHSValue;
5500     if (!handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(), RHS,
5501                                         RHSValue, MD->getParent()->isUnion()))
5502       return false;
5503     if (Info.getLangOpts().CPlusPlus2a && MD->isTrivial() &&
5504         !HandleUnionActiveMemberChange(Info, Args[0], *This))
5505       return false;
5506     if (!handleAssignment(Info, Args[0], *This, MD->getThisType(),
5507                           RHSValue))
5508       return false;
5509     This->moveInto(Result);
5510     return true;
5511   } else if (MD && isLambdaCallOperator(MD)) {
5512     // We're in a lambda; determine the lambda capture field maps unless we're
5513     // just constexpr checking a lambda's call operator. constexpr checking is
5514     // done before the captures have been added to the closure object (unless
5515     // we're inferring constexpr-ness), so we don't have access to them in this
5516     // case. But since we don't need the captures to constexpr check, we can
5517     // just ignore them.
5518     if (!Info.checkingPotentialConstantExpression())
5519       MD->getParent()->getCaptureFields(Frame.LambdaCaptureFields,
5520                                         Frame.LambdaThisCaptureField);
5521   }
5522 
5523   StmtResult Ret = {Result, ResultSlot};
5524   EvalStmtResult ESR = EvaluateStmt(Ret, Info, Body);
5525   if (ESR == ESR_Succeeded) {
5526     if (Callee->getReturnType()->isVoidType())
5527       return true;
5528     Info.FFDiag(Callee->getEndLoc(), diag::note_constexpr_no_return);
5529   }
5530   return ESR == ESR_Returned;
5531 }
5532 
5533 /// Evaluate a constructor call.
5534 static bool HandleConstructorCall(const Expr *E, const LValue &This,
5535                                   APValue *ArgValues,
5536                                   const CXXConstructorDecl *Definition,
5537                                   EvalInfo &Info, APValue &Result) {
5538   SourceLocation CallLoc = E->getExprLoc();
5539   if (!Info.CheckCallLimit(CallLoc))
5540     return false;
5541 
5542   const CXXRecordDecl *RD = Definition->getParent();
5543   if (RD->getNumVBases()) {
5544     Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
5545     return false;
5546   }
5547 
5548   EvalInfo::EvaluatingConstructorRAII EvalObj(
5549       Info,
5550       ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries},
5551       RD->getNumBases());
5552   CallStackFrame Frame(Info, CallLoc, Definition, &This, ArgValues);
5553 
5554   // FIXME: Creating an APValue just to hold a nonexistent return value is
5555   // wasteful.
5556   APValue RetVal;
5557   StmtResult Ret = {RetVal, nullptr};
5558 
5559   // If it's a delegating constructor, delegate.
5560   if (Definition->isDelegatingConstructor()) {
5561     CXXConstructorDecl::init_const_iterator I = Definition->init_begin();
5562     {
5563       FullExpressionRAII InitScope(Info);
5564       if (!EvaluateInPlace(Result, Info, This, (*I)->getInit()) ||
5565           !InitScope.destroy())
5566         return false;
5567     }
5568     return EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed;
5569   }
5570 
5571   // For a trivial copy or move constructor, perform an APValue copy. This is
5572   // essential for unions (or classes with anonymous union members), where the
5573   // operations performed by the constructor cannot be represented by
5574   // ctor-initializers.
5575   //
5576   // Skip this for empty non-union classes; we should not perform an
5577   // lvalue-to-rvalue conversion on them because their copy constructor does not
5578   // actually read them.
5579   if (Definition->isDefaulted() && Definition->isCopyOrMoveConstructor() &&
5580       (Definition->getParent()->isUnion() ||
5581        (Definition->isTrivial() && hasFields(Definition->getParent())))) {
5582     LValue RHS;
5583     RHS.setFrom(Info.Ctx, ArgValues[0]);
5584     return handleLValueToRValueConversion(
5585         Info, E, Definition->getParamDecl(0)->getType().getNonReferenceType(),
5586         RHS, Result, Definition->getParent()->isUnion());
5587   }
5588 
5589   // Reserve space for the struct members.
5590   if (!RD->isUnion() && !Result.hasValue())
5591     Result = APValue(APValue::UninitStruct(), RD->getNumBases(),
5592                      std::distance(RD->field_begin(), RD->field_end()));
5593 
5594   if (RD->isInvalidDecl()) return false;
5595   const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
5596 
5597   // A scope for temporaries lifetime-extended by reference members.
5598   BlockScopeRAII LifetimeExtendedScope(Info);
5599 
5600   bool Success = true;
5601   unsigned BasesSeen = 0;
5602 #ifndef NDEBUG
5603   CXXRecordDecl::base_class_const_iterator BaseIt = RD->bases_begin();
5604 #endif
5605   CXXRecordDecl::field_iterator FieldIt = RD->field_begin();
5606   auto SkipToField = [&](FieldDecl *FD, bool Indirect) {
5607     // We might be initializing the same field again if this is an indirect
5608     // field initialization.
5609     if (FieldIt == RD->field_end() ||
5610         FieldIt->getFieldIndex() > FD->getFieldIndex()) {
5611       assert(Indirect && "fields out of order?");
5612       return;
5613     }
5614 
5615     // Default-initialize any fields with no explicit initializer.
5616     for (; !declaresSameEntity(*FieldIt, FD); ++FieldIt) {
5617       assert(FieldIt != RD->field_end() && "missing field?");
5618       if (!FieldIt->isUnnamedBitfield())
5619         Result.getStructField(FieldIt->getFieldIndex()) =
5620             getDefaultInitValue(FieldIt->getType());
5621     }
5622     ++FieldIt;
5623   };
5624   for (const auto *I : Definition->inits()) {
5625     LValue Subobject = This;
5626     LValue SubobjectParent = This;
5627     APValue *Value = &Result;
5628 
5629     // Determine the subobject to initialize.
5630     FieldDecl *FD = nullptr;
5631     if (I->isBaseInitializer()) {
5632       QualType BaseType(I->getBaseClass(), 0);
5633 #ifndef NDEBUG
5634       // Non-virtual base classes are initialized in the order in the class
5635       // definition. We have already checked for virtual base classes.
5636       assert(!BaseIt->isVirtual() && "virtual base for literal type");
5637       assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&
5638              "base class initializers not in expected order");
5639       ++BaseIt;
5640 #endif
5641       if (!HandleLValueDirectBase(Info, I->getInit(), Subobject, RD,
5642                                   BaseType->getAsCXXRecordDecl(), &Layout))
5643         return false;
5644       Value = &Result.getStructBase(BasesSeen++);
5645     } else if ((FD = I->getMember())) {
5646       if (!HandleLValueMember(Info, I->getInit(), Subobject, FD, &Layout))
5647         return false;
5648       if (RD->isUnion()) {
5649         Result = APValue(FD);
5650         Value = &Result.getUnionValue();
5651       } else {
5652         SkipToField(FD, false);
5653         Value = &Result.getStructField(FD->getFieldIndex());
5654       }
5655     } else if (IndirectFieldDecl *IFD = I->getIndirectMember()) {
5656       // Walk the indirect field decl's chain to find the object to initialize,
5657       // and make sure we've initialized every step along it.
5658       auto IndirectFieldChain = IFD->chain();
5659       for (auto *C : IndirectFieldChain) {
5660         FD = cast<FieldDecl>(C);
5661         CXXRecordDecl *CD = cast<CXXRecordDecl>(FD->getParent());
5662         // Switch the union field if it differs. This happens if we had
5663         // preceding zero-initialization, and we're now initializing a union
5664         // subobject other than the first.
5665         // FIXME: In this case, the values of the other subobjects are
5666         // specified, since zero-initialization sets all padding bits to zero.
5667         if (!Value->hasValue() ||
5668             (Value->isUnion() && Value->getUnionField() != FD)) {
5669           if (CD->isUnion())
5670             *Value = APValue(FD);
5671           else
5672             // FIXME: This immediately starts the lifetime of all members of an
5673             // anonymous struct. It would be preferable to strictly start member
5674             // lifetime in initialization order.
5675             *Value = getDefaultInitValue(Info.Ctx.getRecordType(CD));
5676         }
5677         // Store Subobject as its parent before updating it for the last element
5678         // in the chain.
5679         if (C == IndirectFieldChain.back())
5680           SubobjectParent = Subobject;
5681         if (!HandleLValueMember(Info, I->getInit(), Subobject, FD))
5682           return false;
5683         if (CD->isUnion())
5684           Value = &Value->getUnionValue();
5685         else {
5686           if (C == IndirectFieldChain.front() && !RD->isUnion())
5687             SkipToField(FD, true);
5688           Value = &Value->getStructField(FD->getFieldIndex());
5689         }
5690       }
5691     } else {
5692       llvm_unreachable("unknown base initializer kind");
5693     }
5694 
5695     // Need to override This for implicit field initializers as in this case
5696     // This refers to innermost anonymous struct/union containing initializer,
5697     // not to currently constructed class.
5698     const Expr *Init = I->getInit();
5699     ThisOverrideRAII ThisOverride(*Info.CurrentCall, &SubobjectParent,
5700                                   isa<CXXDefaultInitExpr>(Init));
5701     FullExpressionRAII InitScope(Info);
5702     if (!EvaluateInPlace(*Value, Info, Subobject, Init) ||
5703         (FD && FD->isBitField() &&
5704          !truncateBitfieldValue(Info, Init, *Value, FD))) {
5705       // If we're checking for a potential constant expression, evaluate all
5706       // initializers even if some of them fail.
5707       if (!Info.noteFailure())
5708         return false;
5709       Success = false;
5710     }
5711 
5712     // This is the point at which the dynamic type of the object becomes this
5713     // class type.
5714     if (I->isBaseInitializer() && BasesSeen == RD->getNumBases())
5715       EvalObj.finishedConstructingBases();
5716   }
5717 
5718   // Default-initialize any remaining fields.
5719   if (!RD->isUnion()) {
5720     for (; FieldIt != RD->field_end(); ++FieldIt) {
5721       if (!FieldIt->isUnnamedBitfield())
5722         Result.getStructField(FieldIt->getFieldIndex()) =
5723             getDefaultInitValue(FieldIt->getType());
5724     }
5725   }
5726 
5727   return Success &&
5728          EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed &&
5729          LifetimeExtendedScope.destroy();
5730 }
5731 
5732 static bool HandleConstructorCall(const Expr *E, const LValue &This,
5733                                   ArrayRef<const Expr*> Args,
5734                                   const CXXConstructorDecl *Definition,
5735                                   EvalInfo &Info, APValue &Result) {
5736   ArgVector ArgValues(Args.size());
5737   if (!EvaluateArgs(Args, ArgValues, Info, Definition))
5738     return false;
5739 
5740   return HandleConstructorCall(E, This, ArgValues.data(), Definition,
5741                                Info, Result);
5742 }
5743 
5744 static bool HandleDestructionImpl(EvalInfo &Info, SourceLocation CallLoc,
5745                                   const LValue &This, APValue &Value,
5746                                   QualType T) {
5747   // Objects can only be destroyed while they're within their lifetimes.
5748   // FIXME: We have no representation for whether an object of type nullptr_t
5749   // is in its lifetime; it usually doesn't matter. Perhaps we should model it
5750   // as indeterminate instead?
5751   if (Value.isAbsent() && !T->isNullPtrType()) {
5752     APValue Printable;
5753     This.moveInto(Printable);
5754     Info.FFDiag(CallLoc, diag::note_constexpr_destroy_out_of_lifetime)
5755       << Printable.getAsString(Info.Ctx, Info.Ctx.getLValueReferenceType(T));
5756     return false;
5757   }
5758 
5759   // Invent an expression for location purposes.
5760   // FIXME: We shouldn't need to do this.
5761   OpaqueValueExpr LocE(CallLoc, Info.Ctx.IntTy, VK_RValue);
5762 
5763   // For arrays, destroy elements right-to-left.
5764   if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(T)) {
5765     uint64_t Size = CAT->getSize().getZExtValue();
5766     QualType ElemT = CAT->getElementType();
5767 
5768     LValue ElemLV = This;
5769     ElemLV.addArray(Info, &LocE, CAT);
5770     if (!HandleLValueArrayAdjustment(Info, &LocE, ElemLV, ElemT, Size))
5771       return false;
5772 
5773     // Ensure that we have actual array elements available to destroy; the
5774     // destructors might mutate the value, so we can't run them on the array
5775     // filler.
5776     if (Size && Size > Value.getArrayInitializedElts())
5777       expandArray(Value, Value.getArraySize() - 1);
5778 
5779     for (; Size != 0; --Size) {
5780       APValue &Elem = Value.getArrayInitializedElt(Size - 1);
5781       if (!HandleLValueArrayAdjustment(Info, &LocE, ElemLV, ElemT, -1) ||
5782           !HandleDestructionImpl(Info, CallLoc, ElemLV, Elem, ElemT))
5783         return false;
5784     }
5785 
5786     // End the lifetime of this array now.
5787     Value = APValue();
5788     return true;
5789   }
5790 
5791   const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
5792   if (!RD) {
5793     if (T.isDestructedType()) {
5794       Info.FFDiag(CallLoc, diag::note_constexpr_unsupported_destruction) << T;
5795       return false;
5796     }
5797 
5798     Value = APValue();
5799     return true;
5800   }
5801 
5802   if (RD->getNumVBases()) {
5803     Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
5804     return false;
5805   }
5806 
5807   const CXXDestructorDecl *DD = RD->getDestructor();
5808   if (!DD && !RD->hasTrivialDestructor()) {
5809     Info.FFDiag(CallLoc);
5810     return false;
5811   }
5812 
5813   if (!DD || DD->isTrivial() ||
5814       (RD->isAnonymousStructOrUnion() && RD->isUnion())) {
5815     // A trivial destructor just ends the lifetime of the object. Check for
5816     // this case before checking for a body, because we might not bother
5817     // building a body for a trivial destructor. Note that it doesn't matter
5818     // whether the destructor is constexpr in this case; all trivial
5819     // destructors are constexpr.
5820     //
5821     // If an anonymous union would be destroyed, some enclosing destructor must
5822     // have been explicitly defined, and the anonymous union destruction should
5823     // have no effect.
5824     Value = APValue();
5825     return true;
5826   }
5827 
5828   if (!Info.CheckCallLimit(CallLoc))
5829     return false;
5830 
5831   const FunctionDecl *Definition = nullptr;
5832   const Stmt *Body = DD->getBody(Definition);
5833 
5834   if (!CheckConstexprFunction(Info, CallLoc, DD, Definition, Body))
5835     return false;
5836 
5837   CallStackFrame Frame(Info, CallLoc, Definition, &This, nullptr);
5838 
5839   // We're now in the period of destruction of this object.
5840   unsigned BasesLeft = RD->getNumBases();
5841   EvalInfo::EvaluatingDestructorRAII EvalObj(
5842       Info,
5843       ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries});
5844   if (!EvalObj.DidInsert) {
5845     // C++2a [class.dtor]p19:
5846     //   the behavior is undefined if the destructor is invoked for an object
5847     //   whose lifetime has ended
5848     // (Note that formally the lifetime ends when the period of destruction
5849     // begins, even though certain uses of the object remain valid until the
5850     // period of destruction ends.)
5851     Info.FFDiag(CallLoc, diag::note_constexpr_double_destroy);
5852     return false;
5853   }
5854 
5855   // FIXME: Creating an APValue just to hold a nonexistent return value is
5856   // wasteful.
5857   APValue RetVal;
5858   StmtResult Ret = {RetVal, nullptr};
5859   if (EvaluateStmt(Ret, Info, Definition->getBody()) == ESR_Failed)
5860     return false;
5861 
5862   // A union destructor does not implicitly destroy its members.
5863   if (RD->isUnion())
5864     return true;
5865 
5866   const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
5867 
5868   // We don't have a good way to iterate fields in reverse, so collect all the
5869   // fields first and then walk them backwards.
5870   SmallVector<FieldDecl*, 16> Fields(RD->field_begin(), RD->field_end());
5871   for (const FieldDecl *FD : llvm::reverse(Fields)) {
5872     if (FD->isUnnamedBitfield())
5873       continue;
5874 
5875     LValue Subobject = This;
5876     if (!HandleLValueMember(Info, &LocE, Subobject, FD, &Layout))
5877       return false;
5878 
5879     APValue *SubobjectValue = &Value.getStructField(FD->getFieldIndex());
5880     if (!HandleDestructionImpl(Info, CallLoc, Subobject, *SubobjectValue,
5881                                FD->getType()))
5882       return false;
5883   }
5884 
5885   if (BasesLeft != 0)
5886     EvalObj.startedDestroyingBases();
5887 
5888   // Destroy base classes in reverse order.
5889   for (const CXXBaseSpecifier &Base : llvm::reverse(RD->bases())) {
5890     --BasesLeft;
5891 
5892     QualType BaseType = Base.getType();
5893     LValue Subobject = This;
5894     if (!HandleLValueDirectBase(Info, &LocE, Subobject, RD,
5895                                 BaseType->getAsCXXRecordDecl(), &Layout))
5896       return false;
5897 
5898     APValue *SubobjectValue = &Value.getStructBase(BasesLeft);
5899     if (!HandleDestructionImpl(Info, CallLoc, Subobject, *SubobjectValue,
5900                                BaseType))
5901       return false;
5902   }
5903   assert(BasesLeft == 0 && "NumBases was wrong?");
5904 
5905   // The period of destruction ends now. The object is gone.
5906   Value = APValue();
5907   return true;
5908 }
5909 
5910 namespace {
5911 struct DestroyObjectHandler {
5912   EvalInfo &Info;
5913   const Expr *E;
5914   const LValue &This;
5915   const AccessKinds AccessKind;
5916 
5917   typedef bool result_type;
5918   bool failed() { return false; }
5919   bool found(APValue &Subobj, QualType SubobjType) {
5920     return HandleDestructionImpl(Info, E->getExprLoc(), This, Subobj,
5921                                  SubobjType);
5922   }
5923   bool found(APSInt &Value, QualType SubobjType) {
5924     Info.FFDiag(E, diag::note_constexpr_destroy_complex_elem);
5925     return false;
5926   }
5927   bool found(APFloat &Value, QualType SubobjType) {
5928     Info.FFDiag(E, diag::note_constexpr_destroy_complex_elem);
5929     return false;
5930   }
5931 };
5932 }
5933 
5934 /// Perform a destructor or pseudo-destructor call on the given object, which
5935 /// might in general not be a complete object.
5936 static bool HandleDestruction(EvalInfo &Info, const Expr *E,
5937                               const LValue &This, QualType ThisType) {
5938   CompleteObject Obj = findCompleteObject(Info, E, AK_Destroy, This, ThisType);
5939   DestroyObjectHandler Handler = {Info, E, This, AK_Destroy};
5940   return Obj && findSubobject(Info, E, Obj, This.Designator, Handler);
5941 }
5942 
5943 /// Destroy and end the lifetime of the given complete object.
5944 static bool HandleDestruction(EvalInfo &Info, SourceLocation Loc,
5945                               APValue::LValueBase LVBase, APValue &Value,
5946                               QualType T) {
5947   // If we've had an unmodeled side-effect, we can't rely on mutable state
5948   // (such as the object we're about to destroy) being correct.
5949   if (Info.EvalStatus.HasSideEffects)
5950     return false;
5951 
5952   LValue LV;
5953   LV.set({LVBase});
5954   return HandleDestructionImpl(Info, Loc, LV, Value, T);
5955 }
5956 
5957 /// Perform a call to 'perator new' or to `__builtin_operator_new'.
5958 static bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E,
5959                                   LValue &Result) {
5960   if (Info.checkingPotentialConstantExpression() ||
5961       Info.SpeculativeEvaluationDepth)
5962     return false;
5963 
5964   // This is permitted only within a call to std::allocator<T>::allocate.
5965   auto Caller = Info.getStdAllocatorCaller("allocate");
5966   if (!Caller) {
5967     Info.FFDiag(E->getExprLoc(), Info.getLangOpts().CPlusPlus2a
5968                                      ? diag::note_constexpr_new_untyped
5969                                      : diag::note_constexpr_new);
5970     return false;
5971   }
5972 
5973   QualType ElemType = Caller.ElemType;
5974   if (ElemType->isIncompleteType() || ElemType->isFunctionType()) {
5975     Info.FFDiag(E->getExprLoc(),
5976                 diag::note_constexpr_new_not_complete_object_type)
5977         << (ElemType->isIncompleteType() ? 0 : 1) << ElemType;
5978     return false;
5979   }
5980 
5981   APSInt ByteSize;
5982   if (!EvaluateInteger(E->getArg(0), ByteSize, Info))
5983     return false;
5984   bool IsNothrow = false;
5985   for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) {
5986     EvaluateIgnoredValue(Info, E->getArg(I));
5987     IsNothrow |= E->getType()->isNothrowT();
5988   }
5989 
5990   CharUnits ElemSize;
5991   if (!HandleSizeof(Info, E->getExprLoc(), ElemType, ElemSize))
5992     return false;
5993   APInt Size, Remainder;
5994   APInt ElemSizeAP(ByteSize.getBitWidth(), ElemSize.getQuantity());
5995   APInt::udivrem(ByteSize, ElemSizeAP, Size, Remainder);
5996   if (Remainder != 0) {
5997     // This likely indicates a bug in the implementation of 'std::allocator'.
5998     Info.FFDiag(E->getExprLoc(), diag::note_constexpr_operator_new_bad_size)
5999         << ByteSize << APSInt(ElemSizeAP, true) << ElemType;
6000     return false;
6001   }
6002 
6003   if (ByteSize.getActiveBits() > ConstantArrayType::getMaxSizeBits(Info.Ctx)) {
6004     if (IsNothrow) {
6005       Result.setNull(Info.Ctx, E->getType());
6006       return true;
6007     }
6008 
6009     Info.FFDiag(E, diag::note_constexpr_new_too_large) << APSInt(Size, true);
6010     return false;
6011   }
6012 
6013   QualType AllocType = Info.Ctx.getConstantArrayType(ElemType, Size, nullptr,
6014                                                      ArrayType::Normal, 0);
6015   APValue *Val = Info.createHeapAlloc(E, AllocType, Result);
6016   *Val = APValue(APValue::UninitArray(), 0, Size.getZExtValue());
6017   Result.addArray(Info, E, cast<ConstantArrayType>(AllocType));
6018   return true;
6019 }
6020 
6021 static bool hasVirtualDestructor(QualType T) {
6022   if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
6023     if (CXXDestructorDecl *DD = RD->getDestructor())
6024       return DD->isVirtual();
6025   return false;
6026 }
6027 
6028 static const FunctionDecl *getVirtualOperatorDelete(QualType T) {
6029   if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
6030     if (CXXDestructorDecl *DD = RD->getDestructor())
6031       return DD->isVirtual() ? DD->getOperatorDelete() : nullptr;
6032   return nullptr;
6033 }
6034 
6035 /// Check that the given object is a suitable pointer to a heap allocation that
6036 /// still exists and is of the right kind for the purpose of a deletion.
6037 ///
6038 /// On success, returns the heap allocation to deallocate. On failure, produces
6039 /// a diagnostic and returns None.
6040 static Optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E,
6041                                             const LValue &Pointer,
6042                                             DynAlloc::Kind DeallocKind) {
6043   auto PointerAsString = [&] {
6044     return Pointer.toString(Info.Ctx, Info.Ctx.VoidPtrTy);
6045   };
6046 
6047   DynamicAllocLValue DA = Pointer.Base.dyn_cast<DynamicAllocLValue>();
6048   if (!DA) {
6049     Info.FFDiag(E, diag::note_constexpr_delete_not_heap_alloc)
6050         << PointerAsString();
6051     if (Pointer.Base)
6052       NoteLValueLocation(Info, Pointer.Base);
6053     return None;
6054   }
6055 
6056   Optional<DynAlloc *> Alloc = Info.lookupDynamicAlloc(DA);
6057   if (!Alloc) {
6058     Info.FFDiag(E, diag::note_constexpr_double_delete);
6059     return None;
6060   }
6061 
6062   QualType AllocType = Pointer.Base.getDynamicAllocType();
6063   if (DeallocKind != (*Alloc)->getKind()) {
6064     Info.FFDiag(E, diag::note_constexpr_new_delete_mismatch)
6065         << DeallocKind << (*Alloc)->getKind() << AllocType;
6066     NoteLValueLocation(Info, Pointer.Base);
6067     return None;
6068   }
6069 
6070   bool Subobject = false;
6071   if (DeallocKind == DynAlloc::New) {
6072     Subobject = Pointer.Designator.MostDerivedPathLength != 0 ||
6073                 Pointer.Designator.isOnePastTheEnd();
6074   } else {
6075     Subobject = Pointer.Designator.Entries.size() != 1 ||
6076                 Pointer.Designator.Entries[0].getAsArrayIndex() != 0;
6077   }
6078   if (Subobject) {
6079     Info.FFDiag(E, diag::note_constexpr_delete_subobject)
6080         << PointerAsString() << Pointer.Designator.isOnePastTheEnd();
6081     return None;
6082   }
6083 
6084   return Alloc;
6085 }
6086 
6087 // Perform a call to 'operator delete' or '__builtin_operator_delete'.
6088 bool HandleOperatorDeleteCall(EvalInfo &Info, const CallExpr *E) {
6089   if (Info.checkingPotentialConstantExpression() ||
6090       Info.SpeculativeEvaluationDepth)
6091     return false;
6092 
6093   // This is permitted only within a call to std::allocator<T>::deallocate.
6094   if (!Info.getStdAllocatorCaller("deallocate")) {
6095     Info.FFDiag(E->getExprLoc());
6096     return true;
6097   }
6098 
6099   LValue Pointer;
6100   if (!EvaluatePointer(E->getArg(0), Pointer, Info))
6101     return false;
6102   for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I)
6103     EvaluateIgnoredValue(Info, E->getArg(I));
6104 
6105   if (Pointer.Designator.Invalid)
6106     return false;
6107 
6108   // Deleting a null pointer has no effect.
6109   if (Pointer.isNullPointer())
6110     return true;
6111 
6112   if (!CheckDeleteKind(Info, E, Pointer, DynAlloc::StdAllocator))
6113     return false;
6114 
6115   Info.HeapAllocs.erase(Pointer.Base.get<DynamicAllocLValue>());
6116   return true;
6117 }
6118 
6119 //===----------------------------------------------------------------------===//
6120 // Generic Evaluation
6121 //===----------------------------------------------------------------------===//
6122 namespace {
6123 
6124 class BitCastBuffer {
6125   // FIXME: We're going to need bit-level granularity when we support
6126   // bit-fields.
6127   // FIXME: Its possible under the C++ standard for 'char' to not be 8 bits, but
6128   // we don't support a host or target where that is the case. Still, we should
6129   // use a more generic type in case we ever do.
6130   SmallVector<Optional<unsigned char>, 32> Bytes;
6131 
6132   static_assert(std::numeric_limits<unsigned char>::digits >= 8,
6133                 "Need at least 8 bit unsigned char");
6134 
6135   bool TargetIsLittleEndian;
6136 
6137 public:
6138   BitCastBuffer(CharUnits Width, bool TargetIsLittleEndian)
6139       : Bytes(Width.getQuantity()),
6140         TargetIsLittleEndian(TargetIsLittleEndian) {}
6141 
6142   LLVM_NODISCARD
6143   bool readObject(CharUnits Offset, CharUnits Width,
6144                   SmallVectorImpl<unsigned char> &Output) const {
6145     for (CharUnits I = Offset, E = Offset + Width; I != E; ++I) {
6146       // If a byte of an integer is uninitialized, then the whole integer is
6147       // uninitalized.
6148       if (!Bytes[I.getQuantity()])
6149         return false;
6150       Output.push_back(*Bytes[I.getQuantity()]);
6151     }
6152     if (llvm::sys::IsLittleEndianHost != TargetIsLittleEndian)
6153       std::reverse(Output.begin(), Output.end());
6154     return true;
6155   }
6156 
6157   void writeObject(CharUnits Offset, SmallVectorImpl<unsigned char> &Input) {
6158     if (llvm::sys::IsLittleEndianHost != TargetIsLittleEndian)
6159       std::reverse(Input.begin(), Input.end());
6160 
6161     size_t Index = 0;
6162     for (unsigned char Byte : Input) {
6163       assert(!Bytes[Offset.getQuantity() + Index] && "overwriting a byte?");
6164       Bytes[Offset.getQuantity() + Index] = Byte;
6165       ++Index;
6166     }
6167   }
6168 
6169   size_t size() { return Bytes.size(); }
6170 };
6171 
6172 /// Traverse an APValue to produce an BitCastBuffer, emulating how the current
6173 /// target would represent the value at runtime.
6174 class APValueToBufferConverter {
6175   EvalInfo &Info;
6176   BitCastBuffer Buffer;
6177   const CastExpr *BCE;
6178 
6179   APValueToBufferConverter(EvalInfo &Info, CharUnits ObjectWidth,
6180                            const CastExpr *BCE)
6181       : Info(Info),
6182         Buffer(ObjectWidth, Info.Ctx.getTargetInfo().isLittleEndian()),
6183         BCE(BCE) {}
6184 
6185   bool visit(const APValue &Val, QualType Ty) {
6186     return visit(Val, Ty, CharUnits::fromQuantity(0));
6187   }
6188 
6189   // Write out Val with type Ty into Buffer starting at Offset.
6190   bool visit(const APValue &Val, QualType Ty, CharUnits Offset) {
6191     assert((size_t)Offset.getQuantity() <= Buffer.size());
6192 
6193     // As a special case, nullptr_t has an indeterminate value.
6194     if (Ty->isNullPtrType())
6195       return true;
6196 
6197     // Dig through Src to find the byte at SrcOffset.
6198     switch (Val.getKind()) {
6199     case APValue::Indeterminate:
6200     case APValue::None:
6201       return true;
6202 
6203     case APValue::Int:
6204       return visitInt(Val.getInt(), Ty, Offset);
6205     case APValue::Float:
6206       return visitFloat(Val.getFloat(), Ty, Offset);
6207     case APValue::Array:
6208       return visitArray(Val, Ty, Offset);
6209     case APValue::Struct:
6210       return visitRecord(Val, Ty, Offset);
6211 
6212     case APValue::ComplexInt:
6213     case APValue::ComplexFloat:
6214     case APValue::Vector:
6215     case APValue::FixedPoint:
6216       // FIXME: We should support these.
6217 
6218     case APValue::Union:
6219     case APValue::MemberPointer:
6220     case APValue::AddrLabelDiff: {
6221       Info.FFDiag(BCE->getBeginLoc(),
6222                   diag::note_constexpr_bit_cast_unsupported_type)
6223           << Ty;
6224       return false;
6225     }
6226 
6227     case APValue::LValue:
6228       llvm_unreachable("LValue subobject in bit_cast?");
6229     }
6230     llvm_unreachable("Unhandled APValue::ValueKind");
6231   }
6232 
6233   bool visitRecord(const APValue &Val, QualType Ty, CharUnits Offset) {
6234     const RecordDecl *RD = Ty->getAsRecordDecl();
6235     const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6236 
6237     // Visit the base classes.
6238     if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
6239       for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) {
6240         const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I];
6241         CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
6242 
6243         if (!visitRecord(Val.getStructBase(I), BS.getType(),
6244                          Layout.getBaseClassOffset(BaseDecl) + Offset))
6245           return false;
6246       }
6247     }
6248 
6249     // Visit the fields.
6250     unsigned FieldIdx = 0;
6251     for (FieldDecl *FD : RD->fields()) {
6252       if (FD->isBitField()) {
6253         Info.FFDiag(BCE->getBeginLoc(),
6254                     diag::note_constexpr_bit_cast_unsupported_bitfield);
6255         return false;
6256       }
6257 
6258       uint64_t FieldOffsetBits = Layout.getFieldOffset(FieldIdx);
6259 
6260       assert(FieldOffsetBits % Info.Ctx.getCharWidth() == 0 &&
6261              "only bit-fields can have sub-char alignment");
6262       CharUnits FieldOffset =
6263           Info.Ctx.toCharUnitsFromBits(FieldOffsetBits) + Offset;
6264       QualType FieldTy = FD->getType();
6265       if (!visit(Val.getStructField(FieldIdx), FieldTy, FieldOffset))
6266         return false;
6267       ++FieldIdx;
6268     }
6269 
6270     return true;
6271   }
6272 
6273   bool visitArray(const APValue &Val, QualType Ty, CharUnits Offset) {
6274     const auto *CAT =
6275         dyn_cast_or_null<ConstantArrayType>(Ty->getAsArrayTypeUnsafe());
6276     if (!CAT)
6277       return false;
6278 
6279     CharUnits ElemWidth = Info.Ctx.getTypeSizeInChars(CAT->getElementType());
6280     unsigned NumInitializedElts = Val.getArrayInitializedElts();
6281     unsigned ArraySize = Val.getArraySize();
6282     // First, initialize the initialized elements.
6283     for (unsigned I = 0; I != NumInitializedElts; ++I) {
6284       const APValue &SubObj = Val.getArrayInitializedElt(I);
6285       if (!visit(SubObj, CAT->getElementType(), Offset + I * ElemWidth))
6286         return false;
6287     }
6288 
6289     // Next, initialize the rest of the array using the filler.
6290     if (Val.hasArrayFiller()) {
6291       const APValue &Filler = Val.getArrayFiller();
6292       for (unsigned I = NumInitializedElts; I != ArraySize; ++I) {
6293         if (!visit(Filler, CAT->getElementType(), Offset + I * ElemWidth))
6294           return false;
6295       }
6296     }
6297 
6298     return true;
6299   }
6300 
6301   bool visitInt(const APSInt &Val, QualType Ty, CharUnits Offset) {
6302     CharUnits Width = Info.Ctx.getTypeSizeInChars(Ty);
6303     SmallVector<unsigned char, 8> Bytes(Width.getQuantity());
6304     llvm::StoreIntToMemory(Val, &*Bytes.begin(), Width.getQuantity());
6305     Buffer.writeObject(Offset, Bytes);
6306     return true;
6307   }
6308 
6309   bool visitFloat(const APFloat &Val, QualType Ty, CharUnits Offset) {
6310     APSInt AsInt(Val.bitcastToAPInt());
6311     return visitInt(AsInt, Ty, Offset);
6312   }
6313 
6314 public:
6315   static Optional<BitCastBuffer> convert(EvalInfo &Info, const APValue &Src,
6316                                          const CastExpr *BCE) {
6317     CharUnits DstSize = Info.Ctx.getTypeSizeInChars(BCE->getType());
6318     APValueToBufferConverter Converter(Info, DstSize, BCE);
6319     if (!Converter.visit(Src, BCE->getSubExpr()->getType()))
6320       return None;
6321     return Converter.Buffer;
6322   }
6323 };
6324 
6325 /// Write an BitCastBuffer into an APValue.
6326 class BufferToAPValueConverter {
6327   EvalInfo &Info;
6328   const BitCastBuffer &Buffer;
6329   const CastExpr *BCE;
6330 
6331   BufferToAPValueConverter(EvalInfo &Info, const BitCastBuffer &Buffer,
6332                            const CastExpr *BCE)
6333       : Info(Info), Buffer(Buffer), BCE(BCE) {}
6334 
6335   // Emit an unsupported bit_cast type error. Sema refuses to build a bit_cast
6336   // with an invalid type, so anything left is a deficiency on our part (FIXME).
6337   // Ideally this will be unreachable.
6338   llvm::NoneType unsupportedType(QualType Ty) {
6339     Info.FFDiag(BCE->getBeginLoc(),
6340                 diag::note_constexpr_bit_cast_unsupported_type)
6341         << Ty;
6342     return None;
6343   }
6344 
6345   Optional<APValue> visit(const BuiltinType *T, CharUnits Offset,
6346                           const EnumType *EnumSugar = nullptr) {
6347     if (T->isNullPtrType()) {
6348       uint64_t NullValue = Info.Ctx.getTargetNullPointerValue(QualType(T, 0));
6349       return APValue((Expr *)nullptr,
6350                      /*Offset=*/CharUnits::fromQuantity(NullValue),
6351                      APValue::NoLValuePath{}, /*IsNullPtr=*/true);
6352     }
6353 
6354     CharUnits SizeOf = Info.Ctx.getTypeSizeInChars(T);
6355     SmallVector<uint8_t, 8> Bytes;
6356     if (!Buffer.readObject(Offset, SizeOf, Bytes)) {
6357       // If this is std::byte or unsigned char, then its okay to store an
6358       // indeterminate value.
6359       bool IsStdByte = EnumSugar && EnumSugar->isStdByteType();
6360       bool IsUChar =
6361           !EnumSugar && (T->isSpecificBuiltinType(BuiltinType::UChar) ||
6362                          T->isSpecificBuiltinType(BuiltinType::Char_U));
6363       if (!IsStdByte && !IsUChar) {
6364         QualType DisplayType(EnumSugar ? (const Type *)EnumSugar : T, 0);
6365         Info.FFDiag(BCE->getExprLoc(),
6366                     diag::note_constexpr_bit_cast_indet_dest)
6367             << DisplayType << Info.Ctx.getLangOpts().CharIsSigned;
6368         return None;
6369       }
6370 
6371       return APValue::IndeterminateValue();
6372     }
6373 
6374     APSInt Val(SizeOf.getQuantity() * Info.Ctx.getCharWidth(), true);
6375     llvm::LoadIntFromMemory(Val, &*Bytes.begin(), Bytes.size());
6376 
6377     if (T->isIntegralOrEnumerationType()) {
6378       Val.setIsSigned(T->isSignedIntegerOrEnumerationType());
6379       return APValue(Val);
6380     }
6381 
6382     if (T->isRealFloatingType()) {
6383       const llvm::fltSemantics &Semantics =
6384           Info.Ctx.getFloatTypeSemantics(QualType(T, 0));
6385       return APValue(APFloat(Semantics, Val));
6386     }
6387 
6388     return unsupportedType(QualType(T, 0));
6389   }
6390 
6391   Optional<APValue> visit(const RecordType *RTy, CharUnits Offset) {
6392     const RecordDecl *RD = RTy->getAsRecordDecl();
6393     const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6394 
6395     unsigned NumBases = 0;
6396     if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
6397       NumBases = CXXRD->getNumBases();
6398 
6399     APValue ResultVal(APValue::UninitStruct(), NumBases,
6400                       std::distance(RD->field_begin(), RD->field_end()));
6401 
6402     // Visit the base classes.
6403     if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
6404       for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) {
6405         const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I];
6406         CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
6407         if (BaseDecl->isEmpty() ||
6408             Info.Ctx.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero())
6409           continue;
6410 
6411         Optional<APValue> SubObj = visitType(
6412             BS.getType(), Layout.getBaseClassOffset(BaseDecl) + Offset);
6413         if (!SubObj)
6414           return None;
6415         ResultVal.getStructBase(I) = *SubObj;
6416       }
6417     }
6418 
6419     // Visit the fields.
6420     unsigned FieldIdx = 0;
6421     for (FieldDecl *FD : RD->fields()) {
6422       // FIXME: We don't currently support bit-fields. A lot of the logic for
6423       // this is in CodeGen, so we need to factor it around.
6424       if (FD->isBitField()) {
6425         Info.FFDiag(BCE->getBeginLoc(),
6426                     diag::note_constexpr_bit_cast_unsupported_bitfield);
6427         return None;
6428       }
6429 
6430       uint64_t FieldOffsetBits = Layout.getFieldOffset(FieldIdx);
6431       assert(FieldOffsetBits % Info.Ctx.getCharWidth() == 0);
6432 
6433       CharUnits FieldOffset =
6434           CharUnits::fromQuantity(FieldOffsetBits / Info.Ctx.getCharWidth()) +
6435           Offset;
6436       QualType FieldTy = FD->getType();
6437       Optional<APValue> SubObj = visitType(FieldTy, FieldOffset);
6438       if (!SubObj)
6439         return None;
6440       ResultVal.getStructField(FieldIdx) = *SubObj;
6441       ++FieldIdx;
6442     }
6443 
6444     return ResultVal;
6445   }
6446 
6447   Optional<APValue> visit(const EnumType *Ty, CharUnits Offset) {
6448     QualType RepresentationType = Ty->getDecl()->getIntegerType();
6449     assert(!RepresentationType.isNull() &&
6450            "enum forward decl should be caught by Sema");
6451     const auto *AsBuiltin =
6452         RepresentationType.getCanonicalType()->castAs<BuiltinType>();
6453     // Recurse into the underlying type. Treat std::byte transparently as
6454     // unsigned char.
6455     return visit(AsBuiltin, Offset, /*EnumTy=*/Ty);
6456   }
6457 
6458   Optional<APValue> visit(const ConstantArrayType *Ty, CharUnits Offset) {
6459     size_t Size = Ty->getSize().getLimitedValue();
6460     CharUnits ElementWidth = Info.Ctx.getTypeSizeInChars(Ty->getElementType());
6461 
6462     APValue ArrayValue(APValue::UninitArray(), Size, Size);
6463     for (size_t I = 0; I != Size; ++I) {
6464       Optional<APValue> ElementValue =
6465           visitType(Ty->getElementType(), Offset + I * ElementWidth);
6466       if (!ElementValue)
6467         return None;
6468       ArrayValue.getArrayInitializedElt(I) = std::move(*ElementValue);
6469     }
6470 
6471     return ArrayValue;
6472   }
6473 
6474   Optional<APValue> visit(const Type *Ty, CharUnits Offset) {
6475     return unsupportedType(QualType(Ty, 0));
6476   }
6477 
6478   Optional<APValue> visitType(QualType Ty, CharUnits Offset) {
6479     QualType Can = Ty.getCanonicalType();
6480 
6481     switch (Can->getTypeClass()) {
6482 #define TYPE(Class, Base)                                                      \
6483   case Type::Class:                                                            \
6484     return visit(cast<Class##Type>(Can.getTypePtr()), Offset);
6485 #define ABSTRACT_TYPE(Class, Base)
6486 #define NON_CANONICAL_TYPE(Class, Base)                                        \
6487   case Type::Class:                                                            \
6488     llvm_unreachable("non-canonical type should be impossible!");
6489 #define DEPENDENT_TYPE(Class, Base)                                            \
6490   case Type::Class:                                                            \
6491     llvm_unreachable(                                                          \
6492         "dependent types aren't supported in the constant evaluator!");
6493 #define NON_CANONICAL_UNLESS_DEPENDENT(Class, Base)                            \
6494   case Type::Class:                                                            \
6495     llvm_unreachable("either dependent or not canonical!");
6496 #include "clang/AST/TypeNodes.inc"
6497     }
6498     llvm_unreachable("Unhandled Type::TypeClass");
6499   }
6500 
6501 public:
6502   // Pull out a full value of type DstType.
6503   static Optional<APValue> convert(EvalInfo &Info, BitCastBuffer &Buffer,
6504                                    const CastExpr *BCE) {
6505     BufferToAPValueConverter Converter(Info, Buffer, BCE);
6506     return Converter.visitType(BCE->getType(), CharUnits::fromQuantity(0));
6507   }
6508 };
6509 
6510 static bool checkBitCastConstexprEligibilityType(SourceLocation Loc,
6511                                                  QualType Ty, EvalInfo *Info,
6512                                                  const ASTContext &Ctx,
6513                                                  bool CheckingDest) {
6514   Ty = Ty.getCanonicalType();
6515 
6516   auto diag = [&](int Reason) {
6517     if (Info)
6518       Info->FFDiag(Loc, diag::note_constexpr_bit_cast_invalid_type)
6519           << CheckingDest << (Reason == 4) << Reason;
6520     return false;
6521   };
6522   auto note = [&](int Construct, QualType NoteTy, SourceLocation NoteLoc) {
6523     if (Info)
6524       Info->Note(NoteLoc, diag::note_constexpr_bit_cast_invalid_subtype)
6525           << NoteTy << Construct << Ty;
6526     return false;
6527   };
6528 
6529   if (Ty->isUnionType())
6530     return diag(0);
6531   if (Ty->isPointerType())
6532     return diag(1);
6533   if (Ty->isMemberPointerType())
6534     return diag(2);
6535   if (Ty.isVolatileQualified())
6536     return diag(3);
6537 
6538   if (RecordDecl *Record = Ty->getAsRecordDecl()) {
6539     if (auto *CXXRD = dyn_cast<CXXRecordDecl>(Record)) {
6540       for (CXXBaseSpecifier &BS : CXXRD->bases())
6541         if (!checkBitCastConstexprEligibilityType(Loc, BS.getType(), Info, Ctx,
6542                                                   CheckingDest))
6543           return note(1, BS.getType(), BS.getBeginLoc());
6544     }
6545     for (FieldDecl *FD : Record->fields()) {
6546       if (FD->getType()->isReferenceType())
6547         return diag(4);
6548       if (!checkBitCastConstexprEligibilityType(Loc, FD->getType(), Info, Ctx,
6549                                                 CheckingDest))
6550         return note(0, FD->getType(), FD->getBeginLoc());
6551     }
6552   }
6553 
6554   if (Ty->isArrayType() &&
6555       !checkBitCastConstexprEligibilityType(Loc, Ctx.getBaseElementType(Ty),
6556                                             Info, Ctx, CheckingDest))
6557     return false;
6558 
6559   return true;
6560 }
6561 
6562 static bool checkBitCastConstexprEligibility(EvalInfo *Info,
6563                                              const ASTContext &Ctx,
6564                                              const CastExpr *BCE) {
6565   bool DestOK = checkBitCastConstexprEligibilityType(
6566       BCE->getBeginLoc(), BCE->getType(), Info, Ctx, true);
6567   bool SourceOK = DestOK && checkBitCastConstexprEligibilityType(
6568                                 BCE->getBeginLoc(),
6569                                 BCE->getSubExpr()->getType(), Info, Ctx, false);
6570   return SourceOK;
6571 }
6572 
6573 static bool handleLValueToRValueBitCast(EvalInfo &Info, APValue &DestValue,
6574                                         APValue &SourceValue,
6575                                         const CastExpr *BCE) {
6576   assert(CHAR_BIT == 8 && Info.Ctx.getTargetInfo().getCharWidth() == 8 &&
6577          "no host or target supports non 8-bit chars");
6578   assert(SourceValue.isLValue() &&
6579          "LValueToRValueBitcast requires an lvalue operand!");
6580 
6581   if (!checkBitCastConstexprEligibility(&Info, Info.Ctx, BCE))
6582     return false;
6583 
6584   LValue SourceLValue;
6585   APValue SourceRValue;
6586   SourceLValue.setFrom(Info.Ctx, SourceValue);
6587   if (!handleLValueToRValueConversion(
6588           Info, BCE, BCE->getSubExpr()->getType().withConst(), SourceLValue,
6589           SourceRValue, /*WantObjectRepresentation=*/true))
6590     return false;
6591 
6592   // Read out SourceValue into a char buffer.
6593   Optional<BitCastBuffer> Buffer =
6594       APValueToBufferConverter::convert(Info, SourceRValue, BCE);
6595   if (!Buffer)
6596     return false;
6597 
6598   // Write out the buffer into a new APValue.
6599   Optional<APValue> MaybeDestValue =
6600       BufferToAPValueConverter::convert(Info, *Buffer, BCE);
6601   if (!MaybeDestValue)
6602     return false;
6603 
6604   DestValue = std::move(*MaybeDestValue);
6605   return true;
6606 }
6607 
6608 template <class Derived>
6609 class ExprEvaluatorBase
6610   : public ConstStmtVisitor<Derived, bool> {
6611 private:
6612   Derived &getDerived() { return static_cast<Derived&>(*this); }
6613   bool DerivedSuccess(const APValue &V, const Expr *E) {
6614     return getDerived().Success(V, E);
6615   }
6616   bool DerivedZeroInitialization(const Expr *E) {
6617     return getDerived().ZeroInitialization(E);
6618   }
6619 
6620   // Check whether a conditional operator with a non-constant condition is a
6621   // potential constant expression. If neither arm is a potential constant
6622   // expression, then the conditional operator is not either.
6623   template<typename ConditionalOperator>
6624   void CheckPotentialConstantConditional(const ConditionalOperator *E) {
6625     assert(Info.checkingPotentialConstantExpression());
6626 
6627     // Speculatively evaluate both arms.
6628     SmallVector<PartialDiagnosticAt, 8> Diag;
6629     {
6630       SpeculativeEvaluationRAII Speculate(Info, &Diag);
6631       StmtVisitorTy::Visit(E->getFalseExpr());
6632       if (Diag.empty())
6633         return;
6634     }
6635 
6636     {
6637       SpeculativeEvaluationRAII Speculate(Info, &Diag);
6638       Diag.clear();
6639       StmtVisitorTy::Visit(E->getTrueExpr());
6640       if (Diag.empty())
6641         return;
6642     }
6643 
6644     Error(E, diag::note_constexpr_conditional_never_const);
6645   }
6646 
6647 
6648   template<typename ConditionalOperator>
6649   bool HandleConditionalOperator(const ConditionalOperator *E) {
6650     bool BoolResult;
6651     if (!EvaluateAsBooleanCondition(E->getCond(), BoolResult, Info)) {
6652       if (Info.checkingPotentialConstantExpression() && Info.noteFailure()) {
6653         CheckPotentialConstantConditional(E);
6654         return false;
6655       }
6656       if (Info.noteFailure()) {
6657         StmtVisitorTy::Visit(E->getTrueExpr());
6658         StmtVisitorTy::Visit(E->getFalseExpr());
6659       }
6660       return false;
6661     }
6662 
6663     Expr *EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr();
6664     return StmtVisitorTy::Visit(EvalExpr);
6665   }
6666 
6667 protected:
6668   EvalInfo &Info;
6669   typedef ConstStmtVisitor<Derived, bool> StmtVisitorTy;
6670   typedef ExprEvaluatorBase ExprEvaluatorBaseTy;
6671 
6672   OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
6673     return Info.CCEDiag(E, D);
6674   }
6675 
6676   bool ZeroInitialization(const Expr *E) { return Error(E); }
6677 
6678 public:
6679   ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
6680 
6681   EvalInfo &getEvalInfo() { return Info; }
6682 
6683   /// Report an evaluation error. This should only be called when an error is
6684   /// first discovered. When propagating an error, just return false.
6685   bool Error(const Expr *E, diag::kind D) {
6686     Info.FFDiag(E, D);
6687     return false;
6688   }
6689   bool Error(const Expr *E) {
6690     return Error(E, diag::note_invalid_subexpr_in_const_expr);
6691   }
6692 
6693   bool VisitStmt(const Stmt *) {
6694     llvm_unreachable("Expression evaluator should not be called on stmts");
6695   }
6696   bool VisitExpr(const Expr *E) {
6697     return Error(E);
6698   }
6699 
6700   bool VisitConstantExpr(const ConstantExpr *E)
6701     { return StmtVisitorTy::Visit(E->getSubExpr()); }
6702   bool VisitParenExpr(const ParenExpr *E)
6703     { return StmtVisitorTy::Visit(E->getSubExpr()); }
6704   bool VisitUnaryExtension(const UnaryOperator *E)
6705     { return StmtVisitorTy::Visit(E->getSubExpr()); }
6706   bool VisitUnaryPlus(const UnaryOperator *E)
6707     { return StmtVisitorTy::Visit(E->getSubExpr()); }
6708   bool VisitChooseExpr(const ChooseExpr *E)
6709     { return StmtVisitorTy::Visit(E->getChosenSubExpr()); }
6710   bool VisitGenericSelectionExpr(const GenericSelectionExpr *E)
6711     { return StmtVisitorTy::Visit(E->getResultExpr()); }
6712   bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E)
6713     { return StmtVisitorTy::Visit(E->getReplacement()); }
6714   bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) {
6715     TempVersionRAII RAII(*Info.CurrentCall);
6716     SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope);
6717     return StmtVisitorTy::Visit(E->getExpr());
6718   }
6719   bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
6720     TempVersionRAII RAII(*Info.CurrentCall);
6721     // The initializer may not have been parsed yet, or might be erroneous.
6722     if (!E->getExpr())
6723       return Error(E);
6724     SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope);
6725     return StmtVisitorTy::Visit(E->getExpr());
6726   }
6727 
6728   bool VisitExprWithCleanups(const ExprWithCleanups *E) {
6729     FullExpressionRAII Scope(Info);
6730     return StmtVisitorTy::Visit(E->getSubExpr()) && Scope.destroy();
6731   }
6732 
6733   // Temporaries are registered when created, so we don't care about
6734   // CXXBindTemporaryExpr.
6735   bool VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E) {
6736     return StmtVisitorTy::Visit(E->getSubExpr());
6737   }
6738 
6739   bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
6740     CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
6741     return static_cast<Derived*>(this)->VisitCastExpr(E);
6742   }
6743   bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
6744     if (!Info.Ctx.getLangOpts().CPlusPlus2a)
6745       CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
6746     return static_cast<Derived*>(this)->VisitCastExpr(E);
6747   }
6748   bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E) {
6749     return static_cast<Derived*>(this)->VisitCastExpr(E);
6750   }
6751 
6752   bool VisitBinaryOperator(const BinaryOperator *E) {
6753     switch (E->getOpcode()) {
6754     default:
6755       return Error(E);
6756 
6757     case BO_Comma:
6758       VisitIgnoredValue(E->getLHS());
6759       return StmtVisitorTy::Visit(E->getRHS());
6760 
6761     case BO_PtrMemD:
6762     case BO_PtrMemI: {
6763       LValue Obj;
6764       if (!HandleMemberPointerAccess(Info, E, Obj))
6765         return false;
6766       APValue Result;
6767       if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result))
6768         return false;
6769       return DerivedSuccess(Result, E);
6770     }
6771     }
6772   }
6773 
6774   bool VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *E) {
6775     return StmtVisitorTy::Visit(E->getSemanticForm());
6776   }
6777 
6778   bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E) {
6779     // Evaluate and cache the common expression. We treat it as a temporary,
6780     // even though it's not quite the same thing.
6781     LValue CommonLV;
6782     if (!Evaluate(Info.CurrentCall->createTemporary(
6783                       E->getOpaqueValue(),
6784                       getStorageType(Info.Ctx, E->getOpaqueValue()), false,
6785                       CommonLV),
6786                   Info, E->getCommon()))
6787       return false;
6788 
6789     return HandleConditionalOperator(E);
6790   }
6791 
6792   bool VisitConditionalOperator(const ConditionalOperator *E) {
6793     bool IsBcpCall = false;
6794     // If the condition (ignoring parens) is a __builtin_constant_p call,
6795     // the result is a constant expression if it can be folded without
6796     // side-effects. This is an important GNU extension. See GCC PR38377
6797     // for discussion.
6798     if (const CallExpr *CallCE =
6799           dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
6800       if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
6801         IsBcpCall = true;
6802 
6803     // Always assume __builtin_constant_p(...) ? ... : ... is a potential
6804     // constant expression; we can't check whether it's potentially foldable.
6805     // FIXME: We should instead treat __builtin_constant_p as non-constant if
6806     // it would return 'false' in this mode.
6807     if (Info.checkingPotentialConstantExpression() && IsBcpCall)
6808       return false;
6809 
6810     FoldConstant Fold(Info, IsBcpCall);
6811     if (!HandleConditionalOperator(E)) {
6812       Fold.keepDiagnostics();
6813       return false;
6814     }
6815 
6816     return true;
6817   }
6818 
6819   bool VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
6820     if (APValue *Value = Info.CurrentCall->getCurrentTemporary(E))
6821       return DerivedSuccess(*Value, E);
6822 
6823     const Expr *Source = E->getSourceExpr();
6824     if (!Source)
6825       return Error(E);
6826     if (Source == E) { // sanity checking.
6827       assert(0 && "OpaqueValueExpr recursively refers to itself");
6828       return Error(E);
6829     }
6830     return StmtVisitorTy::Visit(Source);
6831   }
6832 
6833   bool VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
6834     for (const Expr *SemE : E->semantics()) {
6835       if (auto *OVE = dyn_cast<OpaqueValueExpr>(SemE)) {
6836         // FIXME: We can't handle the case where an OpaqueValueExpr is also the
6837         // result expression: there could be two different LValues that would
6838         // refer to the same object in that case, and we can't model that.
6839         if (SemE == E->getResultExpr())
6840           return Error(E);
6841 
6842         // Unique OVEs get evaluated if and when we encounter them when
6843         // emitting the rest of the semantic form, rather than eagerly.
6844         if (OVE->isUnique())
6845           continue;
6846 
6847         LValue LV;
6848         if (!Evaluate(Info.CurrentCall->createTemporary(
6849                           OVE, getStorageType(Info.Ctx, OVE), false, LV),
6850                       Info, OVE->getSourceExpr()))
6851           return false;
6852       } else if (SemE == E->getResultExpr()) {
6853         if (!StmtVisitorTy::Visit(SemE))
6854           return false;
6855       } else {
6856         if (!EvaluateIgnoredValue(Info, SemE))
6857           return false;
6858       }
6859     }
6860     return true;
6861   }
6862 
6863   bool VisitCallExpr(const CallExpr *E) {
6864     APValue Result;
6865     if (!handleCallExpr(E, Result, nullptr))
6866       return false;
6867     return DerivedSuccess(Result, E);
6868   }
6869 
6870   bool handleCallExpr(const CallExpr *E, APValue &Result,
6871                      const LValue *ResultSlot) {
6872     const Expr *Callee = E->getCallee()->IgnoreParens();
6873     QualType CalleeType = Callee->getType();
6874 
6875     const FunctionDecl *FD = nullptr;
6876     LValue *This = nullptr, ThisVal;
6877     auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
6878     bool HasQualifier = false;
6879 
6880     // Extract function decl and 'this' pointer from the callee.
6881     if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) {
6882       const CXXMethodDecl *Member = nullptr;
6883       if (const MemberExpr *ME = dyn_cast<MemberExpr>(Callee)) {
6884         // Explicit bound member calls, such as x.f() or p->g();
6885         if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal))
6886           return false;
6887         Member = dyn_cast<CXXMethodDecl>(ME->getMemberDecl());
6888         if (!Member)
6889           return Error(Callee);
6890         This = &ThisVal;
6891         HasQualifier = ME->hasQualifier();
6892       } else if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) {
6893         // Indirect bound member calls ('.*' or '->*').
6894         const ValueDecl *D =
6895             HandleMemberPointerAccess(Info, BE, ThisVal, false);
6896         if (!D)
6897           return false;
6898         Member = dyn_cast<CXXMethodDecl>(D);
6899         if (!Member)
6900           return Error(Callee);
6901         This = &ThisVal;
6902       } else if (const auto *PDE = dyn_cast<CXXPseudoDestructorExpr>(Callee)) {
6903         if (!Info.getLangOpts().CPlusPlus2a)
6904           Info.CCEDiag(PDE, diag::note_constexpr_pseudo_destructor);
6905         // FIXME: If pseudo-destructor calls ever start ending the lifetime of
6906         // their callee, we should start calling HandleDestruction here.
6907         // For now, we just evaluate the object argument and discard it.
6908         return EvaluateObjectArgument(Info, PDE->getBase(), ThisVal);
6909       } else
6910         return Error(Callee);
6911       FD = Member;
6912     } else if (CalleeType->isFunctionPointerType()) {
6913       LValue Call;
6914       if (!EvaluatePointer(Callee, Call, Info))
6915         return false;
6916 
6917       if (!Call.getLValueOffset().isZero())
6918         return Error(Callee);
6919       FD = dyn_cast_or_null<FunctionDecl>(
6920                              Call.getLValueBase().dyn_cast<const ValueDecl*>());
6921       if (!FD)
6922         return Error(Callee);
6923       // Don't call function pointers which have been cast to some other type.
6924       // Per DR (no number yet), the caller and callee can differ in noexcept.
6925       if (!Info.Ctx.hasSameFunctionTypeIgnoringExceptionSpec(
6926         CalleeType->getPointeeType(), FD->getType())) {
6927         return Error(E);
6928       }
6929 
6930       // Overloaded operator calls to member functions are represented as normal
6931       // calls with '*this' as the first argument.
6932       const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
6933       if (MD && !MD->isStatic()) {
6934         // FIXME: When selecting an implicit conversion for an overloaded
6935         // operator delete, we sometimes try to evaluate calls to conversion
6936         // operators without a 'this' parameter!
6937         if (Args.empty())
6938           return Error(E);
6939 
6940         if (!EvaluateObjectArgument(Info, Args[0], ThisVal))
6941           return false;
6942         This = &ThisVal;
6943         Args = Args.slice(1);
6944       } else if (MD && MD->isLambdaStaticInvoker()) {
6945         // Map the static invoker for the lambda back to the call operator.
6946         // Conveniently, we don't have to slice out the 'this' argument (as is
6947         // being done for the non-static case), since a static member function
6948         // doesn't have an implicit argument passed in.
6949         const CXXRecordDecl *ClosureClass = MD->getParent();
6950         assert(
6951             ClosureClass->captures_begin() == ClosureClass->captures_end() &&
6952             "Number of captures must be zero for conversion to function-ptr");
6953 
6954         const CXXMethodDecl *LambdaCallOp =
6955             ClosureClass->getLambdaCallOperator();
6956 
6957         // Set 'FD', the function that will be called below, to the call
6958         // operator.  If the closure object represents a generic lambda, find
6959         // the corresponding specialization of the call operator.
6960 
6961         if (ClosureClass->isGenericLambda()) {
6962           assert(MD->isFunctionTemplateSpecialization() &&
6963                  "A generic lambda's static-invoker function must be a "
6964                  "template specialization");
6965           const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs();
6966           FunctionTemplateDecl *CallOpTemplate =
6967               LambdaCallOp->getDescribedFunctionTemplate();
6968           void *InsertPos = nullptr;
6969           FunctionDecl *CorrespondingCallOpSpecialization =
6970               CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos);
6971           assert(CorrespondingCallOpSpecialization &&
6972                  "We must always have a function call operator specialization "
6973                  "that corresponds to our static invoker specialization");
6974           FD = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization);
6975         } else
6976           FD = LambdaCallOp;
6977       } else if (FD->isReplaceableGlobalAllocationFunction()) {
6978         if (FD->getDeclName().getCXXOverloadedOperator() == OO_New ||
6979             FD->getDeclName().getCXXOverloadedOperator() == OO_Array_New) {
6980           LValue Ptr;
6981           if (!HandleOperatorNewCall(Info, E, Ptr))
6982             return false;
6983           Ptr.moveInto(Result);
6984           return true;
6985         } else {
6986           return HandleOperatorDeleteCall(Info, E);
6987         }
6988       }
6989     } else
6990       return Error(E);
6991 
6992     SmallVector<QualType, 4> CovariantAdjustmentPath;
6993     if (This) {
6994       auto *NamedMember = dyn_cast<CXXMethodDecl>(FD);
6995       if (NamedMember && NamedMember->isVirtual() && !HasQualifier) {
6996         // Perform virtual dispatch, if necessary.
6997         FD = HandleVirtualDispatch(Info, E, *This, NamedMember,
6998                                    CovariantAdjustmentPath);
6999         if (!FD)
7000           return false;
7001       } else {
7002         // Check that the 'this' pointer points to an object of the right type.
7003         // FIXME: If this is an assignment operator call, we may need to change
7004         // the active union member before we check this.
7005         if (!checkNonVirtualMemberCallThisPointer(Info, E, *This, NamedMember))
7006           return false;
7007       }
7008     }
7009 
7010     // Destructor calls are different enough that they have their own codepath.
7011     if (auto *DD = dyn_cast<CXXDestructorDecl>(FD)) {
7012       assert(This && "no 'this' pointer for destructor call");
7013       return HandleDestruction(Info, E, *This,
7014                                Info.Ctx.getRecordType(DD->getParent()));
7015     }
7016 
7017     const FunctionDecl *Definition = nullptr;
7018     Stmt *Body = FD->getBody(Definition);
7019 
7020     if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body) ||
7021         !HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Body, Info,
7022                             Result, ResultSlot))
7023       return false;
7024 
7025     if (!CovariantAdjustmentPath.empty() &&
7026         !HandleCovariantReturnAdjustment(Info, E, Result,
7027                                          CovariantAdjustmentPath))
7028       return false;
7029 
7030     return true;
7031   }
7032 
7033   bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
7034     return StmtVisitorTy::Visit(E->getInitializer());
7035   }
7036   bool VisitInitListExpr(const InitListExpr *E) {
7037     if (E->getNumInits() == 0)
7038       return DerivedZeroInitialization(E);
7039     if (E->getNumInits() == 1)
7040       return StmtVisitorTy::Visit(E->getInit(0));
7041     return Error(E);
7042   }
7043   bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
7044     return DerivedZeroInitialization(E);
7045   }
7046   bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
7047     return DerivedZeroInitialization(E);
7048   }
7049   bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
7050     return DerivedZeroInitialization(E);
7051   }
7052 
7053   /// A member expression where the object is a prvalue is itself a prvalue.
7054   bool VisitMemberExpr(const MemberExpr *E) {
7055     assert(!Info.Ctx.getLangOpts().CPlusPlus11 &&
7056            "missing temporary materialization conversion");
7057     assert(!E->isArrow() && "missing call to bound member function?");
7058 
7059     APValue Val;
7060     if (!Evaluate(Val, Info, E->getBase()))
7061       return false;
7062 
7063     QualType BaseTy = E->getBase()->getType();
7064 
7065     const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
7066     if (!FD) return Error(E);
7067     assert(!FD->getType()->isReferenceType() && "prvalue reference?");
7068     assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() ==
7069            FD->getParent()->getCanonicalDecl() && "record / field mismatch");
7070 
7071     // Note: there is no lvalue base here. But this case should only ever
7072     // happen in C or in C++98, where we cannot be evaluating a constexpr
7073     // constructor, which is the only case the base matters.
7074     CompleteObject Obj(APValue::LValueBase(), &Val, BaseTy);
7075     SubobjectDesignator Designator(BaseTy);
7076     Designator.addDeclUnchecked(FD);
7077 
7078     APValue Result;
7079     return extractSubobject(Info, E, Obj, Designator, Result) &&
7080            DerivedSuccess(Result, E);
7081   }
7082 
7083   bool VisitCastExpr(const CastExpr *E) {
7084     switch (E->getCastKind()) {
7085     default:
7086       break;
7087 
7088     case CK_AtomicToNonAtomic: {
7089       APValue AtomicVal;
7090       // This does not need to be done in place even for class/array types:
7091       // atomic-to-non-atomic conversion implies copying the object
7092       // representation.
7093       if (!Evaluate(AtomicVal, Info, E->getSubExpr()))
7094         return false;
7095       return DerivedSuccess(AtomicVal, E);
7096     }
7097 
7098     case CK_NoOp:
7099     case CK_UserDefinedConversion:
7100       return StmtVisitorTy::Visit(E->getSubExpr());
7101 
7102     case CK_LValueToRValue: {
7103       LValue LVal;
7104       if (!EvaluateLValue(E->getSubExpr(), LVal, Info))
7105         return false;
7106       APValue RVal;
7107       // Note, we use the subexpression's type in order to retain cv-qualifiers.
7108       if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
7109                                           LVal, RVal))
7110         return false;
7111       return DerivedSuccess(RVal, E);
7112     }
7113     case CK_LValueToRValueBitCast: {
7114       APValue DestValue, SourceValue;
7115       if (!Evaluate(SourceValue, Info, E->getSubExpr()))
7116         return false;
7117       if (!handleLValueToRValueBitCast(Info, DestValue, SourceValue, E))
7118         return false;
7119       return DerivedSuccess(DestValue, E);
7120     }
7121 
7122     case CK_AddressSpaceConversion: {
7123       APValue Value;
7124       if (!Evaluate(Value, Info, E->getSubExpr()))
7125         return false;
7126       return DerivedSuccess(Value, E);
7127     }
7128     }
7129 
7130     return Error(E);
7131   }
7132 
7133   bool VisitUnaryPostInc(const UnaryOperator *UO) {
7134     return VisitUnaryPostIncDec(UO);
7135   }
7136   bool VisitUnaryPostDec(const UnaryOperator *UO) {
7137     return VisitUnaryPostIncDec(UO);
7138   }
7139   bool VisitUnaryPostIncDec(const UnaryOperator *UO) {
7140     if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
7141       return Error(UO);
7142 
7143     LValue LVal;
7144     if (!EvaluateLValue(UO->getSubExpr(), LVal, Info))
7145       return false;
7146     APValue RVal;
7147     if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(),
7148                       UO->isIncrementOp(), &RVal))
7149       return false;
7150     return DerivedSuccess(RVal, UO);
7151   }
7152 
7153   bool VisitStmtExpr(const StmtExpr *E) {
7154     // We will have checked the full-expressions inside the statement expression
7155     // when they were completed, and don't need to check them again now.
7156     if (Info.checkingForUndefinedBehavior())
7157       return Error(E);
7158 
7159     const CompoundStmt *CS = E->getSubStmt();
7160     if (CS->body_empty())
7161       return true;
7162 
7163     BlockScopeRAII Scope(Info);
7164     for (CompoundStmt::const_body_iterator BI = CS->body_begin(),
7165                                            BE = CS->body_end();
7166          /**/; ++BI) {
7167       if (BI + 1 == BE) {
7168         const Expr *FinalExpr = dyn_cast<Expr>(*BI);
7169         if (!FinalExpr) {
7170           Info.FFDiag((*BI)->getBeginLoc(),
7171                       diag::note_constexpr_stmt_expr_unsupported);
7172           return false;
7173         }
7174         return this->Visit(FinalExpr) && Scope.destroy();
7175       }
7176 
7177       APValue ReturnValue;
7178       StmtResult Result = { ReturnValue, nullptr };
7179       EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI);
7180       if (ESR != ESR_Succeeded) {
7181         // FIXME: If the statement-expression terminated due to 'return',
7182         // 'break', or 'continue', it would be nice to propagate that to
7183         // the outer statement evaluation rather than bailing out.
7184         if (ESR != ESR_Failed)
7185           Info.FFDiag((*BI)->getBeginLoc(),
7186                       diag::note_constexpr_stmt_expr_unsupported);
7187         return false;
7188       }
7189     }
7190 
7191     llvm_unreachable("Return from function from the loop above.");
7192   }
7193 
7194   /// Visit a value which is evaluated, but whose value is ignored.
7195   void VisitIgnoredValue(const Expr *E) {
7196     EvaluateIgnoredValue(Info, E);
7197   }
7198 
7199   /// Potentially visit a MemberExpr's base expression.
7200   void VisitIgnoredBaseExpression(const Expr *E) {
7201     // While MSVC doesn't evaluate the base expression, it does diagnose the
7202     // presence of side-effecting behavior.
7203     if (Info.getLangOpts().MSVCCompat && !E->HasSideEffects(Info.Ctx))
7204       return;
7205     VisitIgnoredValue(E);
7206   }
7207 };
7208 
7209 } // namespace
7210 
7211 //===----------------------------------------------------------------------===//
7212 // Common base class for lvalue and temporary evaluation.
7213 //===----------------------------------------------------------------------===//
7214 namespace {
7215 template<class Derived>
7216 class LValueExprEvaluatorBase
7217   : public ExprEvaluatorBase<Derived> {
7218 protected:
7219   LValue &Result;
7220   bool InvalidBaseOK;
7221   typedef LValueExprEvaluatorBase LValueExprEvaluatorBaseTy;
7222   typedef ExprEvaluatorBase<Derived> ExprEvaluatorBaseTy;
7223 
7224   bool Success(APValue::LValueBase B) {
7225     Result.set(B);
7226     return true;
7227   }
7228 
7229   bool evaluatePointer(const Expr *E, LValue &Result) {
7230     return EvaluatePointer(E, Result, this->Info, InvalidBaseOK);
7231   }
7232 
7233 public:
7234   LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result, bool InvalidBaseOK)
7235       : ExprEvaluatorBaseTy(Info), Result(Result),
7236         InvalidBaseOK(InvalidBaseOK) {}
7237 
7238   bool Success(const APValue &V, const Expr *E) {
7239     Result.setFrom(this->Info.Ctx, V);
7240     return true;
7241   }
7242 
7243   bool VisitMemberExpr(const MemberExpr *E) {
7244     // Handle non-static data members.
7245     QualType BaseTy;
7246     bool EvalOK;
7247     if (E->isArrow()) {
7248       EvalOK = evaluatePointer(E->getBase(), Result);
7249       BaseTy = E->getBase()->getType()->castAs<PointerType>()->getPointeeType();
7250     } else if (E->getBase()->isRValue()) {
7251       assert(E->getBase()->getType()->isRecordType());
7252       EvalOK = EvaluateTemporary(E->getBase(), Result, this->Info);
7253       BaseTy = E->getBase()->getType();
7254     } else {
7255       EvalOK = this->Visit(E->getBase());
7256       BaseTy = E->getBase()->getType();
7257     }
7258     if (!EvalOK) {
7259       if (!InvalidBaseOK)
7260         return false;
7261       Result.setInvalid(E);
7262       return true;
7263     }
7264 
7265     const ValueDecl *MD = E->getMemberDecl();
7266     if (const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
7267       assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() ==
7268              FD->getParent()->getCanonicalDecl() && "record / field mismatch");
7269       (void)BaseTy;
7270       if (!HandleLValueMember(this->Info, E, Result, FD))
7271         return false;
7272     } else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(MD)) {
7273       if (!HandleLValueIndirectMember(this->Info, E, Result, IFD))
7274         return false;
7275     } else
7276       return this->Error(E);
7277 
7278     if (MD->getType()->isReferenceType()) {
7279       APValue RefValue;
7280       if (!handleLValueToRValueConversion(this->Info, E, MD->getType(), Result,
7281                                           RefValue))
7282         return false;
7283       return Success(RefValue, E);
7284     }
7285     return true;
7286   }
7287 
7288   bool VisitBinaryOperator(const BinaryOperator *E) {
7289     switch (E->getOpcode()) {
7290     default:
7291       return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
7292 
7293     case BO_PtrMemD:
7294     case BO_PtrMemI:
7295       return HandleMemberPointerAccess(this->Info, E, Result);
7296     }
7297   }
7298 
7299   bool VisitCastExpr(const CastExpr *E) {
7300     switch (E->getCastKind()) {
7301     default:
7302       return ExprEvaluatorBaseTy::VisitCastExpr(E);
7303 
7304     case CK_DerivedToBase:
7305     case CK_UncheckedDerivedToBase:
7306       if (!this->Visit(E->getSubExpr()))
7307         return false;
7308 
7309       // Now figure out the necessary offset to add to the base LV to get from
7310       // the derived class to the base class.
7311       return HandleLValueBasePath(this->Info, E, E->getSubExpr()->getType(),
7312                                   Result);
7313     }
7314   }
7315 };
7316 }
7317 
7318 //===----------------------------------------------------------------------===//
7319 // LValue Evaluation
7320 //
7321 // This is used for evaluating lvalues (in C and C++), xvalues (in C++11),
7322 // function designators (in C), decl references to void objects (in C), and
7323 // temporaries (if building with -Wno-address-of-temporary).
7324 //
7325 // LValue evaluation produces values comprising a base expression of one of the
7326 // following types:
7327 // - Declarations
7328 //  * VarDecl
7329 //  * FunctionDecl
7330 // - Literals
7331 //  * CompoundLiteralExpr in C (and in global scope in C++)
7332 //  * StringLiteral
7333 //  * PredefinedExpr
7334 //  * ObjCStringLiteralExpr
7335 //  * ObjCEncodeExpr
7336 //  * AddrLabelExpr
7337 //  * BlockExpr
7338 //  * CallExpr for a MakeStringConstant builtin
7339 // - typeid(T) expressions, as TypeInfoLValues
7340 // - Locals and temporaries
7341 //  * MaterializeTemporaryExpr
7342 //  * Any Expr, with a CallIndex indicating the function in which the temporary
7343 //    was evaluated, for cases where the MaterializeTemporaryExpr is missing
7344 //    from the AST (FIXME).
7345 //  * A MaterializeTemporaryExpr that has static storage duration, with no
7346 //    CallIndex, for a lifetime-extended temporary.
7347 // plus an offset in bytes.
7348 //===----------------------------------------------------------------------===//
7349 namespace {
7350 class LValueExprEvaluator
7351   : public LValueExprEvaluatorBase<LValueExprEvaluator> {
7352 public:
7353   LValueExprEvaluator(EvalInfo &Info, LValue &Result, bool InvalidBaseOK) :
7354     LValueExprEvaluatorBaseTy(Info, Result, InvalidBaseOK) {}
7355 
7356   bool VisitVarDecl(const Expr *E, const VarDecl *VD);
7357   bool VisitUnaryPreIncDec(const UnaryOperator *UO);
7358 
7359   bool VisitDeclRefExpr(const DeclRefExpr *E);
7360   bool VisitPredefinedExpr(const PredefinedExpr *E) { return Success(E); }
7361   bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
7362   bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
7363   bool VisitMemberExpr(const MemberExpr *E);
7364   bool VisitStringLiteral(const StringLiteral *E) { return Success(E); }
7365   bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { return Success(E); }
7366   bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
7367   bool VisitCXXUuidofExpr(const CXXUuidofExpr *E);
7368   bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
7369   bool VisitUnaryDeref(const UnaryOperator *E);
7370   bool VisitUnaryReal(const UnaryOperator *E);
7371   bool VisitUnaryImag(const UnaryOperator *E);
7372   bool VisitUnaryPreInc(const UnaryOperator *UO) {
7373     return VisitUnaryPreIncDec(UO);
7374   }
7375   bool VisitUnaryPreDec(const UnaryOperator *UO) {
7376     return VisitUnaryPreIncDec(UO);
7377   }
7378   bool VisitBinAssign(const BinaryOperator *BO);
7379   bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO);
7380 
7381   bool VisitCastExpr(const CastExpr *E) {
7382     switch (E->getCastKind()) {
7383     default:
7384       return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
7385 
7386     case CK_LValueBitCast:
7387       this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
7388       if (!Visit(E->getSubExpr()))
7389         return false;
7390       Result.Designator.setInvalid();
7391       return true;
7392 
7393     case CK_BaseToDerived:
7394       if (!Visit(E->getSubExpr()))
7395         return false;
7396       return HandleBaseToDerivedCast(Info, E, Result);
7397 
7398     case CK_Dynamic:
7399       if (!Visit(E->getSubExpr()))
7400         return false;
7401       return HandleDynamicCast(Info, cast<ExplicitCastExpr>(E), Result);
7402     }
7403   }
7404 };
7405 } // end anonymous namespace
7406 
7407 /// Evaluate an expression as an lvalue. This can be legitimately called on
7408 /// expressions which are not glvalues, in three cases:
7409 ///  * function designators in C, and
7410 ///  * "extern void" objects
7411 ///  * @selector() expressions in Objective-C
7412 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
7413                            bool InvalidBaseOK) {
7414   assert(E->isGLValue() || E->getType()->isFunctionType() ||
7415          E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E));
7416   return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
7417 }
7418 
7419 bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) {
7420   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(E->getDecl()))
7421     return Success(FD);
7422   if (const VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
7423     return VisitVarDecl(E, VD);
7424   if (const BindingDecl *BD = dyn_cast<BindingDecl>(E->getDecl()))
7425     return Visit(BD->getBinding());
7426   return Error(E);
7427 }
7428 
7429 
7430 bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
7431 
7432   // If we are within a lambda's call operator, check whether the 'VD' referred
7433   // to within 'E' actually represents a lambda-capture that maps to a
7434   // data-member/field within the closure object, and if so, evaluate to the
7435   // field or what the field refers to.
7436   if (Info.CurrentCall && isLambdaCallOperator(Info.CurrentCall->Callee) &&
7437       isa<DeclRefExpr>(E) &&
7438       cast<DeclRefExpr>(E)->refersToEnclosingVariableOrCapture()) {
7439     // We don't always have a complete capture-map when checking or inferring if
7440     // the function call operator meets the requirements of a constexpr function
7441     // - but we don't need to evaluate the captures to determine constexprness
7442     // (dcl.constexpr C++17).
7443     if (Info.checkingPotentialConstantExpression())
7444       return false;
7445 
7446     if (auto *FD = Info.CurrentCall->LambdaCaptureFields.lookup(VD)) {
7447       // Start with 'Result' referring to the complete closure object...
7448       Result = *Info.CurrentCall->This;
7449       // ... then update it to refer to the field of the closure object
7450       // that represents the capture.
7451       if (!HandleLValueMember(Info, E, Result, FD))
7452         return false;
7453       // And if the field is of reference type, update 'Result' to refer to what
7454       // the field refers to.
7455       if (FD->getType()->isReferenceType()) {
7456         APValue RVal;
7457         if (!handleLValueToRValueConversion(Info, E, FD->getType(), Result,
7458                                             RVal))
7459           return false;
7460         Result.setFrom(Info.Ctx, RVal);
7461       }
7462       return true;
7463     }
7464   }
7465   CallStackFrame *Frame = nullptr;
7466   if (VD->hasLocalStorage() && Info.CurrentCall->Index > 1) {
7467     // Only if a local variable was declared in the function currently being
7468     // evaluated, do we expect to be able to find its value in the current
7469     // frame. (Otherwise it was likely declared in an enclosing context and
7470     // could either have a valid evaluatable value (for e.g. a constexpr
7471     // variable) or be ill-formed (and trigger an appropriate evaluation
7472     // diagnostic)).
7473     if (Info.CurrentCall->Callee &&
7474         Info.CurrentCall->Callee->Equals(VD->getDeclContext())) {
7475       Frame = Info.CurrentCall;
7476     }
7477   }
7478 
7479   if (!VD->getType()->isReferenceType()) {
7480     if (Frame) {
7481       Result.set({VD, Frame->Index,
7482                   Info.CurrentCall->getCurrentTemporaryVersion(VD)});
7483       return true;
7484     }
7485     return Success(VD);
7486   }
7487 
7488   APValue *V;
7489   if (!evaluateVarDeclInit(Info, E, VD, Frame, V, nullptr))
7490     return false;
7491   if (!V->hasValue()) {
7492     // FIXME: Is it possible for V to be indeterminate here? If so, we should
7493     // adjust the diagnostic to say that.
7494     if (!Info.checkingPotentialConstantExpression())
7495       Info.FFDiag(E, diag::note_constexpr_use_uninit_reference);
7496     return false;
7497   }
7498   return Success(*V, E);
7499 }
7500 
7501 bool LValueExprEvaluator::VisitMaterializeTemporaryExpr(
7502     const MaterializeTemporaryExpr *E) {
7503   // Walk through the expression to find the materialized temporary itself.
7504   SmallVector<const Expr *, 2> CommaLHSs;
7505   SmallVector<SubobjectAdjustment, 2> Adjustments;
7506   const Expr *Inner =
7507       E->getSubExpr()->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
7508 
7509   // If we passed any comma operators, evaluate their LHSs.
7510   for (unsigned I = 0, N = CommaLHSs.size(); I != N; ++I)
7511     if (!EvaluateIgnoredValue(Info, CommaLHSs[I]))
7512       return false;
7513 
7514   // A materialized temporary with static storage duration can appear within the
7515   // result of a constant expression evaluation, so we need to preserve its
7516   // value for use outside this evaluation.
7517   APValue *Value;
7518   if (E->getStorageDuration() == SD_Static) {
7519     Value = E->getOrCreateValue(true);
7520     *Value = APValue();
7521     Result.set(E);
7522   } else {
7523     Value = &Info.CurrentCall->createTemporary(
7524         E, E->getType(), E->getStorageDuration() == SD_Automatic, Result);
7525   }
7526 
7527   QualType Type = Inner->getType();
7528 
7529   // Materialize the temporary itself.
7530   if (!EvaluateInPlace(*Value, Info, Result, Inner)) {
7531     *Value = APValue();
7532     return false;
7533   }
7534 
7535   // Adjust our lvalue to refer to the desired subobject.
7536   for (unsigned I = Adjustments.size(); I != 0; /**/) {
7537     --I;
7538     switch (Adjustments[I].Kind) {
7539     case SubobjectAdjustment::DerivedToBaseAdjustment:
7540       if (!HandleLValueBasePath(Info, Adjustments[I].DerivedToBase.BasePath,
7541                                 Type, Result))
7542         return false;
7543       Type = Adjustments[I].DerivedToBase.BasePath->getType();
7544       break;
7545 
7546     case SubobjectAdjustment::FieldAdjustment:
7547       if (!HandleLValueMember(Info, E, Result, Adjustments[I].Field))
7548         return false;
7549       Type = Adjustments[I].Field->getType();
7550       break;
7551 
7552     case SubobjectAdjustment::MemberPointerAdjustment:
7553       if (!HandleMemberPointerAccess(this->Info, Type, Result,
7554                                      Adjustments[I].Ptr.RHS))
7555         return false;
7556       Type = Adjustments[I].Ptr.MPT->getPointeeType();
7557       break;
7558     }
7559   }
7560 
7561   return true;
7562 }
7563 
7564 bool
7565 LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
7566   assert((!Info.getLangOpts().CPlusPlus || E->isFileScope()) &&
7567          "lvalue compound literal in c++?");
7568   // Defer visiting the literal until the lvalue-to-rvalue conversion. We can
7569   // only see this when folding in C, so there's no standard to follow here.
7570   return Success(E);
7571 }
7572 
7573 bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
7574   TypeInfoLValue TypeInfo;
7575 
7576   if (!E->isPotentiallyEvaluated()) {
7577     if (E->isTypeOperand())
7578       TypeInfo = TypeInfoLValue(E->getTypeOperand(Info.Ctx).getTypePtr());
7579     else
7580       TypeInfo = TypeInfoLValue(E->getExprOperand()->getType().getTypePtr());
7581   } else {
7582     if (!Info.Ctx.getLangOpts().CPlusPlus2a) {
7583       Info.CCEDiag(E, diag::note_constexpr_typeid_polymorphic)
7584         << E->getExprOperand()->getType()
7585         << E->getExprOperand()->getSourceRange();
7586     }
7587 
7588     if (!Visit(E->getExprOperand()))
7589       return false;
7590 
7591     Optional<DynamicType> DynType =
7592         ComputeDynamicType(Info, E, Result, AK_TypeId);
7593     if (!DynType)
7594       return false;
7595 
7596     TypeInfo =
7597         TypeInfoLValue(Info.Ctx.getRecordType(DynType->Type).getTypePtr());
7598   }
7599 
7600   return Success(APValue::LValueBase::getTypeInfo(TypeInfo, E->getType()));
7601 }
7602 
7603 bool LValueExprEvaluator::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
7604   return Success(E);
7605 }
7606 
7607 bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
7608   // Handle static data members.
7609   if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) {
7610     VisitIgnoredBaseExpression(E->getBase());
7611     return VisitVarDecl(E, VD);
7612   }
7613 
7614   // Handle static member functions.
7615   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) {
7616     if (MD->isStatic()) {
7617       VisitIgnoredBaseExpression(E->getBase());
7618       return Success(MD);
7619     }
7620   }
7621 
7622   // Handle non-static data members.
7623   return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
7624 }
7625 
7626 bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
7627   // FIXME: Deal with vectors as array subscript bases.
7628   if (E->getBase()->getType()->isVectorType())
7629     return Error(E);
7630 
7631   bool Success = true;
7632   if (!evaluatePointer(E->getBase(), Result)) {
7633     if (!Info.noteFailure())
7634       return false;
7635     Success = false;
7636   }
7637 
7638   APSInt Index;
7639   if (!EvaluateInteger(E->getIdx(), Index, Info))
7640     return false;
7641 
7642   return Success &&
7643          HandleLValueArrayAdjustment(Info, E, Result, E->getType(), Index);
7644 }
7645 
7646 bool LValueExprEvaluator::VisitUnaryDeref(const UnaryOperator *E) {
7647   return evaluatePointer(E->getSubExpr(), Result);
7648 }
7649 
7650 bool LValueExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
7651   if (!Visit(E->getSubExpr()))
7652     return false;
7653   // __real is a no-op on scalar lvalues.
7654   if (E->getSubExpr()->getType()->isAnyComplexType())
7655     HandleLValueComplexElement(Info, E, Result, E->getType(), false);
7656   return true;
7657 }
7658 
7659 bool LValueExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
7660   assert(E->getSubExpr()->getType()->isAnyComplexType() &&
7661          "lvalue __imag__ on scalar?");
7662   if (!Visit(E->getSubExpr()))
7663     return false;
7664   HandleLValueComplexElement(Info, E, Result, E->getType(), true);
7665   return true;
7666 }
7667 
7668 bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) {
7669   if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
7670     return Error(UO);
7671 
7672   if (!this->Visit(UO->getSubExpr()))
7673     return false;
7674 
7675   return handleIncDec(
7676       this->Info, UO, Result, UO->getSubExpr()->getType(),
7677       UO->isIncrementOp(), nullptr);
7678 }
7679 
7680 bool LValueExprEvaluator::VisitCompoundAssignOperator(
7681     const CompoundAssignOperator *CAO) {
7682   if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
7683     return Error(CAO);
7684 
7685   APValue RHS;
7686 
7687   // The overall lvalue result is the result of evaluating the LHS.
7688   if (!this->Visit(CAO->getLHS())) {
7689     if (Info.noteFailure())
7690       Evaluate(RHS, this->Info, CAO->getRHS());
7691     return false;
7692   }
7693 
7694   if (!Evaluate(RHS, this->Info, CAO->getRHS()))
7695     return false;
7696 
7697   return handleCompoundAssignment(
7698       this->Info, CAO,
7699       Result, CAO->getLHS()->getType(), CAO->getComputationLHSType(),
7700       CAO->getOpForCompoundAssignment(CAO->getOpcode()), RHS);
7701 }
7702 
7703 bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) {
7704   if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
7705     return Error(E);
7706 
7707   APValue NewVal;
7708 
7709   if (!this->Visit(E->getLHS())) {
7710     if (Info.noteFailure())
7711       Evaluate(NewVal, this->Info, E->getRHS());
7712     return false;
7713   }
7714 
7715   if (!Evaluate(NewVal, this->Info, E->getRHS()))
7716     return false;
7717 
7718   if (Info.getLangOpts().CPlusPlus2a &&
7719       !HandleUnionActiveMemberChange(Info, E->getLHS(), Result))
7720     return false;
7721 
7722   return handleAssignment(this->Info, E, Result, E->getLHS()->getType(),
7723                           NewVal);
7724 }
7725 
7726 //===----------------------------------------------------------------------===//
7727 // Pointer Evaluation
7728 //===----------------------------------------------------------------------===//
7729 
7730 /// Attempts to compute the number of bytes available at the pointer
7731 /// returned by a function with the alloc_size attribute. Returns true if we
7732 /// were successful. Places an unsigned number into `Result`.
7733 ///
7734 /// This expects the given CallExpr to be a call to a function with an
7735 /// alloc_size attribute.
7736 static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx,
7737                                             const CallExpr *Call,
7738                                             llvm::APInt &Result) {
7739   const AllocSizeAttr *AllocSize = getAllocSizeAttr(Call);
7740 
7741   assert(AllocSize && AllocSize->getElemSizeParam().isValid());
7742   unsigned SizeArgNo = AllocSize->getElemSizeParam().getASTIndex();
7743   unsigned BitsInSizeT = Ctx.getTypeSize(Ctx.getSizeType());
7744   if (Call->getNumArgs() <= SizeArgNo)
7745     return false;
7746 
7747   auto EvaluateAsSizeT = [&](const Expr *E, APSInt &Into) {
7748     Expr::EvalResult ExprResult;
7749     if (!E->EvaluateAsInt(ExprResult, Ctx, Expr::SE_AllowSideEffects))
7750       return false;
7751     Into = ExprResult.Val.getInt();
7752     if (Into.isNegative() || !Into.isIntN(BitsInSizeT))
7753       return false;
7754     Into = Into.zextOrSelf(BitsInSizeT);
7755     return true;
7756   };
7757 
7758   APSInt SizeOfElem;
7759   if (!EvaluateAsSizeT(Call->getArg(SizeArgNo), SizeOfElem))
7760     return false;
7761 
7762   if (!AllocSize->getNumElemsParam().isValid()) {
7763     Result = std::move(SizeOfElem);
7764     return true;
7765   }
7766 
7767   APSInt NumberOfElems;
7768   unsigned NumArgNo = AllocSize->getNumElemsParam().getASTIndex();
7769   if (!EvaluateAsSizeT(Call->getArg(NumArgNo), NumberOfElems))
7770     return false;
7771 
7772   bool Overflow;
7773   llvm::APInt BytesAvailable = SizeOfElem.umul_ov(NumberOfElems, Overflow);
7774   if (Overflow)
7775     return false;
7776 
7777   Result = std::move(BytesAvailable);
7778   return true;
7779 }
7780 
7781 /// Convenience function. LVal's base must be a call to an alloc_size
7782 /// function.
7783 static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx,
7784                                             const LValue &LVal,
7785                                             llvm::APInt &Result) {
7786   assert(isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
7787          "Can't get the size of a non alloc_size function");
7788   const auto *Base = LVal.getLValueBase().get<const Expr *>();
7789   const CallExpr *CE = tryUnwrapAllocSizeCall(Base);
7790   return getBytesReturnedByAllocSizeCall(Ctx, CE, Result);
7791 }
7792 
7793 /// Attempts to evaluate the given LValueBase as the result of a call to
7794 /// a function with the alloc_size attribute. If it was possible to do so, this
7795 /// function will return true, make Result's Base point to said function call,
7796 /// and mark Result's Base as invalid.
7797 static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base,
7798                                       LValue &Result) {
7799   if (Base.isNull())
7800     return false;
7801 
7802   // Because we do no form of static analysis, we only support const variables.
7803   //
7804   // Additionally, we can't support parameters, nor can we support static
7805   // variables (in the latter case, use-before-assign isn't UB; in the former,
7806   // we have no clue what they'll be assigned to).
7807   const auto *VD =
7808       dyn_cast_or_null<VarDecl>(Base.dyn_cast<const ValueDecl *>());
7809   if (!VD || !VD->isLocalVarDecl() || !VD->getType().isConstQualified())
7810     return false;
7811 
7812   const Expr *Init = VD->getAnyInitializer();
7813   if (!Init)
7814     return false;
7815 
7816   const Expr *E = Init->IgnoreParens();
7817   if (!tryUnwrapAllocSizeCall(E))
7818     return false;
7819 
7820   // Store E instead of E unwrapped so that the type of the LValue's base is
7821   // what the user wanted.
7822   Result.setInvalid(E);
7823 
7824   QualType Pointee = E->getType()->castAs<PointerType>()->getPointeeType();
7825   Result.addUnsizedArray(Info, E, Pointee);
7826   return true;
7827 }
7828 
7829 namespace {
7830 class PointerExprEvaluator
7831   : public ExprEvaluatorBase<PointerExprEvaluator> {
7832   LValue &Result;
7833   bool InvalidBaseOK;
7834 
7835   bool Success(const Expr *E) {
7836     Result.set(E);
7837     return true;
7838   }
7839 
7840   bool evaluateLValue(const Expr *E, LValue &Result) {
7841     return EvaluateLValue(E, Result, Info, InvalidBaseOK);
7842   }
7843 
7844   bool evaluatePointer(const Expr *E, LValue &Result) {
7845     return EvaluatePointer(E, Result, Info, InvalidBaseOK);
7846   }
7847 
7848   bool visitNonBuiltinCallExpr(const CallExpr *E);
7849 public:
7850 
7851   PointerExprEvaluator(EvalInfo &info, LValue &Result, bool InvalidBaseOK)
7852       : ExprEvaluatorBaseTy(info), Result(Result),
7853         InvalidBaseOK(InvalidBaseOK) {}
7854 
7855   bool Success(const APValue &V, const Expr *E) {
7856     Result.setFrom(Info.Ctx, V);
7857     return true;
7858   }
7859   bool ZeroInitialization(const Expr *E) {
7860     Result.setNull(Info.Ctx, E->getType());
7861     return true;
7862   }
7863 
7864   bool VisitBinaryOperator(const BinaryOperator *E);
7865   bool VisitCastExpr(const CastExpr* E);
7866   bool VisitUnaryAddrOf(const UnaryOperator *E);
7867   bool VisitObjCStringLiteral(const ObjCStringLiteral *E)
7868       { return Success(E); }
7869   bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
7870     if (E->isExpressibleAsConstantInitializer())
7871       return Success(E);
7872     if (Info.noteFailure())
7873       EvaluateIgnoredValue(Info, E->getSubExpr());
7874     return Error(E);
7875   }
7876   bool VisitAddrLabelExpr(const AddrLabelExpr *E)
7877       { return Success(E); }
7878   bool VisitCallExpr(const CallExpr *E);
7879   bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
7880   bool VisitBlockExpr(const BlockExpr *E) {
7881     if (!E->getBlockDecl()->hasCaptures())
7882       return Success(E);
7883     return Error(E);
7884   }
7885   bool VisitCXXThisExpr(const CXXThisExpr *E) {
7886     // Can't look at 'this' when checking a potential constant expression.
7887     if (Info.checkingPotentialConstantExpression())
7888       return false;
7889     if (!Info.CurrentCall->This) {
7890       if (Info.getLangOpts().CPlusPlus11)
7891         Info.FFDiag(E, diag::note_constexpr_this) << E->isImplicit();
7892       else
7893         Info.FFDiag(E);
7894       return false;
7895     }
7896     Result = *Info.CurrentCall->This;
7897     // If we are inside a lambda's call operator, the 'this' expression refers
7898     // to the enclosing '*this' object (either by value or reference) which is
7899     // either copied into the closure object's field that represents the '*this'
7900     // or refers to '*this'.
7901     if (isLambdaCallOperator(Info.CurrentCall->Callee)) {
7902       // Ensure we actually have captured 'this'. (an error will have
7903       // been previously reported if not).
7904       if (!Info.CurrentCall->LambdaThisCaptureField)
7905         return false;
7906 
7907       // Update 'Result' to refer to the data member/field of the closure object
7908       // that represents the '*this' capture.
7909       if (!HandleLValueMember(Info, E, Result,
7910                              Info.CurrentCall->LambdaThisCaptureField))
7911         return false;
7912       // If we captured '*this' by reference, replace the field with its referent.
7913       if (Info.CurrentCall->LambdaThisCaptureField->getType()
7914               ->isPointerType()) {
7915         APValue RVal;
7916         if (!handleLValueToRValueConversion(Info, E, E->getType(), Result,
7917                                             RVal))
7918           return false;
7919 
7920         Result.setFrom(Info.Ctx, RVal);
7921       }
7922     }
7923     return true;
7924   }
7925 
7926   bool VisitCXXNewExpr(const CXXNewExpr *E);
7927 
7928   bool VisitSourceLocExpr(const SourceLocExpr *E) {
7929     assert(E->isStringType() && "SourceLocExpr isn't a pointer type?");
7930     APValue LValResult = E->EvaluateInContext(
7931         Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr());
7932     Result.setFrom(Info.Ctx, LValResult);
7933     return true;
7934   }
7935 
7936   // FIXME: Missing: @protocol, @selector
7937 };
7938 } // end anonymous namespace
7939 
7940 static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
7941                             bool InvalidBaseOK) {
7942   assert(E->isRValue() && E->getType()->hasPointerRepresentation());
7943   return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
7944 }
7945 
7946 bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
7947   if (E->getOpcode() != BO_Add &&
7948       E->getOpcode() != BO_Sub)
7949     return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
7950 
7951   const Expr *PExp = E->getLHS();
7952   const Expr *IExp = E->getRHS();
7953   if (IExp->getType()->isPointerType())
7954     std::swap(PExp, IExp);
7955 
7956   bool EvalPtrOK = evaluatePointer(PExp, Result);
7957   if (!EvalPtrOK && !Info.noteFailure())
7958     return false;
7959 
7960   llvm::APSInt Offset;
7961   if (!EvaluateInteger(IExp, Offset, Info) || !EvalPtrOK)
7962     return false;
7963 
7964   if (E->getOpcode() == BO_Sub)
7965     negateAsSigned(Offset);
7966 
7967   QualType Pointee = PExp->getType()->castAs<PointerType>()->getPointeeType();
7968   return HandleLValueArrayAdjustment(Info, E, Result, Pointee, Offset);
7969 }
7970 
7971 bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
7972   return evaluateLValue(E->getSubExpr(), Result);
7973 }
7974 
7975 bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
7976   const Expr *SubExpr = E->getSubExpr();
7977 
7978   switch (E->getCastKind()) {
7979   default:
7980     break;
7981   case CK_BitCast:
7982   case CK_CPointerToObjCPointerCast:
7983   case CK_BlockPointerToObjCPointerCast:
7984   case CK_AnyPointerToBlockPointerCast:
7985   case CK_AddressSpaceConversion:
7986     if (!Visit(SubExpr))
7987       return false;
7988     // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are
7989     // permitted in constant expressions in C++11. Bitcasts from cv void* are
7990     // also static_casts, but we disallow them as a resolution to DR1312.
7991     if (!E->getType()->isVoidPointerType()) {
7992       if (!Result.InvalidBase && !Result.Designator.Invalid &&
7993           !Result.IsNullPtr &&
7994           Info.Ctx.hasSameUnqualifiedType(Result.Designator.getType(Info.Ctx),
7995                                           E->getType()->getPointeeType()) &&
7996           Info.getStdAllocatorCaller("allocate")) {
7997         // Inside a call to std::allocator::allocate and friends, we permit
7998         // casting from void* back to cv1 T* for a pointer that points to a
7999         // cv2 T.
8000       } else {
8001         Result.Designator.setInvalid();
8002         if (SubExpr->getType()->isVoidPointerType())
8003           CCEDiag(E, diag::note_constexpr_invalid_cast)
8004             << 3 << SubExpr->getType();
8005         else
8006           CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
8007       }
8008     }
8009     if (E->getCastKind() == CK_AddressSpaceConversion && Result.IsNullPtr)
8010       ZeroInitialization(E);
8011     return true;
8012 
8013   case CK_DerivedToBase:
8014   case CK_UncheckedDerivedToBase:
8015     if (!evaluatePointer(E->getSubExpr(), Result))
8016       return false;
8017     if (!Result.Base && Result.Offset.isZero())
8018       return true;
8019 
8020     // Now figure out the necessary offset to add to the base LV to get from
8021     // the derived class to the base class.
8022     return HandleLValueBasePath(Info, E, E->getSubExpr()->getType()->
8023                                   castAs<PointerType>()->getPointeeType(),
8024                                 Result);
8025 
8026   case CK_BaseToDerived:
8027     if (!Visit(E->getSubExpr()))
8028       return false;
8029     if (!Result.Base && Result.Offset.isZero())
8030       return true;
8031     return HandleBaseToDerivedCast(Info, E, Result);
8032 
8033   case CK_Dynamic:
8034     if (!Visit(E->getSubExpr()))
8035       return false;
8036     return HandleDynamicCast(Info, cast<ExplicitCastExpr>(E), Result);
8037 
8038   case CK_NullToPointer:
8039     VisitIgnoredValue(E->getSubExpr());
8040     return ZeroInitialization(E);
8041 
8042   case CK_IntegralToPointer: {
8043     CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
8044 
8045     APValue Value;
8046     if (!EvaluateIntegerOrLValue(SubExpr, Value, Info))
8047       break;
8048 
8049     if (Value.isInt()) {
8050       unsigned Size = Info.Ctx.getTypeSize(E->getType());
8051       uint64_t N = Value.getInt().extOrTrunc(Size).getZExtValue();
8052       Result.Base = (Expr*)nullptr;
8053       Result.InvalidBase = false;
8054       Result.Offset = CharUnits::fromQuantity(N);
8055       Result.Designator.setInvalid();
8056       Result.IsNullPtr = false;
8057       return true;
8058     } else {
8059       // Cast is of an lvalue, no need to change value.
8060       Result.setFrom(Info.Ctx, Value);
8061       return true;
8062     }
8063   }
8064 
8065   case CK_ArrayToPointerDecay: {
8066     if (SubExpr->isGLValue()) {
8067       if (!evaluateLValue(SubExpr, Result))
8068         return false;
8069     } else {
8070       APValue &Value = Info.CurrentCall->createTemporary(
8071           SubExpr, SubExpr->getType(), false, Result);
8072       if (!EvaluateInPlace(Value, Info, Result, SubExpr))
8073         return false;
8074     }
8075     // The result is a pointer to the first element of the array.
8076     auto *AT = Info.Ctx.getAsArrayType(SubExpr->getType());
8077     if (auto *CAT = dyn_cast<ConstantArrayType>(AT))
8078       Result.addArray(Info, E, CAT);
8079     else
8080       Result.addUnsizedArray(Info, E, AT->getElementType());
8081     return true;
8082   }
8083 
8084   case CK_FunctionToPointerDecay:
8085     return evaluateLValue(SubExpr, Result);
8086 
8087   case CK_LValueToRValue: {
8088     LValue LVal;
8089     if (!evaluateLValue(E->getSubExpr(), LVal))
8090       return false;
8091 
8092     APValue RVal;
8093     // Note, we use the subexpression's type in order to retain cv-qualifiers.
8094     if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
8095                                         LVal, RVal))
8096       return InvalidBaseOK &&
8097              evaluateLValueAsAllocSize(Info, LVal.Base, Result);
8098     return Success(RVal, E);
8099   }
8100   }
8101 
8102   return ExprEvaluatorBaseTy::VisitCastExpr(E);
8103 }
8104 
8105 static CharUnits GetAlignOfType(EvalInfo &Info, QualType T,
8106                                 UnaryExprOrTypeTrait ExprKind) {
8107   // C++ [expr.alignof]p3:
8108   //     When alignof is applied to a reference type, the result is the
8109   //     alignment of the referenced type.
8110   if (const ReferenceType *Ref = T->getAs<ReferenceType>())
8111     T = Ref->getPointeeType();
8112 
8113   if (T.getQualifiers().hasUnaligned())
8114     return CharUnits::One();
8115 
8116   const bool AlignOfReturnsPreferred =
8117       Info.Ctx.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver7;
8118 
8119   // __alignof is defined to return the preferred alignment.
8120   // Before 8, clang returned the preferred alignment for alignof and _Alignof
8121   // as well.
8122   if (ExprKind == UETT_PreferredAlignOf || AlignOfReturnsPreferred)
8123     return Info.Ctx.toCharUnitsFromBits(
8124       Info.Ctx.getPreferredTypeAlign(T.getTypePtr()));
8125   // alignof and _Alignof are defined to return the ABI alignment.
8126   else if (ExprKind == UETT_AlignOf)
8127     return Info.Ctx.getTypeAlignInChars(T.getTypePtr());
8128   else
8129     llvm_unreachable("GetAlignOfType on a non-alignment ExprKind");
8130 }
8131 
8132 static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E,
8133                                 UnaryExprOrTypeTrait ExprKind) {
8134   E = E->IgnoreParens();
8135 
8136   // The kinds of expressions that we have special-case logic here for
8137   // should be kept up to date with the special checks for those
8138   // expressions in Sema.
8139 
8140   // alignof decl is always accepted, even if it doesn't make sense: we default
8141   // to 1 in those cases.
8142   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
8143     return Info.Ctx.getDeclAlign(DRE->getDecl(),
8144                                  /*RefAsPointee*/true);
8145 
8146   if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
8147     return Info.Ctx.getDeclAlign(ME->getMemberDecl(),
8148                                  /*RefAsPointee*/true);
8149 
8150   return GetAlignOfType(Info, E->getType(), ExprKind);
8151 }
8152 
8153 // To be clear: this happily visits unsupported builtins. Better name welcomed.
8154 bool PointerExprEvaluator::visitNonBuiltinCallExpr(const CallExpr *E) {
8155   if (ExprEvaluatorBaseTy::VisitCallExpr(E))
8156     return true;
8157 
8158   if (!(InvalidBaseOK && getAllocSizeAttr(E)))
8159     return false;
8160 
8161   Result.setInvalid(E);
8162   QualType PointeeTy = E->getType()->castAs<PointerType>()->getPointeeType();
8163   Result.addUnsizedArray(Info, E, PointeeTy);
8164   return true;
8165 }
8166 
8167 bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) {
8168   if (IsStringLiteralCall(E))
8169     return Success(E);
8170 
8171   if (unsigned BuiltinOp = E->getBuiltinCallee())
8172     return VisitBuiltinCallExpr(E, BuiltinOp);
8173 
8174   return visitNonBuiltinCallExpr(E);
8175 }
8176 
8177 bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
8178                                                 unsigned BuiltinOp) {
8179   switch (BuiltinOp) {
8180   case Builtin::BI__builtin_addressof:
8181     return evaluateLValue(E->getArg(0), Result);
8182   case Builtin::BI__builtin_assume_aligned: {
8183     // We need to be very careful here because: if the pointer does not have the
8184     // asserted alignment, then the behavior is undefined, and undefined
8185     // behavior is non-constant.
8186     if (!evaluatePointer(E->getArg(0), Result))
8187       return false;
8188 
8189     LValue OffsetResult(Result);
8190     APSInt Alignment;
8191     if (!EvaluateInteger(E->getArg(1), Alignment, Info))
8192       return false;
8193     CharUnits Align = CharUnits::fromQuantity(Alignment.getZExtValue());
8194 
8195     if (E->getNumArgs() > 2) {
8196       APSInt Offset;
8197       if (!EvaluateInteger(E->getArg(2), Offset, Info))
8198         return false;
8199 
8200       int64_t AdditionalOffset = -Offset.getZExtValue();
8201       OffsetResult.Offset += CharUnits::fromQuantity(AdditionalOffset);
8202     }
8203 
8204     // If there is a base object, then it must have the correct alignment.
8205     if (OffsetResult.Base) {
8206       CharUnits BaseAlignment;
8207       if (const ValueDecl *VD =
8208           OffsetResult.Base.dyn_cast<const ValueDecl*>()) {
8209         BaseAlignment = Info.Ctx.getDeclAlign(VD);
8210       } else if (const Expr *E = OffsetResult.Base.dyn_cast<const Expr *>()) {
8211         BaseAlignment = GetAlignOfExpr(Info, E, UETT_AlignOf);
8212       } else {
8213         BaseAlignment = GetAlignOfType(
8214             Info, OffsetResult.Base.getTypeInfoType(), UETT_AlignOf);
8215       }
8216 
8217       if (BaseAlignment < Align) {
8218         Result.Designator.setInvalid();
8219         // FIXME: Add support to Diagnostic for long / long long.
8220         CCEDiag(E->getArg(0),
8221                 diag::note_constexpr_baa_insufficient_alignment) << 0
8222           << (unsigned)BaseAlignment.getQuantity()
8223           << (unsigned)Align.getQuantity();
8224         return false;
8225       }
8226     }
8227 
8228     // The offset must also have the correct alignment.
8229     if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) {
8230       Result.Designator.setInvalid();
8231 
8232       (OffsetResult.Base
8233            ? CCEDiag(E->getArg(0),
8234                      diag::note_constexpr_baa_insufficient_alignment) << 1
8235            : CCEDiag(E->getArg(0),
8236                      diag::note_constexpr_baa_value_insufficient_alignment))
8237         << (int)OffsetResult.Offset.getQuantity()
8238         << (unsigned)Align.getQuantity();
8239       return false;
8240     }
8241 
8242     return true;
8243   }
8244   case Builtin::BI__builtin_operator_new:
8245     return HandleOperatorNewCall(Info, E, Result);
8246   case Builtin::BI__builtin_launder:
8247     return evaluatePointer(E->getArg(0), Result);
8248   case Builtin::BIstrchr:
8249   case Builtin::BIwcschr:
8250   case Builtin::BImemchr:
8251   case Builtin::BIwmemchr:
8252     if (Info.getLangOpts().CPlusPlus11)
8253       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
8254         << /*isConstexpr*/0 << /*isConstructor*/0
8255         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
8256     else
8257       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
8258     LLVM_FALLTHROUGH;
8259   case Builtin::BI__builtin_strchr:
8260   case Builtin::BI__builtin_wcschr:
8261   case Builtin::BI__builtin_memchr:
8262   case Builtin::BI__builtin_char_memchr:
8263   case Builtin::BI__builtin_wmemchr: {
8264     if (!Visit(E->getArg(0)))
8265       return false;
8266     APSInt Desired;
8267     if (!EvaluateInteger(E->getArg(1), Desired, Info))
8268       return false;
8269     uint64_t MaxLength = uint64_t(-1);
8270     if (BuiltinOp != Builtin::BIstrchr &&
8271         BuiltinOp != Builtin::BIwcschr &&
8272         BuiltinOp != Builtin::BI__builtin_strchr &&
8273         BuiltinOp != Builtin::BI__builtin_wcschr) {
8274       APSInt N;
8275       if (!EvaluateInteger(E->getArg(2), N, Info))
8276         return false;
8277       MaxLength = N.getExtValue();
8278     }
8279     // We cannot find the value if there are no candidates to match against.
8280     if (MaxLength == 0u)
8281       return ZeroInitialization(E);
8282     if (!Result.checkNullPointerForFoldAccess(Info, E, AK_Read) ||
8283         Result.Designator.Invalid)
8284       return false;
8285     QualType CharTy = Result.Designator.getType(Info.Ctx);
8286     bool IsRawByte = BuiltinOp == Builtin::BImemchr ||
8287                      BuiltinOp == Builtin::BI__builtin_memchr;
8288     assert(IsRawByte ||
8289            Info.Ctx.hasSameUnqualifiedType(
8290                CharTy, E->getArg(0)->getType()->getPointeeType()));
8291     // Pointers to const void may point to objects of incomplete type.
8292     if (IsRawByte && CharTy->isIncompleteType()) {
8293       Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy;
8294       return false;
8295     }
8296     // Give up on byte-oriented matching against multibyte elements.
8297     // FIXME: We can compare the bytes in the correct order.
8298     if (IsRawByte && Info.Ctx.getTypeSizeInChars(CharTy) != CharUnits::One())
8299       return false;
8300     // Figure out what value we're actually looking for (after converting to
8301     // the corresponding unsigned type if necessary).
8302     uint64_t DesiredVal;
8303     bool StopAtNull = false;
8304     switch (BuiltinOp) {
8305     case Builtin::BIstrchr:
8306     case Builtin::BI__builtin_strchr:
8307       // strchr compares directly to the passed integer, and therefore
8308       // always fails if given an int that is not a char.
8309       if (!APSInt::isSameValue(HandleIntToIntCast(Info, E, CharTy,
8310                                                   E->getArg(1)->getType(),
8311                                                   Desired),
8312                                Desired))
8313         return ZeroInitialization(E);
8314       StopAtNull = true;
8315       LLVM_FALLTHROUGH;
8316     case Builtin::BImemchr:
8317     case Builtin::BI__builtin_memchr:
8318     case Builtin::BI__builtin_char_memchr:
8319       // memchr compares by converting both sides to unsigned char. That's also
8320       // correct for strchr if we get this far (to cope with plain char being
8321       // unsigned in the strchr case).
8322       DesiredVal = Desired.trunc(Info.Ctx.getCharWidth()).getZExtValue();
8323       break;
8324 
8325     case Builtin::BIwcschr:
8326     case Builtin::BI__builtin_wcschr:
8327       StopAtNull = true;
8328       LLVM_FALLTHROUGH;
8329     case Builtin::BIwmemchr:
8330     case Builtin::BI__builtin_wmemchr:
8331       // wcschr and wmemchr are given a wchar_t to look for. Just use it.
8332       DesiredVal = Desired.getZExtValue();
8333       break;
8334     }
8335 
8336     for (; MaxLength; --MaxLength) {
8337       APValue Char;
8338       if (!handleLValueToRValueConversion(Info, E, CharTy, Result, Char) ||
8339           !Char.isInt())
8340         return false;
8341       if (Char.getInt().getZExtValue() == DesiredVal)
8342         return true;
8343       if (StopAtNull && !Char.getInt())
8344         break;
8345       if (!HandleLValueArrayAdjustment(Info, E, Result, CharTy, 1))
8346         return false;
8347     }
8348     // Not found: return nullptr.
8349     return ZeroInitialization(E);
8350   }
8351 
8352   case Builtin::BImemcpy:
8353   case Builtin::BImemmove:
8354   case Builtin::BIwmemcpy:
8355   case Builtin::BIwmemmove:
8356     if (Info.getLangOpts().CPlusPlus11)
8357       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
8358         << /*isConstexpr*/0 << /*isConstructor*/0
8359         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
8360     else
8361       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
8362     LLVM_FALLTHROUGH;
8363   case Builtin::BI__builtin_memcpy:
8364   case Builtin::BI__builtin_memmove:
8365   case Builtin::BI__builtin_wmemcpy:
8366   case Builtin::BI__builtin_wmemmove: {
8367     bool WChar = BuiltinOp == Builtin::BIwmemcpy ||
8368                  BuiltinOp == Builtin::BIwmemmove ||
8369                  BuiltinOp == Builtin::BI__builtin_wmemcpy ||
8370                  BuiltinOp == Builtin::BI__builtin_wmemmove;
8371     bool Move = BuiltinOp == Builtin::BImemmove ||
8372                 BuiltinOp == Builtin::BIwmemmove ||
8373                 BuiltinOp == Builtin::BI__builtin_memmove ||
8374                 BuiltinOp == Builtin::BI__builtin_wmemmove;
8375 
8376     // The result of mem* is the first argument.
8377     if (!Visit(E->getArg(0)))
8378       return false;
8379     LValue Dest = Result;
8380 
8381     LValue Src;
8382     if (!EvaluatePointer(E->getArg(1), Src, Info))
8383       return false;
8384 
8385     APSInt N;
8386     if (!EvaluateInteger(E->getArg(2), N, Info))
8387       return false;
8388     assert(!N.isSigned() && "memcpy and friends take an unsigned size");
8389 
8390     // If the size is zero, we treat this as always being a valid no-op.
8391     // (Even if one of the src and dest pointers is null.)
8392     if (!N)
8393       return true;
8394 
8395     // Otherwise, if either of the operands is null, we can't proceed. Don't
8396     // try to determine the type of the copied objects, because there aren't
8397     // any.
8398     if (!Src.Base || !Dest.Base) {
8399       APValue Val;
8400       (!Src.Base ? Src : Dest).moveInto(Val);
8401       Info.FFDiag(E, diag::note_constexpr_memcpy_null)
8402           << Move << WChar << !!Src.Base
8403           << Val.getAsString(Info.Ctx, E->getArg(0)->getType());
8404       return false;
8405     }
8406     if (Src.Designator.Invalid || Dest.Designator.Invalid)
8407       return false;
8408 
8409     // We require that Src and Dest are both pointers to arrays of
8410     // trivially-copyable type. (For the wide version, the designator will be
8411     // invalid if the designated object is not a wchar_t.)
8412     QualType T = Dest.Designator.getType(Info.Ctx);
8413     QualType SrcT = Src.Designator.getType(Info.Ctx);
8414     if (!Info.Ctx.hasSameUnqualifiedType(T, SrcT)) {
8415       Info.FFDiag(E, diag::note_constexpr_memcpy_type_pun) << Move << SrcT << T;
8416       return false;
8417     }
8418     if (T->isIncompleteType()) {
8419       Info.FFDiag(E, diag::note_constexpr_memcpy_incomplete_type) << Move << T;
8420       return false;
8421     }
8422     if (!T.isTriviallyCopyableType(Info.Ctx)) {
8423       Info.FFDiag(E, diag::note_constexpr_memcpy_nontrivial) << Move << T;
8424       return false;
8425     }
8426 
8427     // Figure out how many T's we're copying.
8428     uint64_t TSize = Info.Ctx.getTypeSizeInChars(T).getQuantity();
8429     if (!WChar) {
8430       uint64_t Remainder;
8431       llvm::APInt OrigN = N;
8432       llvm::APInt::udivrem(OrigN, TSize, N, Remainder);
8433       if (Remainder) {
8434         Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported)
8435             << Move << WChar << 0 << T << OrigN.toString(10, /*Signed*/false)
8436             << (unsigned)TSize;
8437         return false;
8438       }
8439     }
8440 
8441     // Check that the copying will remain within the arrays, just so that we
8442     // can give a more meaningful diagnostic. This implicitly also checks that
8443     // N fits into 64 bits.
8444     uint64_t RemainingSrcSize = Src.Designator.validIndexAdjustments().second;
8445     uint64_t RemainingDestSize = Dest.Designator.validIndexAdjustments().second;
8446     if (N.ugt(RemainingSrcSize) || N.ugt(RemainingDestSize)) {
8447       Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported)
8448           << Move << WChar << (N.ugt(RemainingSrcSize) ? 1 : 2) << T
8449           << N.toString(10, /*Signed*/false);
8450       return false;
8451     }
8452     uint64_t NElems = N.getZExtValue();
8453     uint64_t NBytes = NElems * TSize;
8454 
8455     // Check for overlap.
8456     int Direction = 1;
8457     if (HasSameBase(Src, Dest)) {
8458       uint64_t SrcOffset = Src.getLValueOffset().getQuantity();
8459       uint64_t DestOffset = Dest.getLValueOffset().getQuantity();
8460       if (DestOffset >= SrcOffset && DestOffset - SrcOffset < NBytes) {
8461         // Dest is inside the source region.
8462         if (!Move) {
8463           Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar;
8464           return false;
8465         }
8466         // For memmove and friends, copy backwards.
8467         if (!HandleLValueArrayAdjustment(Info, E, Src, T, NElems - 1) ||
8468             !HandleLValueArrayAdjustment(Info, E, Dest, T, NElems - 1))
8469           return false;
8470         Direction = -1;
8471       } else if (!Move && SrcOffset >= DestOffset &&
8472                  SrcOffset - DestOffset < NBytes) {
8473         // Src is inside the destination region for memcpy: invalid.
8474         Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar;
8475         return false;
8476       }
8477     }
8478 
8479     while (true) {
8480       APValue Val;
8481       // FIXME: Set WantObjectRepresentation to true if we're copying a
8482       // char-like type?
8483       if (!handleLValueToRValueConversion(Info, E, T, Src, Val) ||
8484           !handleAssignment(Info, E, Dest, T, Val))
8485         return false;
8486       // Do not iterate past the last element; if we're copying backwards, that
8487       // might take us off the start of the array.
8488       if (--NElems == 0)
8489         return true;
8490       if (!HandleLValueArrayAdjustment(Info, E, Src, T, Direction) ||
8491           !HandleLValueArrayAdjustment(Info, E, Dest, T, Direction))
8492         return false;
8493     }
8494   }
8495 
8496   default:
8497     break;
8498   }
8499 
8500   return visitNonBuiltinCallExpr(E);
8501 }
8502 
8503 static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This,
8504                                      APValue &Result, const InitListExpr *ILE,
8505                                      QualType AllocType);
8506 
8507 bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {
8508   if (!Info.getLangOpts().CPlusPlus2a)
8509     Info.CCEDiag(E, diag::note_constexpr_new);
8510 
8511   // We cannot speculatively evaluate a delete expression.
8512   if (Info.SpeculativeEvaluationDepth)
8513     return false;
8514 
8515   FunctionDecl *OperatorNew = E->getOperatorNew();
8516 
8517   bool IsNothrow = false;
8518   bool IsPlacement = false;
8519   if (OperatorNew->isReservedGlobalPlacementOperator() &&
8520       Info.CurrentCall->isStdFunction() && !E->isArray()) {
8521     // FIXME Support array placement new.
8522     assert(E->getNumPlacementArgs() == 1);
8523     if (!EvaluatePointer(E->getPlacementArg(0), Result, Info))
8524       return false;
8525     if (Result.Designator.Invalid)
8526       return false;
8527     IsPlacement = true;
8528   } else if (!OperatorNew->isReplaceableGlobalAllocationFunction()) {
8529     Info.FFDiag(E, diag::note_constexpr_new_non_replaceable)
8530         << isa<CXXMethodDecl>(OperatorNew) << OperatorNew;
8531     return false;
8532   } else if (E->getNumPlacementArgs()) {
8533     // The only new-placement list we support is of the form (std::nothrow).
8534     //
8535     // FIXME: There is no restriction on this, but it's not clear that any
8536     // other form makes any sense. We get here for cases such as:
8537     //
8538     //   new (std::align_val_t{N}) X(int)
8539     //
8540     // (which should presumably be valid only if N is a multiple of
8541     // alignof(int), and in any case can't be deallocated unless N is
8542     // alignof(X) and X has new-extended alignment).
8543     if (E->getNumPlacementArgs() != 1 ||
8544         !E->getPlacementArg(0)->getType()->isNothrowT())
8545       return Error(E, diag::note_constexpr_new_placement);
8546 
8547     LValue Nothrow;
8548     if (!EvaluateLValue(E->getPlacementArg(0), Nothrow, Info))
8549       return false;
8550     IsNothrow = true;
8551   }
8552 
8553   const Expr *Init = E->getInitializer();
8554   const InitListExpr *ResizedArrayILE = nullptr;
8555 
8556   QualType AllocType = E->getAllocatedType();
8557   if (Optional<const Expr*> ArraySize = E->getArraySize()) {
8558     const Expr *Stripped = *ArraySize;
8559     for (; auto *ICE = dyn_cast<ImplicitCastExpr>(Stripped);
8560          Stripped = ICE->getSubExpr())
8561       if (ICE->getCastKind() != CK_NoOp &&
8562           ICE->getCastKind() != CK_IntegralCast)
8563         break;
8564 
8565     llvm::APSInt ArrayBound;
8566     if (!EvaluateInteger(Stripped, ArrayBound, Info))
8567       return false;
8568 
8569     // C++ [expr.new]p9:
8570     //   The expression is erroneous if:
8571     //   -- [...] its value before converting to size_t [or] applying the
8572     //      second standard conversion sequence is less than zero
8573     if (ArrayBound.isSigned() && ArrayBound.isNegative()) {
8574       if (IsNothrow)
8575         return ZeroInitialization(E);
8576 
8577       Info.FFDiag(*ArraySize, diag::note_constexpr_new_negative)
8578           << ArrayBound << (*ArraySize)->getSourceRange();
8579       return false;
8580     }
8581 
8582     //   -- its value is such that the size of the allocated object would
8583     //      exceed the implementation-defined limit
8584     if (ConstantArrayType::getNumAddressingBits(Info.Ctx, AllocType,
8585                                                 ArrayBound) >
8586         ConstantArrayType::getMaxSizeBits(Info.Ctx)) {
8587       if (IsNothrow)
8588         return ZeroInitialization(E);
8589 
8590       Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_large)
8591         << ArrayBound << (*ArraySize)->getSourceRange();
8592       return false;
8593     }
8594 
8595     //   -- the new-initializer is a braced-init-list and the number of
8596     //      array elements for which initializers are provided [...]
8597     //      exceeds the number of elements to initialize
8598     if (Init) {
8599       auto *CAT = Info.Ctx.getAsConstantArrayType(Init->getType());
8600       assert(CAT && "unexpected type for array initializer");
8601 
8602       unsigned Bits =
8603           std::max(CAT->getSize().getBitWidth(), ArrayBound.getBitWidth());
8604       llvm::APInt InitBound = CAT->getSize().zextOrSelf(Bits);
8605       llvm::APInt AllocBound = ArrayBound.zextOrSelf(Bits);
8606       if (InitBound.ugt(AllocBound)) {
8607         if (IsNothrow)
8608           return ZeroInitialization(E);
8609 
8610         Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_small)
8611             << AllocBound.toString(10, /*Signed=*/false)
8612             << InitBound.toString(10, /*Signed=*/false)
8613             << (*ArraySize)->getSourceRange();
8614         return false;
8615       }
8616 
8617       // If the sizes differ, we must have an initializer list, and we need
8618       // special handling for this case when we initialize.
8619       if (InitBound != AllocBound)
8620         ResizedArrayILE = cast<InitListExpr>(Init);
8621     }
8622 
8623     AllocType = Info.Ctx.getConstantArrayType(AllocType, ArrayBound, nullptr,
8624                                               ArrayType::Normal, 0);
8625   } else {
8626     assert(!AllocType->isArrayType() &&
8627            "array allocation with non-array new");
8628   }
8629 
8630   APValue *Val;
8631   if (IsPlacement) {
8632     AccessKinds AK = AK_Construct;
8633     struct FindObjectHandler {
8634       EvalInfo &Info;
8635       const Expr *E;
8636       QualType AllocType;
8637       const AccessKinds AccessKind;
8638       APValue *Value;
8639 
8640       typedef bool result_type;
8641       bool failed() { return false; }
8642       bool found(APValue &Subobj, QualType SubobjType) {
8643         // FIXME: Reject the cases where [basic.life]p8 would not permit the
8644         // old name of the object to be used to name the new object.
8645         if (!Info.Ctx.hasSameUnqualifiedType(SubobjType, AllocType)) {
8646           Info.FFDiag(E, diag::note_constexpr_placement_new_wrong_type) <<
8647             SubobjType << AllocType;
8648           return false;
8649         }
8650         Value = &Subobj;
8651         return true;
8652       }
8653       bool found(APSInt &Value, QualType SubobjType) {
8654         Info.FFDiag(E, diag::note_constexpr_construct_complex_elem);
8655         return false;
8656       }
8657       bool found(APFloat &Value, QualType SubobjType) {
8658         Info.FFDiag(E, diag::note_constexpr_construct_complex_elem);
8659         return false;
8660       }
8661     } Handler = {Info, E, AllocType, AK, nullptr};
8662 
8663     CompleteObject Obj = findCompleteObject(Info, E, AK, Result, AllocType);
8664     if (!Obj || !findSubobject(Info, E, Obj, Result.Designator, Handler))
8665       return false;
8666 
8667     Val = Handler.Value;
8668 
8669     // [basic.life]p1:
8670     //   The lifetime of an object o of type T ends when [...] the storage
8671     //   which the object occupies is [...] reused by an object that is not
8672     //   nested within o (6.6.2).
8673     *Val = APValue();
8674   } else {
8675     // Perform the allocation and obtain a pointer to the resulting object.
8676     Val = Info.createHeapAlloc(E, AllocType, Result);
8677     if (!Val)
8678       return false;
8679   }
8680 
8681   if (ResizedArrayILE) {
8682     if (!EvaluateArrayNewInitList(Info, Result, *Val, ResizedArrayILE,
8683                                   AllocType))
8684       return false;
8685   } else if (Init) {
8686     if (!EvaluateInPlace(*Val, Info, Result, Init))
8687       return false;
8688   } else {
8689     *Val = getDefaultInitValue(AllocType);
8690   }
8691 
8692   // Array new returns a pointer to the first element, not a pointer to the
8693   // array.
8694   if (auto *AT = AllocType->getAsArrayTypeUnsafe())
8695     Result.addArray(Info, E, cast<ConstantArrayType>(AT));
8696 
8697   return true;
8698 }
8699 //===----------------------------------------------------------------------===//
8700 // Member Pointer Evaluation
8701 //===----------------------------------------------------------------------===//
8702 
8703 namespace {
8704 class MemberPointerExprEvaluator
8705   : public ExprEvaluatorBase<MemberPointerExprEvaluator> {
8706   MemberPtr &Result;
8707 
8708   bool Success(const ValueDecl *D) {
8709     Result = MemberPtr(D);
8710     return true;
8711   }
8712 public:
8713 
8714   MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result)
8715     : ExprEvaluatorBaseTy(Info), Result(Result) {}
8716 
8717   bool Success(const APValue &V, const Expr *E) {
8718     Result.setFrom(V);
8719     return true;
8720   }
8721   bool ZeroInitialization(const Expr *E) {
8722     return Success((const ValueDecl*)nullptr);
8723   }
8724 
8725   bool VisitCastExpr(const CastExpr *E);
8726   bool VisitUnaryAddrOf(const UnaryOperator *E);
8727 };
8728 } // end anonymous namespace
8729 
8730 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
8731                                   EvalInfo &Info) {
8732   assert(E->isRValue() && E->getType()->isMemberPointerType());
8733   return MemberPointerExprEvaluator(Info, Result).Visit(E);
8734 }
8735 
8736 bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
8737   switch (E->getCastKind()) {
8738   default:
8739     return ExprEvaluatorBaseTy::VisitCastExpr(E);
8740 
8741   case CK_NullToMemberPointer:
8742     VisitIgnoredValue(E->getSubExpr());
8743     return ZeroInitialization(E);
8744 
8745   case CK_BaseToDerivedMemberPointer: {
8746     if (!Visit(E->getSubExpr()))
8747       return false;
8748     if (E->path_empty())
8749       return true;
8750     // Base-to-derived member pointer casts store the path in derived-to-base
8751     // order, so iterate backwards. The CXXBaseSpecifier also provides us with
8752     // the wrong end of the derived->base arc, so stagger the path by one class.
8753     typedef std::reverse_iterator<CastExpr::path_const_iterator> ReverseIter;
8754     for (ReverseIter PathI(E->path_end() - 1), PathE(E->path_begin());
8755          PathI != PathE; ++PathI) {
8756       assert(!(*PathI)->isVirtual() && "memptr cast through vbase");
8757       const CXXRecordDecl *Derived = (*PathI)->getType()->getAsCXXRecordDecl();
8758       if (!Result.castToDerived(Derived))
8759         return Error(E);
8760     }
8761     const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass();
8762     if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl()))
8763       return Error(E);
8764     return true;
8765   }
8766 
8767   case CK_DerivedToBaseMemberPointer:
8768     if (!Visit(E->getSubExpr()))
8769       return false;
8770     for (CastExpr::path_const_iterator PathI = E->path_begin(),
8771          PathE = E->path_end(); PathI != PathE; ++PathI) {
8772       assert(!(*PathI)->isVirtual() && "memptr cast through vbase");
8773       const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
8774       if (!Result.castToBase(Base))
8775         return Error(E);
8776     }
8777     return true;
8778   }
8779 }
8780 
8781 bool MemberPointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
8782   // C++11 [expr.unary.op]p3 has very strict rules on how the address of a
8783   // member can be formed.
8784   return Success(cast<DeclRefExpr>(E->getSubExpr())->getDecl());
8785 }
8786 
8787 //===----------------------------------------------------------------------===//
8788 // Record Evaluation
8789 //===----------------------------------------------------------------------===//
8790 
8791 namespace {
8792   class RecordExprEvaluator
8793   : public ExprEvaluatorBase<RecordExprEvaluator> {
8794     const LValue &This;
8795     APValue &Result;
8796   public:
8797 
8798     RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result)
8799       : ExprEvaluatorBaseTy(info), This(This), Result(Result) {}
8800 
8801     bool Success(const APValue &V, const Expr *E) {
8802       Result = V;
8803       return true;
8804     }
8805     bool ZeroInitialization(const Expr *E) {
8806       return ZeroInitialization(E, E->getType());
8807     }
8808     bool ZeroInitialization(const Expr *E, QualType T);
8809 
8810     bool VisitCallExpr(const CallExpr *E) {
8811       return handleCallExpr(E, Result, &This);
8812     }
8813     bool VisitCastExpr(const CastExpr *E);
8814     bool VisitInitListExpr(const InitListExpr *E);
8815     bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
8816       return VisitCXXConstructExpr(E, E->getType());
8817     }
8818     bool VisitLambdaExpr(const LambdaExpr *E);
8819     bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
8820     bool VisitCXXConstructExpr(const CXXConstructExpr *E, QualType T);
8821     bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E);
8822     bool VisitBinCmp(const BinaryOperator *E);
8823   };
8824 }
8825 
8826 /// Perform zero-initialization on an object of non-union class type.
8827 /// C++11 [dcl.init]p5:
8828 ///  To zero-initialize an object or reference of type T means:
8829 ///    [...]
8830 ///    -- if T is a (possibly cv-qualified) non-union class type,
8831 ///       each non-static data member and each base-class subobject is
8832 ///       zero-initialized
8833 static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E,
8834                                           const RecordDecl *RD,
8835                                           const LValue &This, APValue &Result) {
8836   assert(!RD->isUnion() && "Expected non-union class type");
8837   const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
8838   Result = APValue(APValue::UninitStruct(), CD ? CD->getNumBases() : 0,
8839                    std::distance(RD->field_begin(), RD->field_end()));
8840 
8841   if (RD->isInvalidDecl()) return false;
8842   const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
8843 
8844   if (CD) {
8845     unsigned Index = 0;
8846     for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(),
8847            End = CD->bases_end(); I != End; ++I, ++Index) {
8848       const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl();
8849       LValue Subobject = This;
8850       if (!HandleLValueDirectBase(Info, E, Subobject, CD, Base, &Layout))
8851         return false;
8852       if (!HandleClassZeroInitialization(Info, E, Base, Subobject,
8853                                          Result.getStructBase(Index)))
8854         return false;
8855     }
8856   }
8857 
8858   for (const auto *I : RD->fields()) {
8859     // -- if T is a reference type, no initialization is performed.
8860     if (I->getType()->isReferenceType())
8861       continue;
8862 
8863     LValue Subobject = This;
8864     if (!HandleLValueMember(Info, E, Subobject, I, &Layout))
8865       return false;
8866 
8867     ImplicitValueInitExpr VIE(I->getType());
8868     if (!EvaluateInPlace(
8869           Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE))
8870       return false;
8871   }
8872 
8873   return true;
8874 }
8875 
8876 bool RecordExprEvaluator::ZeroInitialization(const Expr *E, QualType T) {
8877   const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
8878   if (RD->isInvalidDecl()) return false;
8879   if (RD->isUnion()) {
8880     // C++11 [dcl.init]p5: If T is a (possibly cv-qualified) union type, the
8881     // object's first non-static named data member is zero-initialized
8882     RecordDecl::field_iterator I = RD->field_begin();
8883     if (I == RD->field_end()) {
8884       Result = APValue((const FieldDecl*)nullptr);
8885       return true;
8886     }
8887 
8888     LValue Subobject = This;
8889     if (!HandleLValueMember(Info, E, Subobject, *I))
8890       return false;
8891     Result = APValue(*I);
8892     ImplicitValueInitExpr VIE(I->getType());
8893     return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE);
8894   }
8895 
8896   if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->getNumVBases()) {
8897     Info.FFDiag(E, diag::note_constexpr_virtual_base) << RD;
8898     return false;
8899   }
8900 
8901   return HandleClassZeroInitialization(Info, E, RD, This, Result);
8902 }
8903 
8904 bool RecordExprEvaluator::VisitCastExpr(const CastExpr *E) {
8905   switch (E->getCastKind()) {
8906   default:
8907     return ExprEvaluatorBaseTy::VisitCastExpr(E);
8908 
8909   case CK_ConstructorConversion:
8910     return Visit(E->getSubExpr());
8911 
8912   case CK_DerivedToBase:
8913   case CK_UncheckedDerivedToBase: {
8914     APValue DerivedObject;
8915     if (!Evaluate(DerivedObject, Info, E->getSubExpr()))
8916       return false;
8917     if (!DerivedObject.isStruct())
8918       return Error(E->getSubExpr());
8919 
8920     // Derived-to-base rvalue conversion: just slice off the derived part.
8921     APValue *Value = &DerivedObject;
8922     const CXXRecordDecl *RD = E->getSubExpr()->getType()->getAsCXXRecordDecl();
8923     for (CastExpr::path_const_iterator PathI = E->path_begin(),
8924          PathE = E->path_end(); PathI != PathE; ++PathI) {
8925       assert(!(*PathI)->isVirtual() && "record rvalue with virtual base");
8926       const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
8927       Value = &Value->getStructBase(getBaseIndex(RD, Base));
8928       RD = Base;
8929     }
8930     Result = *Value;
8931     return true;
8932   }
8933   }
8934 }
8935 
8936 bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
8937   if (E->isTransparent())
8938     return Visit(E->getInit(0));
8939 
8940   const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl();
8941   if (RD->isInvalidDecl()) return false;
8942   const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
8943   auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
8944 
8945   EvalInfo::EvaluatingConstructorRAII EvalObj(
8946       Info,
8947       ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries},
8948       CXXRD && CXXRD->getNumBases());
8949 
8950   if (RD->isUnion()) {
8951     const FieldDecl *Field = E->getInitializedFieldInUnion();
8952     Result = APValue(Field);
8953     if (!Field)
8954       return true;
8955 
8956     // If the initializer list for a union does not contain any elements, the
8957     // first element of the union is value-initialized.
8958     // FIXME: The element should be initialized from an initializer list.
8959     //        Is this difference ever observable for initializer lists which
8960     //        we don't build?
8961     ImplicitValueInitExpr VIE(Field->getType());
8962     const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE;
8963 
8964     LValue Subobject = This;
8965     if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout))
8966       return false;
8967 
8968     // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
8969     ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
8970                                   isa<CXXDefaultInitExpr>(InitExpr));
8971 
8972     return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr);
8973   }
8974 
8975   if (!Result.hasValue())
8976     Result = APValue(APValue::UninitStruct(), CXXRD ? CXXRD->getNumBases() : 0,
8977                      std::distance(RD->field_begin(), RD->field_end()));
8978   unsigned ElementNo = 0;
8979   bool Success = true;
8980 
8981   // Initialize base classes.
8982   if (CXXRD && CXXRD->getNumBases()) {
8983     for (const auto &Base : CXXRD->bases()) {
8984       assert(ElementNo < E->getNumInits() && "missing init for base class");
8985       const Expr *Init = E->getInit(ElementNo);
8986 
8987       LValue Subobject = This;
8988       if (!HandleLValueBase(Info, Init, Subobject, CXXRD, &Base))
8989         return false;
8990 
8991       APValue &FieldVal = Result.getStructBase(ElementNo);
8992       if (!EvaluateInPlace(FieldVal, Info, Subobject, Init)) {
8993         if (!Info.noteFailure())
8994           return false;
8995         Success = false;
8996       }
8997       ++ElementNo;
8998     }
8999 
9000     EvalObj.finishedConstructingBases();
9001   }
9002 
9003   // Initialize members.
9004   for (const auto *Field : RD->fields()) {
9005     // Anonymous bit-fields are not considered members of the class for
9006     // purposes of aggregate initialization.
9007     if (Field->isUnnamedBitfield())
9008       continue;
9009 
9010     LValue Subobject = This;
9011 
9012     bool HaveInit = ElementNo < E->getNumInits();
9013 
9014     // FIXME: Diagnostics here should point to the end of the initializer
9015     // list, not the start.
9016     if (!HandleLValueMember(Info, HaveInit ? E->getInit(ElementNo) : E,
9017                             Subobject, Field, &Layout))
9018       return false;
9019 
9020     // Perform an implicit value-initialization for members beyond the end of
9021     // the initializer list.
9022     ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType());
9023     const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE;
9024 
9025     // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
9026     ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
9027                                   isa<CXXDefaultInitExpr>(Init));
9028 
9029     APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
9030     if (!EvaluateInPlace(FieldVal, Info, Subobject, Init) ||
9031         (Field->isBitField() && !truncateBitfieldValue(Info, Init,
9032                                                        FieldVal, Field))) {
9033       if (!Info.noteFailure())
9034         return false;
9035       Success = false;
9036     }
9037   }
9038 
9039   return Success;
9040 }
9041 
9042 bool RecordExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
9043                                                 QualType T) {
9044   // Note that E's type is not necessarily the type of our class here; we might
9045   // be initializing an array element instead.
9046   const CXXConstructorDecl *FD = E->getConstructor();
9047   if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl()) return false;
9048 
9049   bool ZeroInit = E->requiresZeroInitialization();
9050   if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) {
9051     // If we've already performed zero-initialization, we're already done.
9052     if (Result.hasValue())
9053       return true;
9054 
9055     if (ZeroInit)
9056       return ZeroInitialization(E, T);
9057 
9058     Result = getDefaultInitValue(T);
9059     return true;
9060   }
9061 
9062   const FunctionDecl *Definition = nullptr;
9063   auto Body = FD->getBody(Definition);
9064 
9065   if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
9066     return false;
9067 
9068   // Avoid materializing a temporary for an elidable copy/move constructor.
9069   if (E->isElidable() && !ZeroInit)
9070     if (const MaterializeTemporaryExpr *ME
9071           = dyn_cast<MaterializeTemporaryExpr>(E->getArg(0)))
9072       return Visit(ME->getSubExpr());
9073 
9074   if (ZeroInit && !ZeroInitialization(E, T))
9075     return false;
9076 
9077   auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
9078   return HandleConstructorCall(E, This, Args,
9079                                cast<CXXConstructorDecl>(Definition), Info,
9080                                Result);
9081 }
9082 
9083 bool RecordExprEvaluator::VisitCXXInheritedCtorInitExpr(
9084     const CXXInheritedCtorInitExpr *E) {
9085   if (!Info.CurrentCall) {
9086     assert(Info.checkingPotentialConstantExpression());
9087     return false;
9088   }
9089 
9090   const CXXConstructorDecl *FD = E->getConstructor();
9091   if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl())
9092     return false;
9093 
9094   const FunctionDecl *Definition = nullptr;
9095   auto Body = FD->getBody(Definition);
9096 
9097   if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
9098     return false;
9099 
9100   return HandleConstructorCall(E, This, Info.CurrentCall->Arguments,
9101                                cast<CXXConstructorDecl>(Definition), Info,
9102                                Result);
9103 }
9104 
9105 bool RecordExprEvaluator::VisitCXXStdInitializerListExpr(
9106     const CXXStdInitializerListExpr *E) {
9107   const ConstantArrayType *ArrayType =
9108       Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
9109 
9110   LValue Array;
9111   if (!EvaluateLValue(E->getSubExpr(), Array, Info))
9112     return false;
9113 
9114   // Get a pointer to the first element of the array.
9115   Array.addArray(Info, E, ArrayType);
9116 
9117   // FIXME: Perform the checks on the field types in SemaInit.
9118   RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
9119   RecordDecl::field_iterator Field = Record->field_begin();
9120   if (Field == Record->field_end())
9121     return Error(E);
9122 
9123   // Start pointer.
9124   if (!Field->getType()->isPointerType() ||
9125       !Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
9126                             ArrayType->getElementType()))
9127     return Error(E);
9128 
9129   // FIXME: What if the initializer_list type has base classes, etc?
9130   Result = APValue(APValue::UninitStruct(), 0, 2);
9131   Array.moveInto(Result.getStructField(0));
9132 
9133   if (++Field == Record->field_end())
9134     return Error(E);
9135 
9136   if (Field->getType()->isPointerType() &&
9137       Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
9138                            ArrayType->getElementType())) {
9139     // End pointer.
9140     if (!HandleLValueArrayAdjustment(Info, E, Array,
9141                                      ArrayType->getElementType(),
9142                                      ArrayType->getSize().getZExtValue()))
9143       return false;
9144     Array.moveInto(Result.getStructField(1));
9145   } else if (Info.Ctx.hasSameType(Field->getType(), Info.Ctx.getSizeType()))
9146     // Length.
9147     Result.getStructField(1) = APValue(APSInt(ArrayType->getSize()));
9148   else
9149     return Error(E);
9150 
9151   if (++Field != Record->field_end())
9152     return Error(E);
9153 
9154   return true;
9155 }
9156 
9157 bool RecordExprEvaluator::VisitLambdaExpr(const LambdaExpr *E) {
9158   const CXXRecordDecl *ClosureClass = E->getLambdaClass();
9159   if (ClosureClass->isInvalidDecl())
9160     return false;
9161 
9162   const size_t NumFields =
9163       std::distance(ClosureClass->field_begin(), ClosureClass->field_end());
9164 
9165   assert(NumFields == (size_t)std::distance(E->capture_init_begin(),
9166                                             E->capture_init_end()) &&
9167          "The number of lambda capture initializers should equal the number of "
9168          "fields within the closure type");
9169 
9170   Result = APValue(APValue::UninitStruct(), /*NumBases*/0, NumFields);
9171   // Iterate through all the lambda's closure object's fields and initialize
9172   // them.
9173   auto *CaptureInitIt = E->capture_init_begin();
9174   const LambdaCapture *CaptureIt = ClosureClass->captures_begin();
9175   bool Success = true;
9176   for (const auto *Field : ClosureClass->fields()) {
9177     assert(CaptureInitIt != E->capture_init_end());
9178     // Get the initializer for this field
9179     Expr *const CurFieldInit = *CaptureInitIt++;
9180 
9181     // If there is no initializer, either this is a VLA or an error has
9182     // occurred.
9183     if (!CurFieldInit)
9184       return Error(E);
9185 
9186     APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
9187     if (!EvaluateInPlace(FieldVal, Info, This, CurFieldInit)) {
9188       if (!Info.keepEvaluatingAfterFailure())
9189         return false;
9190       Success = false;
9191     }
9192     ++CaptureIt;
9193   }
9194   return Success;
9195 }
9196 
9197 static bool EvaluateRecord(const Expr *E, const LValue &This,
9198                            APValue &Result, EvalInfo &Info) {
9199   assert(E->isRValue() && E->getType()->isRecordType() &&
9200          "can't evaluate expression as a record rvalue");
9201   return RecordExprEvaluator(Info, This, Result).Visit(E);
9202 }
9203 
9204 //===----------------------------------------------------------------------===//
9205 // Temporary Evaluation
9206 //
9207 // Temporaries are represented in the AST as rvalues, but generally behave like
9208 // lvalues. The full-object of which the temporary is a subobject is implicitly
9209 // materialized so that a reference can bind to it.
9210 //===----------------------------------------------------------------------===//
9211 namespace {
9212 class TemporaryExprEvaluator
9213   : public LValueExprEvaluatorBase<TemporaryExprEvaluator> {
9214 public:
9215   TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) :
9216     LValueExprEvaluatorBaseTy(Info, Result, false) {}
9217 
9218   /// Visit an expression which constructs the value of this temporary.
9219   bool VisitConstructExpr(const Expr *E) {
9220     APValue &Value =
9221         Info.CurrentCall->createTemporary(E, E->getType(), false, Result);
9222     return EvaluateInPlace(Value, Info, Result, E);
9223   }
9224 
9225   bool VisitCastExpr(const CastExpr *E) {
9226     switch (E->getCastKind()) {
9227     default:
9228       return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
9229 
9230     case CK_ConstructorConversion:
9231       return VisitConstructExpr(E->getSubExpr());
9232     }
9233   }
9234   bool VisitInitListExpr(const InitListExpr *E) {
9235     return VisitConstructExpr(E);
9236   }
9237   bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
9238     return VisitConstructExpr(E);
9239   }
9240   bool VisitCallExpr(const CallExpr *E) {
9241     return VisitConstructExpr(E);
9242   }
9243   bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E) {
9244     return VisitConstructExpr(E);
9245   }
9246   bool VisitLambdaExpr(const LambdaExpr *E) {
9247     return VisitConstructExpr(E);
9248   }
9249 };
9250 } // end anonymous namespace
9251 
9252 /// Evaluate an expression of record type as a temporary.
9253 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
9254   assert(E->isRValue() && E->getType()->isRecordType());
9255   return TemporaryExprEvaluator(Info, Result).Visit(E);
9256 }
9257 
9258 //===----------------------------------------------------------------------===//
9259 // Vector Evaluation
9260 //===----------------------------------------------------------------------===//
9261 
9262 namespace {
9263   class VectorExprEvaluator
9264   : public ExprEvaluatorBase<VectorExprEvaluator> {
9265     APValue &Result;
9266   public:
9267 
9268     VectorExprEvaluator(EvalInfo &info, APValue &Result)
9269       : ExprEvaluatorBaseTy(info), Result(Result) {}
9270 
9271     bool Success(ArrayRef<APValue> V, const Expr *E) {
9272       assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements());
9273       // FIXME: remove this APValue copy.
9274       Result = APValue(V.data(), V.size());
9275       return true;
9276     }
9277     bool Success(const APValue &V, const Expr *E) {
9278       assert(V.isVector());
9279       Result = V;
9280       return true;
9281     }
9282     bool ZeroInitialization(const Expr *E);
9283 
9284     bool VisitUnaryReal(const UnaryOperator *E)
9285       { return Visit(E->getSubExpr()); }
9286     bool VisitCastExpr(const CastExpr* E);
9287     bool VisitInitListExpr(const InitListExpr *E);
9288     bool VisitUnaryImag(const UnaryOperator *E);
9289     // FIXME: Missing: unary -, unary ~, binary add/sub/mul/div,
9290     //                 binary comparisons, binary and/or/xor,
9291     //                 shufflevector, ExtVectorElementExpr
9292   };
9293 } // end anonymous namespace
9294 
9295 static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
9296   assert(E->isRValue() && E->getType()->isVectorType() &&"not a vector rvalue");
9297   return VectorExprEvaluator(Info, Result).Visit(E);
9298 }
9299 
9300 bool VectorExprEvaluator::VisitCastExpr(const CastExpr *E) {
9301   const VectorType *VTy = E->getType()->castAs<VectorType>();
9302   unsigned NElts = VTy->getNumElements();
9303 
9304   const Expr *SE = E->getSubExpr();
9305   QualType SETy = SE->getType();
9306 
9307   switch (E->getCastKind()) {
9308   case CK_VectorSplat: {
9309     APValue Val = APValue();
9310     if (SETy->isIntegerType()) {
9311       APSInt IntResult;
9312       if (!EvaluateInteger(SE, IntResult, Info))
9313         return false;
9314       Val = APValue(std::move(IntResult));
9315     } else if (SETy->isRealFloatingType()) {
9316       APFloat FloatResult(0.0);
9317       if (!EvaluateFloat(SE, FloatResult, Info))
9318         return false;
9319       Val = APValue(std::move(FloatResult));
9320     } else {
9321       return Error(E);
9322     }
9323 
9324     // Splat and create vector APValue.
9325     SmallVector<APValue, 4> Elts(NElts, Val);
9326     return Success(Elts, E);
9327   }
9328   case CK_BitCast: {
9329     // Evaluate the operand into an APInt we can extract from.
9330     llvm::APInt SValInt;
9331     if (!EvalAndBitcastToAPInt(Info, SE, SValInt))
9332       return false;
9333     // Extract the elements
9334     QualType EltTy = VTy->getElementType();
9335     unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
9336     bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
9337     SmallVector<APValue, 4> Elts;
9338     if (EltTy->isRealFloatingType()) {
9339       const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy);
9340       unsigned FloatEltSize = EltSize;
9341       if (&Sem == &APFloat::x87DoubleExtended())
9342         FloatEltSize = 80;
9343       for (unsigned i = 0; i < NElts; i++) {
9344         llvm::APInt Elt;
9345         if (BigEndian)
9346           Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize);
9347         else
9348           Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize);
9349         Elts.push_back(APValue(APFloat(Sem, Elt)));
9350       }
9351     } else if (EltTy->isIntegerType()) {
9352       for (unsigned i = 0; i < NElts; i++) {
9353         llvm::APInt Elt;
9354         if (BigEndian)
9355           Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize);
9356         else
9357           Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize);
9358         Elts.push_back(APValue(APSInt(Elt, EltTy->isSignedIntegerType())));
9359       }
9360     } else {
9361       return Error(E);
9362     }
9363     return Success(Elts, E);
9364   }
9365   default:
9366     return ExprEvaluatorBaseTy::VisitCastExpr(E);
9367   }
9368 }
9369 
9370 bool
9371 VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
9372   const VectorType *VT = E->getType()->castAs<VectorType>();
9373   unsigned NumInits = E->getNumInits();
9374   unsigned NumElements = VT->getNumElements();
9375 
9376   QualType EltTy = VT->getElementType();
9377   SmallVector<APValue, 4> Elements;
9378 
9379   // The number of initializers can be less than the number of
9380   // vector elements. For OpenCL, this can be due to nested vector
9381   // initialization. For GCC compatibility, missing trailing elements
9382   // should be initialized with zeroes.
9383   unsigned CountInits = 0, CountElts = 0;
9384   while (CountElts < NumElements) {
9385     // Handle nested vector initialization.
9386     if (CountInits < NumInits
9387         && E->getInit(CountInits)->getType()->isVectorType()) {
9388       APValue v;
9389       if (!EvaluateVector(E->getInit(CountInits), v, Info))
9390         return Error(E);
9391       unsigned vlen = v.getVectorLength();
9392       for (unsigned j = 0; j < vlen; j++)
9393         Elements.push_back(v.getVectorElt(j));
9394       CountElts += vlen;
9395     } else if (EltTy->isIntegerType()) {
9396       llvm::APSInt sInt(32);
9397       if (CountInits < NumInits) {
9398         if (!EvaluateInteger(E->getInit(CountInits), sInt, Info))
9399           return false;
9400       } else // trailing integer zero.
9401         sInt = Info.Ctx.MakeIntValue(0, EltTy);
9402       Elements.push_back(APValue(sInt));
9403       CountElts++;
9404     } else {
9405       llvm::APFloat f(0.0);
9406       if (CountInits < NumInits) {
9407         if (!EvaluateFloat(E->getInit(CountInits), f, Info))
9408           return false;
9409       } else // trailing float zero.
9410         f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
9411       Elements.push_back(APValue(f));
9412       CountElts++;
9413     }
9414     CountInits++;
9415   }
9416   return Success(Elements, E);
9417 }
9418 
9419 bool
9420 VectorExprEvaluator::ZeroInitialization(const Expr *E) {
9421   const auto *VT = E->getType()->castAs<VectorType>();
9422   QualType EltTy = VT->getElementType();
9423   APValue ZeroElement;
9424   if (EltTy->isIntegerType())
9425     ZeroElement = APValue(Info.Ctx.MakeIntValue(0, EltTy));
9426   else
9427     ZeroElement =
9428         APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
9429 
9430   SmallVector<APValue, 4> Elements(VT->getNumElements(), ZeroElement);
9431   return Success(Elements, E);
9432 }
9433 
9434 bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
9435   VisitIgnoredValue(E->getSubExpr());
9436   return ZeroInitialization(E);
9437 }
9438 
9439 //===----------------------------------------------------------------------===//
9440 // Array Evaluation
9441 //===----------------------------------------------------------------------===//
9442 
9443 namespace {
9444   class ArrayExprEvaluator
9445   : public ExprEvaluatorBase<ArrayExprEvaluator> {
9446     const LValue &This;
9447     APValue &Result;
9448   public:
9449 
9450     ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result)
9451       : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
9452 
9453     bool Success(const APValue &V, const Expr *E) {
9454       assert(V.isArray() && "expected array");
9455       Result = V;
9456       return true;
9457     }
9458 
9459     bool ZeroInitialization(const Expr *E) {
9460       const ConstantArrayType *CAT =
9461           Info.Ctx.getAsConstantArrayType(E->getType());
9462       if (!CAT)
9463         return Error(E);
9464 
9465       Result = APValue(APValue::UninitArray(), 0,
9466                        CAT->getSize().getZExtValue());
9467       if (!Result.hasArrayFiller()) return true;
9468 
9469       // Zero-initialize all elements.
9470       LValue Subobject = This;
9471       Subobject.addArray(Info, E, CAT);
9472       ImplicitValueInitExpr VIE(CAT->getElementType());
9473       return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
9474     }
9475 
9476     bool VisitCallExpr(const CallExpr *E) {
9477       return handleCallExpr(E, Result, &This);
9478     }
9479     bool VisitInitListExpr(const InitListExpr *E,
9480                            QualType AllocType = QualType());
9481     bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E);
9482     bool VisitCXXConstructExpr(const CXXConstructExpr *E);
9483     bool VisitCXXConstructExpr(const CXXConstructExpr *E,
9484                                const LValue &Subobject,
9485                                APValue *Value, QualType Type);
9486     bool VisitStringLiteral(const StringLiteral *E,
9487                             QualType AllocType = QualType()) {
9488       expandStringLiteral(Info, E, Result, AllocType);
9489       return true;
9490     }
9491   };
9492 } // end anonymous namespace
9493 
9494 static bool EvaluateArray(const Expr *E, const LValue &This,
9495                           APValue &Result, EvalInfo &Info) {
9496   assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue");
9497   return ArrayExprEvaluator(Info, This, Result).Visit(E);
9498 }
9499 
9500 static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This,
9501                                      APValue &Result, const InitListExpr *ILE,
9502                                      QualType AllocType) {
9503   assert(ILE->isRValue() && ILE->getType()->isArrayType() &&
9504          "not an array rvalue");
9505   return ArrayExprEvaluator(Info, This, Result)
9506       .VisitInitListExpr(ILE, AllocType);
9507 }
9508 
9509 // Return true iff the given array filler may depend on the element index.
9510 static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {
9511   // For now, just whitelist non-class value-initialization and initialization
9512   // lists comprised of them.
9513   if (isa<ImplicitValueInitExpr>(FillerExpr))
9514     return false;
9515   if (const InitListExpr *ILE = dyn_cast<InitListExpr>(FillerExpr)) {
9516     for (unsigned I = 0, E = ILE->getNumInits(); I != E; ++I) {
9517       if (MaybeElementDependentArrayFiller(ILE->getInit(I)))
9518         return true;
9519     }
9520     return false;
9521   }
9522   return true;
9523 }
9524 
9525 bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E,
9526                                            QualType AllocType) {
9527   const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(
9528       AllocType.isNull() ? E->getType() : AllocType);
9529   if (!CAT)
9530     return Error(E);
9531 
9532   // C++11 [dcl.init.string]p1: A char array [...] can be initialized by [...]
9533   // an appropriately-typed string literal enclosed in braces.
9534   if (E->isStringLiteralInit()) {
9535     auto *SL = dyn_cast<StringLiteral>(E->getInit(0)->IgnoreParens());
9536     // FIXME: Support ObjCEncodeExpr here once we support it in
9537     // ArrayExprEvaluator generally.
9538     if (!SL)
9539       return Error(E);
9540     return VisitStringLiteral(SL, AllocType);
9541   }
9542 
9543   bool Success = true;
9544 
9545   assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) &&
9546          "zero-initialized array shouldn't have any initialized elts");
9547   APValue Filler;
9548   if (Result.isArray() && Result.hasArrayFiller())
9549     Filler = Result.getArrayFiller();
9550 
9551   unsigned NumEltsToInit = E->getNumInits();
9552   unsigned NumElts = CAT->getSize().getZExtValue();
9553   const Expr *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : nullptr;
9554 
9555   // If the initializer might depend on the array index, run it for each
9556   // array element.
9557   if (NumEltsToInit != NumElts && MaybeElementDependentArrayFiller(FillerExpr))
9558     NumEltsToInit = NumElts;
9559 
9560   LLVM_DEBUG(llvm::dbgs() << "The number of elements to initialize: "
9561                           << NumEltsToInit << ".\n");
9562 
9563   Result = APValue(APValue::UninitArray(), NumEltsToInit, NumElts);
9564 
9565   // If the array was previously zero-initialized, preserve the
9566   // zero-initialized values.
9567   if (Filler.hasValue()) {
9568     for (unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I)
9569       Result.getArrayInitializedElt(I) = Filler;
9570     if (Result.hasArrayFiller())
9571       Result.getArrayFiller() = Filler;
9572   }
9573 
9574   LValue Subobject = This;
9575   Subobject.addArray(Info, E, CAT);
9576   for (unsigned Index = 0; Index != NumEltsToInit; ++Index) {
9577     const Expr *Init =
9578         Index < E->getNumInits() ? E->getInit(Index) : FillerExpr;
9579     if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
9580                          Info, Subobject, Init) ||
9581         !HandleLValueArrayAdjustment(Info, Init, Subobject,
9582                                      CAT->getElementType(), 1)) {
9583       if (!Info.noteFailure())
9584         return false;
9585       Success = false;
9586     }
9587   }
9588 
9589   if (!Result.hasArrayFiller())
9590     return Success;
9591 
9592   // If we get here, we have a trivial filler, which we can just evaluate
9593   // once and splat over the rest of the array elements.
9594   assert(FillerExpr && "no array filler for incomplete init list");
9595   return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject,
9596                          FillerExpr) && Success;
9597 }
9598 
9599 bool ArrayExprEvaluator::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) {
9600   LValue CommonLV;
9601   if (E->getCommonExpr() &&
9602       !Evaluate(Info.CurrentCall->createTemporary(
9603                     E->getCommonExpr(),
9604                     getStorageType(Info.Ctx, E->getCommonExpr()), false,
9605                     CommonLV),
9606                 Info, E->getCommonExpr()->getSourceExpr()))
9607     return false;
9608 
9609   auto *CAT = cast<ConstantArrayType>(E->getType()->castAsArrayTypeUnsafe());
9610 
9611   uint64_t Elements = CAT->getSize().getZExtValue();
9612   Result = APValue(APValue::UninitArray(), Elements, Elements);
9613 
9614   LValue Subobject = This;
9615   Subobject.addArray(Info, E, CAT);
9616 
9617   bool Success = true;
9618   for (EvalInfo::ArrayInitLoopIndex Index(Info); Index != Elements; ++Index) {
9619     if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
9620                          Info, Subobject, E->getSubExpr()) ||
9621         !HandleLValueArrayAdjustment(Info, E, Subobject,
9622                                      CAT->getElementType(), 1)) {
9623       if (!Info.noteFailure())
9624         return false;
9625       Success = false;
9626     }
9627   }
9628 
9629   return Success;
9630 }
9631 
9632 bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E) {
9633   return VisitCXXConstructExpr(E, This, &Result, E->getType());
9634 }
9635 
9636 bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
9637                                                const LValue &Subobject,
9638                                                APValue *Value,
9639                                                QualType Type) {
9640   bool HadZeroInit = Value->hasValue();
9641 
9642   if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) {
9643     unsigned N = CAT->getSize().getZExtValue();
9644 
9645     // Preserve the array filler if we had prior zero-initialization.
9646     APValue Filler =
9647       HadZeroInit && Value->hasArrayFiller() ? Value->getArrayFiller()
9648                                              : APValue();
9649 
9650     *Value = APValue(APValue::UninitArray(), N, N);
9651 
9652     if (HadZeroInit)
9653       for (unsigned I = 0; I != N; ++I)
9654         Value->getArrayInitializedElt(I) = Filler;
9655 
9656     // Initialize the elements.
9657     LValue ArrayElt = Subobject;
9658     ArrayElt.addArray(Info, E, CAT);
9659     for (unsigned I = 0; I != N; ++I)
9660       if (!VisitCXXConstructExpr(E, ArrayElt, &Value->getArrayInitializedElt(I),
9661                                  CAT->getElementType()) ||
9662           !HandleLValueArrayAdjustment(Info, E, ArrayElt,
9663                                        CAT->getElementType(), 1))
9664         return false;
9665 
9666     return true;
9667   }
9668 
9669   if (!Type->isRecordType())
9670     return Error(E);
9671 
9672   return RecordExprEvaluator(Info, Subobject, *Value)
9673              .VisitCXXConstructExpr(E, Type);
9674 }
9675 
9676 //===----------------------------------------------------------------------===//
9677 // Integer Evaluation
9678 //
9679 // As a GNU extension, we support casting pointers to sufficiently-wide integer
9680 // types and back in constant folding. Integer values are thus represented
9681 // either as an integer-valued APValue, or as an lvalue-valued APValue.
9682 //===----------------------------------------------------------------------===//
9683 
9684 namespace {
9685 class IntExprEvaluator
9686         : public ExprEvaluatorBase<IntExprEvaluator> {
9687   APValue &Result;
9688 public:
9689   IntExprEvaluator(EvalInfo &info, APValue &result)
9690       : ExprEvaluatorBaseTy(info), Result(result) {}
9691 
9692   bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
9693     assert(E->getType()->isIntegralOrEnumerationType() &&
9694            "Invalid evaluation result.");
9695     assert(SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() &&
9696            "Invalid evaluation result.");
9697     assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
9698            "Invalid evaluation result.");
9699     Result = APValue(SI);
9700     return true;
9701   }
9702   bool Success(const llvm::APSInt &SI, const Expr *E) {
9703     return Success(SI, E, Result);
9704   }
9705 
9706   bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
9707     assert(E->getType()->isIntegralOrEnumerationType() &&
9708            "Invalid evaluation result.");
9709     assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
9710            "Invalid evaluation result.");
9711     Result = APValue(APSInt(I));
9712     Result.getInt().setIsUnsigned(
9713                             E->getType()->isUnsignedIntegerOrEnumerationType());
9714     return true;
9715   }
9716   bool Success(const llvm::APInt &I, const Expr *E) {
9717     return Success(I, E, Result);
9718   }
9719 
9720   bool Success(uint64_t Value, const Expr *E, APValue &Result) {
9721     assert(E->getType()->isIntegralOrEnumerationType() &&
9722            "Invalid evaluation result.");
9723     Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
9724     return true;
9725   }
9726   bool Success(uint64_t Value, const Expr *E) {
9727     return Success(Value, E, Result);
9728   }
9729 
9730   bool Success(CharUnits Size, const Expr *E) {
9731     return Success(Size.getQuantity(), E);
9732   }
9733 
9734   bool Success(const APValue &V, const Expr *E) {
9735     if (V.isLValue() || V.isAddrLabelDiff() || V.isIndeterminate()) {
9736       Result = V;
9737       return true;
9738     }
9739     return Success(V.getInt(), E);
9740   }
9741 
9742   bool ZeroInitialization(const Expr *E) { return Success(0, E); }
9743 
9744   //===--------------------------------------------------------------------===//
9745   //                            Visitor Methods
9746   //===--------------------------------------------------------------------===//
9747 
9748   bool VisitConstantExpr(const ConstantExpr *E);
9749 
9750   bool VisitIntegerLiteral(const IntegerLiteral *E) {
9751     return Success(E->getValue(), E);
9752   }
9753   bool VisitCharacterLiteral(const CharacterLiteral *E) {
9754     return Success(E->getValue(), E);
9755   }
9756 
9757   bool CheckReferencedDecl(const Expr *E, const Decl *D);
9758   bool VisitDeclRefExpr(const DeclRefExpr *E) {
9759     if (CheckReferencedDecl(E, E->getDecl()))
9760       return true;
9761 
9762     return ExprEvaluatorBaseTy::VisitDeclRefExpr(E);
9763   }
9764   bool VisitMemberExpr(const MemberExpr *E) {
9765     if (CheckReferencedDecl(E, E->getMemberDecl())) {
9766       VisitIgnoredBaseExpression(E->getBase());
9767       return true;
9768     }
9769 
9770     return ExprEvaluatorBaseTy::VisitMemberExpr(E);
9771   }
9772 
9773   bool VisitCallExpr(const CallExpr *E);
9774   bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
9775   bool VisitBinaryOperator(const BinaryOperator *E);
9776   bool VisitOffsetOfExpr(const OffsetOfExpr *E);
9777   bool VisitUnaryOperator(const UnaryOperator *E);
9778 
9779   bool VisitCastExpr(const CastExpr* E);
9780   bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
9781 
9782   bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
9783     return Success(E->getValue(), E);
9784   }
9785 
9786   bool VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
9787     return Success(E->getValue(), E);
9788   }
9789 
9790   bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) {
9791     if (Info.ArrayInitIndex == uint64_t(-1)) {
9792       // We were asked to evaluate this subexpression independent of the
9793       // enclosing ArrayInitLoopExpr. We can't do that.
9794       Info.FFDiag(E);
9795       return false;
9796     }
9797     return Success(Info.ArrayInitIndex, E);
9798   }
9799 
9800   // Note, GNU defines __null as an integer, not a pointer.
9801   bool VisitGNUNullExpr(const GNUNullExpr *E) {
9802     return ZeroInitialization(E);
9803   }
9804 
9805   bool VisitTypeTraitExpr(const TypeTraitExpr *E) {
9806     return Success(E->getValue(), E);
9807   }
9808 
9809   bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
9810     return Success(E->getValue(), E);
9811   }
9812 
9813   bool VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
9814     return Success(E->getValue(), E);
9815   }
9816 
9817   bool VisitUnaryReal(const UnaryOperator *E);
9818   bool VisitUnaryImag(const UnaryOperator *E);
9819 
9820   bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E);
9821   bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
9822   bool VisitSourceLocExpr(const SourceLocExpr *E);
9823   bool VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E);
9824   // FIXME: Missing: array subscript of vector, member of vector
9825 };
9826 
9827 class FixedPointExprEvaluator
9828     : public ExprEvaluatorBase<FixedPointExprEvaluator> {
9829   APValue &Result;
9830 
9831  public:
9832   FixedPointExprEvaluator(EvalInfo &info, APValue &result)
9833       : ExprEvaluatorBaseTy(info), Result(result) {}
9834 
9835   bool Success(const llvm::APInt &I, const Expr *E) {
9836     return Success(
9837         APFixedPoint(I, Info.Ctx.getFixedPointSemantics(E->getType())), E);
9838   }
9839 
9840   bool Success(uint64_t Value, const Expr *E) {
9841     return Success(
9842         APFixedPoint(Value, Info.Ctx.getFixedPointSemantics(E->getType())), E);
9843   }
9844 
9845   bool Success(const APValue &V, const Expr *E) {
9846     return Success(V.getFixedPoint(), E);
9847   }
9848 
9849   bool Success(const APFixedPoint &V, const Expr *E) {
9850     assert(E->getType()->isFixedPointType() && "Invalid evaluation result.");
9851     assert(V.getWidth() == Info.Ctx.getIntWidth(E->getType()) &&
9852            "Invalid evaluation result.");
9853     Result = APValue(V);
9854     return true;
9855   }
9856 
9857   //===--------------------------------------------------------------------===//
9858   //                            Visitor Methods
9859   //===--------------------------------------------------------------------===//
9860 
9861   bool VisitFixedPointLiteral(const FixedPointLiteral *E) {
9862     return Success(E->getValue(), E);
9863   }
9864 
9865   bool VisitCastExpr(const CastExpr *E);
9866   bool VisitUnaryOperator(const UnaryOperator *E);
9867   bool VisitBinaryOperator(const BinaryOperator *E);
9868 };
9869 } // end anonymous namespace
9870 
9871 /// EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and
9872 /// produce either the integer value or a pointer.
9873 ///
9874 /// GCC has a heinous extension which folds casts between pointer types and
9875 /// pointer-sized integral types. We support this by allowing the evaluation of
9876 /// an integer rvalue to produce a pointer (represented as an lvalue) instead.
9877 /// Some simple arithmetic on such values is supported (they are treated much
9878 /// like char*).
9879 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
9880                                     EvalInfo &Info) {
9881   assert(E->isRValue() && E->getType()->isIntegralOrEnumerationType());
9882   return IntExprEvaluator(Info, Result).Visit(E);
9883 }
9884 
9885 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
9886   APValue Val;
9887   if (!EvaluateIntegerOrLValue(E, Val, Info))
9888     return false;
9889   if (!Val.isInt()) {
9890     // FIXME: It would be better to produce the diagnostic for casting
9891     //        a pointer to an integer.
9892     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
9893     return false;
9894   }
9895   Result = Val.getInt();
9896   return true;
9897 }
9898 
9899 bool IntExprEvaluator::VisitSourceLocExpr(const SourceLocExpr *E) {
9900   APValue Evaluated = E->EvaluateInContext(
9901       Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr());
9902   return Success(Evaluated, E);
9903 }
9904 
9905 static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
9906                                EvalInfo &Info) {
9907   if (E->getType()->isFixedPointType()) {
9908     APValue Val;
9909     if (!FixedPointExprEvaluator(Info, Val).Visit(E))
9910       return false;
9911     if (!Val.isFixedPoint())
9912       return false;
9913 
9914     Result = Val.getFixedPoint();
9915     return true;
9916   }
9917   return false;
9918 }
9919 
9920 static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
9921                                         EvalInfo &Info) {
9922   if (E->getType()->isIntegerType()) {
9923     auto FXSema = Info.Ctx.getFixedPointSemantics(E->getType());
9924     APSInt Val;
9925     if (!EvaluateInteger(E, Val, Info))
9926       return false;
9927     Result = APFixedPoint(Val, FXSema);
9928     return true;
9929   } else if (E->getType()->isFixedPointType()) {
9930     return EvaluateFixedPoint(E, Result, Info);
9931   }
9932   return false;
9933 }
9934 
9935 /// Check whether the given declaration can be directly converted to an integral
9936 /// rvalue. If not, no diagnostic is produced; there are other things we can
9937 /// try.
9938 bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) {
9939   // Enums are integer constant exprs.
9940   if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) {
9941     // Check for signedness/width mismatches between E type and ECD value.
9942     bool SameSign = (ECD->getInitVal().isSigned()
9943                      == E->getType()->isSignedIntegerOrEnumerationType());
9944     bool SameWidth = (ECD->getInitVal().getBitWidth()
9945                       == Info.Ctx.getIntWidth(E->getType()));
9946     if (SameSign && SameWidth)
9947       return Success(ECD->getInitVal(), E);
9948     else {
9949       // Get rid of mismatch (otherwise Success assertions will fail)
9950       // by computing a new value matching the type of E.
9951       llvm::APSInt Val = ECD->getInitVal();
9952       if (!SameSign)
9953         Val.setIsSigned(!ECD->getInitVal().isSigned());
9954       if (!SameWidth)
9955         Val = Val.extOrTrunc(Info.Ctx.getIntWidth(E->getType()));
9956       return Success(Val, E);
9957     }
9958   }
9959   return false;
9960 }
9961 
9962 /// Values returned by __builtin_classify_type, chosen to match the values
9963 /// produced by GCC's builtin.
9964 enum class GCCTypeClass {
9965   None = -1,
9966   Void = 0,
9967   Integer = 1,
9968   // GCC reserves 2 for character types, but instead classifies them as
9969   // integers.
9970   Enum = 3,
9971   Bool = 4,
9972   Pointer = 5,
9973   // GCC reserves 6 for references, but appears to never use it (because
9974   // expressions never have reference type, presumably).
9975   PointerToDataMember = 7,
9976   RealFloat = 8,
9977   Complex = 9,
9978   // GCC reserves 10 for functions, but does not use it since GCC version 6 due
9979   // to decay to pointer. (Prior to version 6 it was only used in C++ mode).
9980   // GCC claims to reserve 11 for pointers to member functions, but *actually*
9981   // uses 12 for that purpose, same as for a class or struct. Maybe it
9982   // internally implements a pointer to member as a struct?  Who knows.
9983   PointerToMemberFunction = 12, // Not a bug, see above.
9984   ClassOrStruct = 12,
9985   Union = 13,
9986   // GCC reserves 14 for arrays, but does not use it since GCC version 6 due to
9987   // decay to pointer. (Prior to version 6 it was only used in C++ mode).
9988   // GCC reserves 15 for strings, but actually uses 5 (pointer) for string
9989   // literals.
9990 };
9991 
9992 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
9993 /// as GCC.
9994 static GCCTypeClass
9995 EvaluateBuiltinClassifyType(QualType T, const LangOptions &LangOpts) {
9996   assert(!T->isDependentType() && "unexpected dependent type");
9997 
9998   QualType CanTy = T.getCanonicalType();
9999   const BuiltinType *BT = dyn_cast<BuiltinType>(CanTy);
10000 
10001   switch (CanTy->getTypeClass()) {
10002 #define TYPE(ID, BASE)
10003 #define DEPENDENT_TYPE(ID, BASE) case Type::ID:
10004 #define NON_CANONICAL_TYPE(ID, BASE) case Type::ID:
10005 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(ID, BASE) case Type::ID:
10006 #include "clang/AST/TypeNodes.inc"
10007   case Type::Auto:
10008   case Type::DeducedTemplateSpecialization:
10009       llvm_unreachable("unexpected non-canonical or dependent type");
10010 
10011   case Type::Builtin:
10012     switch (BT->getKind()) {
10013 #define BUILTIN_TYPE(ID, SINGLETON_ID)
10014 #define SIGNED_TYPE(ID, SINGLETON_ID) \
10015     case BuiltinType::ID: return GCCTypeClass::Integer;
10016 #define FLOATING_TYPE(ID, SINGLETON_ID) \
10017     case BuiltinType::ID: return GCCTypeClass::RealFloat;
10018 #define PLACEHOLDER_TYPE(ID, SINGLETON_ID) \
10019     case BuiltinType::ID: break;
10020 #include "clang/AST/BuiltinTypes.def"
10021     case BuiltinType::Void:
10022       return GCCTypeClass::Void;
10023 
10024     case BuiltinType::Bool:
10025       return GCCTypeClass::Bool;
10026 
10027     case BuiltinType::Char_U:
10028     case BuiltinType::UChar:
10029     case BuiltinType::WChar_U:
10030     case BuiltinType::Char8:
10031     case BuiltinType::Char16:
10032     case BuiltinType::Char32:
10033     case BuiltinType::UShort:
10034     case BuiltinType::UInt:
10035     case BuiltinType::ULong:
10036     case BuiltinType::ULongLong:
10037     case BuiltinType::UInt128:
10038       return GCCTypeClass::Integer;
10039 
10040     case BuiltinType::UShortAccum:
10041     case BuiltinType::UAccum:
10042     case BuiltinType::ULongAccum:
10043     case BuiltinType::UShortFract:
10044     case BuiltinType::UFract:
10045     case BuiltinType::ULongFract:
10046     case BuiltinType::SatUShortAccum:
10047     case BuiltinType::SatUAccum:
10048     case BuiltinType::SatULongAccum:
10049     case BuiltinType::SatUShortFract:
10050     case BuiltinType::SatUFract:
10051     case BuiltinType::SatULongFract:
10052       return GCCTypeClass::None;
10053 
10054     case BuiltinType::NullPtr:
10055 
10056     case BuiltinType::ObjCId:
10057     case BuiltinType::ObjCClass:
10058     case BuiltinType::ObjCSel:
10059 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
10060     case BuiltinType::Id:
10061 #include "clang/Basic/OpenCLImageTypes.def"
10062 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
10063     case BuiltinType::Id:
10064 #include "clang/Basic/OpenCLExtensionTypes.def"
10065     case BuiltinType::OCLSampler:
10066     case BuiltinType::OCLEvent:
10067     case BuiltinType::OCLClkEvent:
10068     case BuiltinType::OCLQueue:
10069     case BuiltinType::OCLReserveID:
10070 #define SVE_TYPE(Name, Id, SingletonId) \
10071     case BuiltinType::Id:
10072 #include "clang/Basic/AArch64SVEACLETypes.def"
10073       return GCCTypeClass::None;
10074 
10075     case BuiltinType::Dependent:
10076       llvm_unreachable("unexpected dependent type");
10077     };
10078     llvm_unreachable("unexpected placeholder type");
10079 
10080   case Type::Enum:
10081     return LangOpts.CPlusPlus ? GCCTypeClass::Enum : GCCTypeClass::Integer;
10082 
10083   case Type::Pointer:
10084   case Type::ConstantArray:
10085   case Type::VariableArray:
10086   case Type::IncompleteArray:
10087   case Type::FunctionNoProto:
10088   case Type::FunctionProto:
10089     return GCCTypeClass::Pointer;
10090 
10091   case Type::MemberPointer:
10092     return CanTy->isMemberDataPointerType()
10093                ? GCCTypeClass::PointerToDataMember
10094                : GCCTypeClass::PointerToMemberFunction;
10095 
10096   case Type::Complex:
10097     return GCCTypeClass::Complex;
10098 
10099   case Type::Record:
10100     return CanTy->isUnionType() ? GCCTypeClass::Union
10101                                 : GCCTypeClass::ClassOrStruct;
10102 
10103   case Type::Atomic:
10104     // GCC classifies _Atomic T the same as T.
10105     return EvaluateBuiltinClassifyType(
10106         CanTy->castAs<AtomicType>()->getValueType(), LangOpts);
10107 
10108   case Type::BlockPointer:
10109   case Type::Vector:
10110   case Type::ExtVector:
10111   case Type::ObjCObject:
10112   case Type::ObjCInterface:
10113   case Type::ObjCObjectPointer:
10114   case Type::Pipe:
10115     // GCC classifies vectors as None. We follow its lead and classify all
10116     // other types that don't fit into the regular classification the same way.
10117     return GCCTypeClass::None;
10118 
10119   case Type::LValueReference:
10120   case Type::RValueReference:
10121     llvm_unreachable("invalid type for expression");
10122   }
10123 
10124   llvm_unreachable("unexpected type class");
10125 }
10126 
10127 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
10128 /// as GCC.
10129 static GCCTypeClass
10130 EvaluateBuiltinClassifyType(const CallExpr *E, const LangOptions &LangOpts) {
10131   // If no argument was supplied, default to None. This isn't
10132   // ideal, however it is what gcc does.
10133   if (E->getNumArgs() == 0)
10134     return GCCTypeClass::None;
10135 
10136   // FIXME: Bizarrely, GCC treats a call with more than one argument as not
10137   // being an ICE, but still folds it to a constant using the type of the first
10138   // argument.
10139   return EvaluateBuiltinClassifyType(E->getArg(0)->getType(), LangOpts);
10140 }
10141 
10142 /// EvaluateBuiltinConstantPForLValue - Determine the result of
10143 /// __builtin_constant_p when applied to the given pointer.
10144 ///
10145 /// A pointer is only "constant" if it is null (or a pointer cast to integer)
10146 /// or it points to the first character of a string literal.
10147 static bool EvaluateBuiltinConstantPForLValue(const APValue &LV) {
10148   APValue::LValueBase Base = LV.getLValueBase();
10149   if (Base.isNull()) {
10150     // A null base is acceptable.
10151     return true;
10152   } else if (const Expr *E = Base.dyn_cast<const Expr *>()) {
10153     if (!isa<StringLiteral>(E))
10154       return false;
10155     return LV.getLValueOffset().isZero();
10156   } else if (Base.is<TypeInfoLValue>()) {
10157     // Surprisingly, GCC considers __builtin_constant_p(&typeid(int)) to
10158     // evaluate to true.
10159     return true;
10160   } else {
10161     // Any other base is not constant enough for GCC.
10162     return false;
10163   }
10164 }
10165 
10166 /// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to
10167 /// GCC as we can manage.
10168 static bool EvaluateBuiltinConstantP(EvalInfo &Info, const Expr *Arg) {
10169   // This evaluation is not permitted to have side-effects, so evaluate it in
10170   // a speculative evaluation context.
10171   SpeculativeEvaluationRAII SpeculativeEval(Info);
10172 
10173   // Constant-folding is always enabled for the operand of __builtin_constant_p
10174   // (even when the enclosing evaluation context otherwise requires a strict
10175   // language-specific constant expression).
10176   FoldConstant Fold(Info, true);
10177 
10178   QualType ArgType = Arg->getType();
10179 
10180   // __builtin_constant_p always has one operand. The rules which gcc follows
10181   // are not precisely documented, but are as follows:
10182   //
10183   //  - If the operand is of integral, floating, complex or enumeration type,
10184   //    and can be folded to a known value of that type, it returns 1.
10185   //  - If the operand can be folded to a pointer to the first character
10186   //    of a string literal (or such a pointer cast to an integral type)
10187   //    or to a null pointer or an integer cast to a pointer, it returns 1.
10188   //
10189   // Otherwise, it returns 0.
10190   //
10191   // FIXME: GCC also intends to return 1 for literals of aggregate types, but
10192   // its support for this did not work prior to GCC 9 and is not yet well
10193   // understood.
10194   if (ArgType->isIntegralOrEnumerationType() || ArgType->isFloatingType() ||
10195       ArgType->isAnyComplexType() || ArgType->isPointerType() ||
10196       ArgType->isNullPtrType()) {
10197     APValue V;
10198     if (!::EvaluateAsRValue(Info, Arg, V)) {
10199       Fold.keepDiagnostics();
10200       return false;
10201     }
10202 
10203     // For a pointer (possibly cast to integer), there are special rules.
10204     if (V.getKind() == APValue::LValue)
10205       return EvaluateBuiltinConstantPForLValue(V);
10206 
10207     // Otherwise, any constant value is good enough.
10208     return V.hasValue();
10209   }
10210 
10211   // Anything else isn't considered to be sufficiently constant.
10212   return false;
10213 }
10214 
10215 /// Retrieves the "underlying object type" of the given expression,
10216 /// as used by __builtin_object_size.
10217 static QualType getObjectType(APValue::LValueBase B) {
10218   if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
10219     if (const VarDecl *VD = dyn_cast<VarDecl>(D))
10220       return VD->getType();
10221   } else if (const Expr *E = B.get<const Expr*>()) {
10222     if (isa<CompoundLiteralExpr>(E))
10223       return E->getType();
10224   } else if (B.is<TypeInfoLValue>()) {
10225     return B.getTypeInfoType();
10226   } else if (B.is<DynamicAllocLValue>()) {
10227     return B.getDynamicAllocType();
10228   }
10229 
10230   return QualType();
10231 }
10232 
10233 /// A more selective version of E->IgnoreParenCasts for
10234 /// tryEvaluateBuiltinObjectSize. This ignores some casts/parens that serve only
10235 /// to change the type of E.
10236 /// Ex. For E = `(short*)((char*)(&foo))`, returns `&foo`
10237 ///
10238 /// Always returns an RValue with a pointer representation.
10239 static const Expr *ignorePointerCastsAndParens(const Expr *E) {
10240   assert(E->isRValue() && E->getType()->hasPointerRepresentation());
10241 
10242   auto *NoParens = E->IgnoreParens();
10243   auto *Cast = dyn_cast<CastExpr>(NoParens);
10244   if (Cast == nullptr)
10245     return NoParens;
10246 
10247   // We only conservatively allow a few kinds of casts, because this code is
10248   // inherently a simple solution that seeks to support the common case.
10249   auto CastKind = Cast->getCastKind();
10250   if (CastKind != CK_NoOp && CastKind != CK_BitCast &&
10251       CastKind != CK_AddressSpaceConversion)
10252     return NoParens;
10253 
10254   auto *SubExpr = Cast->getSubExpr();
10255   if (!SubExpr->getType()->hasPointerRepresentation() || !SubExpr->isRValue())
10256     return NoParens;
10257   return ignorePointerCastsAndParens(SubExpr);
10258 }
10259 
10260 /// Checks to see if the given LValue's Designator is at the end of the LValue's
10261 /// record layout. e.g.
10262 ///   struct { struct { int a, b; } fst, snd; } obj;
10263 ///   obj.fst   // no
10264 ///   obj.snd   // yes
10265 ///   obj.fst.a // no
10266 ///   obj.fst.b // no
10267 ///   obj.snd.a // no
10268 ///   obj.snd.b // yes
10269 ///
10270 /// Please note: this function is specialized for how __builtin_object_size
10271 /// views "objects".
10272 ///
10273 /// If this encounters an invalid RecordDecl or otherwise cannot determine the
10274 /// correct result, it will always return true.
10275 static bool isDesignatorAtObjectEnd(const ASTContext &Ctx, const LValue &LVal) {
10276   assert(!LVal.Designator.Invalid);
10277 
10278   auto IsLastOrInvalidFieldDecl = [&Ctx](const FieldDecl *FD, bool &Invalid) {
10279     const RecordDecl *Parent = FD->getParent();
10280     Invalid = Parent->isInvalidDecl();
10281     if (Invalid || Parent->isUnion())
10282       return true;
10283     const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(Parent);
10284     return FD->getFieldIndex() + 1 == Layout.getFieldCount();
10285   };
10286 
10287   auto &Base = LVal.getLValueBase();
10288   if (auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<const Expr *>())) {
10289     if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
10290       bool Invalid;
10291       if (!IsLastOrInvalidFieldDecl(FD, Invalid))
10292         return Invalid;
10293     } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(ME->getMemberDecl())) {
10294       for (auto *FD : IFD->chain()) {
10295         bool Invalid;
10296         if (!IsLastOrInvalidFieldDecl(cast<FieldDecl>(FD), Invalid))
10297           return Invalid;
10298       }
10299     }
10300   }
10301 
10302   unsigned I = 0;
10303   QualType BaseType = getType(Base);
10304   if (LVal.Designator.FirstEntryIsAnUnsizedArray) {
10305     // If we don't know the array bound, conservatively assume we're looking at
10306     // the final array element.
10307     ++I;
10308     if (BaseType->isIncompleteArrayType())
10309       BaseType = Ctx.getAsArrayType(BaseType)->getElementType();
10310     else
10311       BaseType = BaseType->castAs<PointerType>()->getPointeeType();
10312   }
10313 
10314   for (unsigned E = LVal.Designator.Entries.size(); I != E; ++I) {
10315     const auto &Entry = LVal.Designator.Entries[I];
10316     if (BaseType->isArrayType()) {
10317       // Because __builtin_object_size treats arrays as objects, we can ignore
10318       // the index iff this is the last array in the Designator.
10319       if (I + 1 == E)
10320         return true;
10321       const auto *CAT = cast<ConstantArrayType>(Ctx.getAsArrayType(BaseType));
10322       uint64_t Index = Entry.getAsArrayIndex();
10323       if (Index + 1 != CAT->getSize())
10324         return false;
10325       BaseType = CAT->getElementType();
10326     } else if (BaseType->isAnyComplexType()) {
10327       const auto *CT = BaseType->castAs<ComplexType>();
10328       uint64_t Index = Entry.getAsArrayIndex();
10329       if (Index != 1)
10330         return false;
10331       BaseType = CT->getElementType();
10332     } else if (auto *FD = getAsField(Entry)) {
10333       bool Invalid;
10334       if (!IsLastOrInvalidFieldDecl(FD, Invalid))
10335         return Invalid;
10336       BaseType = FD->getType();
10337     } else {
10338       assert(getAsBaseClass(Entry) && "Expecting cast to a base class");
10339       return false;
10340     }
10341   }
10342   return true;
10343 }
10344 
10345 /// Tests to see if the LValue has a user-specified designator (that isn't
10346 /// necessarily valid). Note that this always returns 'true' if the LValue has
10347 /// an unsized array as its first designator entry, because there's currently no
10348 /// way to tell if the user typed *foo or foo[0].
10349 static bool refersToCompleteObject(const LValue &LVal) {
10350   if (LVal.Designator.Invalid)
10351     return false;
10352 
10353   if (!LVal.Designator.Entries.empty())
10354     return LVal.Designator.isMostDerivedAnUnsizedArray();
10355 
10356   if (!LVal.InvalidBase)
10357     return true;
10358 
10359   // If `E` is a MemberExpr, then the first part of the designator is hiding in
10360   // the LValueBase.
10361   const auto *E = LVal.Base.dyn_cast<const Expr *>();
10362   return !E || !isa<MemberExpr>(E);
10363 }
10364 
10365 /// Attempts to detect a user writing into a piece of memory that's impossible
10366 /// to figure out the size of by just using types.
10367 static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal) {
10368   const SubobjectDesignator &Designator = LVal.Designator;
10369   // Notes:
10370   // - Users can only write off of the end when we have an invalid base. Invalid
10371   //   bases imply we don't know where the memory came from.
10372   // - We used to be a bit more aggressive here; we'd only be conservative if
10373   //   the array at the end was flexible, or if it had 0 or 1 elements. This
10374   //   broke some common standard library extensions (PR30346), but was
10375   //   otherwise seemingly fine. It may be useful to reintroduce this behavior
10376   //   with some sort of whitelist. OTOH, it seems that GCC is always
10377   //   conservative with the last element in structs (if it's an array), so our
10378   //   current behavior is more compatible than a whitelisting approach would
10379   //   be.
10380   return LVal.InvalidBase &&
10381          Designator.Entries.size() == Designator.MostDerivedPathLength &&
10382          Designator.MostDerivedIsArrayElement &&
10383          isDesignatorAtObjectEnd(Ctx, LVal);
10384 }
10385 
10386 /// Converts the given APInt to CharUnits, assuming the APInt is unsigned.
10387 /// Fails if the conversion would cause loss of precision.
10388 static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int,
10389                                             CharUnits &Result) {
10390   auto CharUnitsMax = std::numeric_limits<CharUnits::QuantityType>::max();
10391   if (Int.ugt(CharUnitsMax))
10392     return false;
10393   Result = CharUnits::fromQuantity(Int.getZExtValue());
10394   return true;
10395 }
10396 
10397 /// Helper for tryEvaluateBuiltinObjectSize -- Given an LValue, this will
10398 /// determine how many bytes exist from the beginning of the object to either
10399 /// the end of the current subobject, or the end of the object itself, depending
10400 /// on what the LValue looks like + the value of Type.
10401 ///
10402 /// If this returns false, the value of Result is undefined.
10403 static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc,
10404                                unsigned Type, const LValue &LVal,
10405                                CharUnits &EndOffset) {
10406   bool DetermineForCompleteObject = refersToCompleteObject(LVal);
10407 
10408   auto CheckedHandleSizeof = [&](QualType Ty, CharUnits &Result) {
10409     if (Ty.isNull() || Ty->isIncompleteType() || Ty->isFunctionType())
10410       return false;
10411     return HandleSizeof(Info, ExprLoc, Ty, Result);
10412   };
10413 
10414   // We want to evaluate the size of the entire object. This is a valid fallback
10415   // for when Type=1 and the designator is invalid, because we're asked for an
10416   // upper-bound.
10417   if (!(Type & 1) || LVal.Designator.Invalid || DetermineForCompleteObject) {
10418     // Type=3 wants a lower bound, so we can't fall back to this.
10419     if (Type == 3 && !DetermineForCompleteObject)
10420       return false;
10421 
10422     llvm::APInt APEndOffset;
10423     if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
10424         getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
10425       return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
10426 
10427     if (LVal.InvalidBase)
10428       return false;
10429 
10430     QualType BaseTy = getObjectType(LVal.getLValueBase());
10431     return CheckedHandleSizeof(BaseTy, EndOffset);
10432   }
10433 
10434   // We want to evaluate the size of a subobject.
10435   const SubobjectDesignator &Designator = LVal.Designator;
10436 
10437   // The following is a moderately common idiom in C:
10438   //
10439   // struct Foo { int a; char c[1]; };
10440   // struct Foo *F = (struct Foo *)malloc(sizeof(struct Foo) + strlen(Bar));
10441   // strcpy(&F->c[0], Bar);
10442   //
10443   // In order to not break too much legacy code, we need to support it.
10444   if (isUserWritingOffTheEnd(Info.Ctx, LVal)) {
10445     // If we can resolve this to an alloc_size call, we can hand that back,
10446     // because we know for certain how many bytes there are to write to.
10447     llvm::APInt APEndOffset;
10448     if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
10449         getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
10450       return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
10451 
10452     // If we cannot determine the size of the initial allocation, then we can't
10453     // given an accurate upper-bound. However, we are still able to give
10454     // conservative lower-bounds for Type=3.
10455     if (Type == 1)
10456       return false;
10457   }
10458 
10459   CharUnits BytesPerElem;
10460   if (!CheckedHandleSizeof(Designator.MostDerivedType, BytesPerElem))
10461     return false;
10462 
10463   // According to the GCC documentation, we want the size of the subobject
10464   // denoted by the pointer. But that's not quite right -- what we actually
10465   // want is the size of the immediately-enclosing array, if there is one.
10466   int64_t ElemsRemaining;
10467   if (Designator.MostDerivedIsArrayElement &&
10468       Designator.Entries.size() == Designator.MostDerivedPathLength) {
10469     uint64_t ArraySize = Designator.getMostDerivedArraySize();
10470     uint64_t ArrayIndex = Designator.Entries.back().getAsArrayIndex();
10471     ElemsRemaining = ArraySize <= ArrayIndex ? 0 : ArraySize - ArrayIndex;
10472   } else {
10473     ElemsRemaining = Designator.isOnePastTheEnd() ? 0 : 1;
10474   }
10475 
10476   EndOffset = LVal.getLValueOffset() + BytesPerElem * ElemsRemaining;
10477   return true;
10478 }
10479 
10480 /// Tries to evaluate the __builtin_object_size for @p E. If successful,
10481 /// returns true and stores the result in @p Size.
10482 ///
10483 /// If @p WasError is non-null, this will report whether the failure to evaluate
10484 /// is to be treated as an Error in IntExprEvaluator.
10485 static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type,
10486                                          EvalInfo &Info, uint64_t &Size) {
10487   // Determine the denoted object.
10488   LValue LVal;
10489   {
10490     // The operand of __builtin_object_size is never evaluated for side-effects.
10491     // If there are any, but we can determine the pointed-to object anyway, then
10492     // ignore the side-effects.
10493     SpeculativeEvaluationRAII SpeculativeEval(Info);
10494     IgnoreSideEffectsRAII Fold(Info);
10495 
10496     if (E->isGLValue()) {
10497       // It's possible for us to be given GLValues if we're called via
10498       // Expr::tryEvaluateObjectSize.
10499       APValue RVal;
10500       if (!EvaluateAsRValue(Info, E, RVal))
10501         return false;
10502       LVal.setFrom(Info.Ctx, RVal);
10503     } else if (!EvaluatePointer(ignorePointerCastsAndParens(E), LVal, Info,
10504                                 /*InvalidBaseOK=*/true))
10505       return false;
10506   }
10507 
10508   // If we point to before the start of the object, there are no accessible
10509   // bytes.
10510   if (LVal.getLValueOffset().isNegative()) {
10511     Size = 0;
10512     return true;
10513   }
10514 
10515   CharUnits EndOffset;
10516   if (!determineEndOffset(Info, E->getExprLoc(), Type, LVal, EndOffset))
10517     return false;
10518 
10519   // If we've fallen outside of the end offset, just pretend there's nothing to
10520   // write to/read from.
10521   if (EndOffset <= LVal.getLValueOffset())
10522     Size = 0;
10523   else
10524     Size = (EndOffset - LVal.getLValueOffset()).getQuantity();
10525   return true;
10526 }
10527 
10528 bool IntExprEvaluator::VisitConstantExpr(const ConstantExpr *E) {
10529   llvm::SaveAndRestore<bool> InConstantContext(Info.InConstantContext, true);
10530   if (E->getResultAPValueKind() != APValue::None)
10531     return Success(E->getAPValueResult(), E);
10532   return ExprEvaluatorBaseTy::VisitConstantExpr(E);
10533 }
10534 
10535 bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
10536   if (unsigned BuiltinOp = E->getBuiltinCallee())
10537     return VisitBuiltinCallExpr(E, BuiltinOp);
10538 
10539   return ExprEvaluatorBaseTy::VisitCallExpr(E);
10540 }
10541 
10542 bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
10543                                             unsigned BuiltinOp) {
10544   switch (unsigned BuiltinOp = E->getBuiltinCallee()) {
10545   default:
10546     return ExprEvaluatorBaseTy::VisitCallExpr(E);
10547 
10548   case Builtin::BI__builtin_dynamic_object_size:
10549   case Builtin::BI__builtin_object_size: {
10550     // The type was checked when we built the expression.
10551     unsigned Type =
10552         E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
10553     assert(Type <= 3 && "unexpected type");
10554 
10555     uint64_t Size;
10556     if (tryEvaluateBuiltinObjectSize(E->getArg(0), Type, Info, Size))
10557       return Success(Size, E);
10558 
10559     if (E->getArg(0)->HasSideEffects(Info.Ctx))
10560       return Success((Type & 2) ? 0 : -1, E);
10561 
10562     // Expression had no side effects, but we couldn't statically determine the
10563     // size of the referenced object.
10564     switch (Info.EvalMode) {
10565     case EvalInfo::EM_ConstantExpression:
10566     case EvalInfo::EM_ConstantFold:
10567     case EvalInfo::EM_IgnoreSideEffects:
10568       // Leave it to IR generation.
10569       return Error(E);
10570     case EvalInfo::EM_ConstantExpressionUnevaluated:
10571       // Reduce it to a constant now.
10572       return Success((Type & 2) ? 0 : -1, E);
10573     }
10574 
10575     llvm_unreachable("unexpected EvalMode");
10576   }
10577 
10578   case Builtin::BI__builtin_os_log_format_buffer_size: {
10579     analyze_os_log::OSLogBufferLayout Layout;
10580     analyze_os_log::computeOSLogBufferLayout(Info.Ctx, E, Layout);
10581     return Success(Layout.size().getQuantity(), E);
10582   }
10583 
10584   case Builtin::BI__builtin_bswap16:
10585   case Builtin::BI__builtin_bswap32:
10586   case Builtin::BI__builtin_bswap64: {
10587     APSInt Val;
10588     if (!EvaluateInteger(E->getArg(0), Val, Info))
10589       return false;
10590 
10591     return Success(Val.byteSwap(), E);
10592   }
10593 
10594   case Builtin::BI__builtin_classify_type:
10595     return Success((int)EvaluateBuiltinClassifyType(E, Info.getLangOpts()), E);
10596 
10597   case Builtin::BI__builtin_clrsb:
10598   case Builtin::BI__builtin_clrsbl:
10599   case Builtin::BI__builtin_clrsbll: {
10600     APSInt Val;
10601     if (!EvaluateInteger(E->getArg(0), Val, Info))
10602       return false;
10603 
10604     return Success(Val.getBitWidth() - Val.getMinSignedBits(), E);
10605   }
10606 
10607   case Builtin::BI__builtin_clz:
10608   case Builtin::BI__builtin_clzl:
10609   case Builtin::BI__builtin_clzll:
10610   case Builtin::BI__builtin_clzs: {
10611     APSInt Val;
10612     if (!EvaluateInteger(E->getArg(0), Val, Info))
10613       return false;
10614     if (!Val)
10615       return Error(E);
10616 
10617     return Success(Val.countLeadingZeros(), E);
10618   }
10619 
10620   case Builtin::BI__builtin_constant_p: {
10621     const Expr *Arg = E->getArg(0);
10622     if (EvaluateBuiltinConstantP(Info, Arg))
10623       return Success(true, E);
10624     if (Info.InConstantContext || Arg->HasSideEffects(Info.Ctx)) {
10625       // Outside a constant context, eagerly evaluate to false in the presence
10626       // of side-effects in order to avoid -Wunsequenced false-positives in
10627       // a branch on __builtin_constant_p(expr).
10628       return Success(false, E);
10629     }
10630     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
10631     return false;
10632   }
10633 
10634   case Builtin::BI__builtin_is_constant_evaluated: {
10635     const auto *Callee = Info.CurrentCall->getCallee();
10636     if (Info.InConstantContext && !Info.CheckingPotentialConstantExpression &&
10637         (Info.CallStackDepth == 1 ||
10638          (Info.CallStackDepth == 2 && Callee->isInStdNamespace() &&
10639           Callee->getIdentifier() &&
10640           Callee->getIdentifier()->isStr("is_constant_evaluated")))) {
10641       // FIXME: Find a better way to avoid duplicated diagnostics.
10642       if (Info.EvalStatus.Diag)
10643         Info.report((Info.CallStackDepth == 1) ? E->getExprLoc()
10644                                                : Info.CurrentCall->CallLoc,
10645                     diag::warn_is_constant_evaluated_always_true_constexpr)
10646             << (Info.CallStackDepth == 1 ? "__builtin_is_constant_evaluated"
10647                                          : "std::is_constant_evaluated");
10648     }
10649 
10650     return Success(Info.InConstantContext, E);
10651   }
10652 
10653   case Builtin::BI__builtin_ctz:
10654   case Builtin::BI__builtin_ctzl:
10655   case Builtin::BI__builtin_ctzll:
10656   case Builtin::BI__builtin_ctzs: {
10657     APSInt Val;
10658     if (!EvaluateInteger(E->getArg(0), Val, Info))
10659       return false;
10660     if (!Val)
10661       return Error(E);
10662 
10663     return Success(Val.countTrailingZeros(), E);
10664   }
10665 
10666   case Builtin::BI__builtin_eh_return_data_regno: {
10667     int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
10668     Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand);
10669     return Success(Operand, E);
10670   }
10671 
10672   case Builtin::BI__builtin_expect:
10673     return Visit(E->getArg(0));
10674 
10675   case Builtin::BI__builtin_ffs:
10676   case Builtin::BI__builtin_ffsl:
10677   case Builtin::BI__builtin_ffsll: {
10678     APSInt Val;
10679     if (!EvaluateInteger(E->getArg(0), Val, Info))
10680       return false;
10681 
10682     unsigned N = Val.countTrailingZeros();
10683     return Success(N == Val.getBitWidth() ? 0 : N + 1, E);
10684   }
10685 
10686   case Builtin::BI__builtin_fpclassify: {
10687     APFloat Val(0.0);
10688     if (!EvaluateFloat(E->getArg(5), Val, Info))
10689       return false;
10690     unsigned Arg;
10691     switch (Val.getCategory()) {
10692     case APFloat::fcNaN: Arg = 0; break;
10693     case APFloat::fcInfinity: Arg = 1; break;
10694     case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2; break;
10695     case APFloat::fcZero: Arg = 4; break;
10696     }
10697     return Visit(E->getArg(Arg));
10698   }
10699 
10700   case Builtin::BI__builtin_isinf_sign: {
10701     APFloat Val(0.0);
10702     return EvaluateFloat(E->getArg(0), Val, Info) &&
10703            Success(Val.isInfinity() ? (Val.isNegative() ? -1 : 1) : 0, E);
10704   }
10705 
10706   case Builtin::BI__builtin_isinf: {
10707     APFloat Val(0.0);
10708     return EvaluateFloat(E->getArg(0), Val, Info) &&
10709            Success(Val.isInfinity() ? 1 : 0, E);
10710   }
10711 
10712   case Builtin::BI__builtin_isfinite: {
10713     APFloat Val(0.0);
10714     return EvaluateFloat(E->getArg(0), Val, Info) &&
10715            Success(Val.isFinite() ? 1 : 0, E);
10716   }
10717 
10718   case Builtin::BI__builtin_isnan: {
10719     APFloat Val(0.0);
10720     return EvaluateFloat(E->getArg(0), Val, Info) &&
10721            Success(Val.isNaN() ? 1 : 0, E);
10722   }
10723 
10724   case Builtin::BI__builtin_isnormal: {
10725     APFloat Val(0.0);
10726     return EvaluateFloat(E->getArg(0), Val, Info) &&
10727            Success(Val.isNormal() ? 1 : 0, E);
10728   }
10729 
10730   case Builtin::BI__builtin_parity:
10731   case Builtin::BI__builtin_parityl:
10732   case Builtin::BI__builtin_parityll: {
10733     APSInt Val;
10734     if (!EvaluateInteger(E->getArg(0), Val, Info))
10735       return false;
10736 
10737     return Success(Val.countPopulation() % 2, E);
10738   }
10739 
10740   case Builtin::BI__builtin_popcount:
10741   case Builtin::BI__builtin_popcountl:
10742   case Builtin::BI__builtin_popcountll: {
10743     APSInt Val;
10744     if (!EvaluateInteger(E->getArg(0), Val, Info))
10745       return false;
10746 
10747     return Success(Val.countPopulation(), E);
10748   }
10749 
10750   case Builtin::BIstrlen:
10751   case Builtin::BIwcslen:
10752     // A call to strlen is not a constant expression.
10753     if (Info.getLangOpts().CPlusPlus11)
10754       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
10755         << /*isConstexpr*/0 << /*isConstructor*/0
10756         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
10757     else
10758       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
10759     LLVM_FALLTHROUGH;
10760   case Builtin::BI__builtin_strlen:
10761   case Builtin::BI__builtin_wcslen: {
10762     // As an extension, we support __builtin_strlen() as a constant expression,
10763     // and support folding strlen() to a constant.
10764     LValue String;
10765     if (!EvaluatePointer(E->getArg(0), String, Info))
10766       return false;
10767 
10768     QualType CharTy = E->getArg(0)->getType()->getPointeeType();
10769 
10770     // Fast path: if it's a string literal, search the string value.
10771     if (const StringLiteral *S = dyn_cast_or_null<StringLiteral>(
10772             String.getLValueBase().dyn_cast<const Expr *>())) {
10773       // The string literal may have embedded null characters. Find the first
10774       // one and truncate there.
10775       StringRef Str = S->getBytes();
10776       int64_t Off = String.Offset.getQuantity();
10777       if (Off >= 0 && (uint64_t)Off <= (uint64_t)Str.size() &&
10778           S->getCharByteWidth() == 1 &&
10779           // FIXME: Add fast-path for wchar_t too.
10780           Info.Ctx.hasSameUnqualifiedType(CharTy, Info.Ctx.CharTy)) {
10781         Str = Str.substr(Off);
10782 
10783         StringRef::size_type Pos = Str.find(0);
10784         if (Pos != StringRef::npos)
10785           Str = Str.substr(0, Pos);
10786 
10787         return Success(Str.size(), E);
10788       }
10789 
10790       // Fall through to slow path to issue appropriate diagnostic.
10791     }
10792 
10793     // Slow path: scan the bytes of the string looking for the terminating 0.
10794     for (uint64_t Strlen = 0; /**/; ++Strlen) {
10795       APValue Char;
10796       if (!handleLValueToRValueConversion(Info, E, CharTy, String, Char) ||
10797           !Char.isInt())
10798         return false;
10799       if (!Char.getInt())
10800         return Success(Strlen, E);
10801       if (!HandleLValueArrayAdjustment(Info, E, String, CharTy, 1))
10802         return false;
10803     }
10804   }
10805 
10806   case Builtin::BIstrcmp:
10807   case Builtin::BIwcscmp:
10808   case Builtin::BIstrncmp:
10809   case Builtin::BIwcsncmp:
10810   case Builtin::BImemcmp:
10811   case Builtin::BIbcmp:
10812   case Builtin::BIwmemcmp:
10813     // A call to strlen is not a constant expression.
10814     if (Info.getLangOpts().CPlusPlus11)
10815       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
10816         << /*isConstexpr*/0 << /*isConstructor*/0
10817         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
10818     else
10819       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
10820     LLVM_FALLTHROUGH;
10821   case Builtin::BI__builtin_strcmp:
10822   case Builtin::BI__builtin_wcscmp:
10823   case Builtin::BI__builtin_strncmp:
10824   case Builtin::BI__builtin_wcsncmp:
10825   case Builtin::BI__builtin_memcmp:
10826   case Builtin::BI__builtin_bcmp:
10827   case Builtin::BI__builtin_wmemcmp: {
10828     LValue String1, String2;
10829     if (!EvaluatePointer(E->getArg(0), String1, Info) ||
10830         !EvaluatePointer(E->getArg(1), String2, Info))
10831       return false;
10832 
10833     uint64_t MaxLength = uint64_t(-1);
10834     if (BuiltinOp != Builtin::BIstrcmp &&
10835         BuiltinOp != Builtin::BIwcscmp &&
10836         BuiltinOp != Builtin::BI__builtin_strcmp &&
10837         BuiltinOp != Builtin::BI__builtin_wcscmp) {
10838       APSInt N;
10839       if (!EvaluateInteger(E->getArg(2), N, Info))
10840         return false;
10841       MaxLength = N.getExtValue();
10842     }
10843 
10844     // Empty substrings compare equal by definition.
10845     if (MaxLength == 0u)
10846       return Success(0, E);
10847 
10848     if (!String1.checkNullPointerForFoldAccess(Info, E, AK_Read) ||
10849         !String2.checkNullPointerForFoldAccess(Info, E, AK_Read) ||
10850         String1.Designator.Invalid || String2.Designator.Invalid)
10851       return false;
10852 
10853     QualType CharTy1 = String1.Designator.getType(Info.Ctx);
10854     QualType CharTy2 = String2.Designator.getType(Info.Ctx);
10855 
10856     bool IsRawByte = BuiltinOp == Builtin::BImemcmp ||
10857                      BuiltinOp == Builtin::BIbcmp ||
10858                      BuiltinOp == Builtin::BI__builtin_memcmp ||
10859                      BuiltinOp == Builtin::BI__builtin_bcmp;
10860 
10861     assert(IsRawByte ||
10862            (Info.Ctx.hasSameUnqualifiedType(
10863                 CharTy1, E->getArg(0)->getType()->getPointeeType()) &&
10864             Info.Ctx.hasSameUnqualifiedType(CharTy1, CharTy2)));
10865 
10866     const auto &ReadCurElems = [&](APValue &Char1, APValue &Char2) {
10867       return handleLValueToRValueConversion(Info, E, CharTy1, String1, Char1) &&
10868              handleLValueToRValueConversion(Info, E, CharTy2, String2, Char2) &&
10869              Char1.isInt() && Char2.isInt();
10870     };
10871     const auto &AdvanceElems = [&] {
10872       return HandleLValueArrayAdjustment(Info, E, String1, CharTy1, 1) &&
10873              HandleLValueArrayAdjustment(Info, E, String2, CharTy2, 1);
10874     };
10875 
10876     if (IsRawByte) {
10877       uint64_t BytesRemaining = MaxLength;
10878       // Pointers to const void may point to objects of incomplete type.
10879       if (CharTy1->isIncompleteType()) {
10880         Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy1;
10881         return false;
10882       }
10883       if (CharTy2->isIncompleteType()) {
10884         Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy2;
10885         return false;
10886       }
10887       uint64_t CharTy1Width{Info.Ctx.getTypeSize(CharTy1)};
10888       CharUnits CharTy1Size = Info.Ctx.toCharUnitsFromBits(CharTy1Width);
10889       // Give up on comparing between elements with disparate widths.
10890       if (CharTy1Size != Info.Ctx.getTypeSizeInChars(CharTy2))
10891         return false;
10892       uint64_t BytesPerElement = CharTy1Size.getQuantity();
10893       assert(BytesRemaining && "BytesRemaining should not be zero: the "
10894                                "following loop considers at least one element");
10895       while (true) {
10896         APValue Char1, Char2;
10897         if (!ReadCurElems(Char1, Char2))
10898           return false;
10899         // We have compatible in-memory widths, but a possible type and
10900         // (for `bool`) internal representation mismatch.
10901         // Assuming two's complement representation, including 0 for `false` and
10902         // 1 for `true`, we can check an appropriate number of elements for
10903         // equality even if they are not byte-sized.
10904         APSInt Char1InMem = Char1.getInt().extOrTrunc(CharTy1Width);
10905         APSInt Char2InMem = Char2.getInt().extOrTrunc(CharTy1Width);
10906         if (Char1InMem.ne(Char2InMem)) {
10907           // If the elements are byte-sized, then we can produce a three-way
10908           // comparison result in a straightforward manner.
10909           if (BytesPerElement == 1u) {
10910             // memcmp always compares unsigned chars.
10911             return Success(Char1InMem.ult(Char2InMem) ? -1 : 1, E);
10912           }
10913           // The result is byte-order sensitive, and we have multibyte elements.
10914           // FIXME: We can compare the remaining bytes in the correct order.
10915           return false;
10916         }
10917         if (!AdvanceElems())
10918           return false;
10919         if (BytesRemaining <= BytesPerElement)
10920           break;
10921         BytesRemaining -= BytesPerElement;
10922       }
10923       // Enough elements are equal to account for the memcmp limit.
10924       return Success(0, E);
10925     }
10926 
10927     bool StopAtNull =
10928         (BuiltinOp != Builtin::BImemcmp && BuiltinOp != Builtin::BIbcmp &&
10929          BuiltinOp != Builtin::BIwmemcmp &&
10930          BuiltinOp != Builtin::BI__builtin_memcmp &&
10931          BuiltinOp != Builtin::BI__builtin_bcmp &&
10932          BuiltinOp != Builtin::BI__builtin_wmemcmp);
10933     bool IsWide = BuiltinOp == Builtin::BIwcscmp ||
10934                   BuiltinOp == Builtin::BIwcsncmp ||
10935                   BuiltinOp == Builtin::BIwmemcmp ||
10936                   BuiltinOp == Builtin::BI__builtin_wcscmp ||
10937                   BuiltinOp == Builtin::BI__builtin_wcsncmp ||
10938                   BuiltinOp == Builtin::BI__builtin_wmemcmp;
10939 
10940     for (; MaxLength; --MaxLength) {
10941       APValue Char1, Char2;
10942       if (!ReadCurElems(Char1, Char2))
10943         return false;
10944       if (Char1.getInt() != Char2.getInt()) {
10945         if (IsWide) // wmemcmp compares with wchar_t signedness.
10946           return Success(Char1.getInt() < Char2.getInt() ? -1 : 1, E);
10947         // memcmp always compares unsigned chars.
10948         return Success(Char1.getInt().ult(Char2.getInt()) ? -1 : 1, E);
10949       }
10950       if (StopAtNull && !Char1.getInt())
10951         return Success(0, E);
10952       assert(!(StopAtNull && !Char2.getInt()));
10953       if (!AdvanceElems())
10954         return false;
10955     }
10956     // We hit the strncmp / memcmp limit.
10957     return Success(0, E);
10958   }
10959 
10960   case Builtin::BI__atomic_always_lock_free:
10961   case Builtin::BI__atomic_is_lock_free:
10962   case Builtin::BI__c11_atomic_is_lock_free: {
10963     APSInt SizeVal;
10964     if (!EvaluateInteger(E->getArg(0), SizeVal, Info))
10965       return false;
10966 
10967     // For __atomic_is_lock_free(sizeof(_Atomic(T))), if the size is a power
10968     // of two less than the maximum inline atomic width, we know it is
10969     // lock-free.  If the size isn't a power of two, or greater than the
10970     // maximum alignment where we promote atomics, we know it is not lock-free
10971     // (at least not in the sense of atomic_is_lock_free).  Otherwise,
10972     // the answer can only be determined at runtime; for example, 16-byte
10973     // atomics have lock-free implementations on some, but not all,
10974     // x86-64 processors.
10975 
10976     // Check power-of-two.
10977     CharUnits Size = CharUnits::fromQuantity(SizeVal.getZExtValue());
10978     if (Size.isPowerOfTwo()) {
10979       // Check against inlining width.
10980       unsigned InlineWidthBits =
10981           Info.Ctx.getTargetInfo().getMaxAtomicInlineWidth();
10982       if (Size <= Info.Ctx.toCharUnitsFromBits(InlineWidthBits)) {
10983         if (BuiltinOp == Builtin::BI__c11_atomic_is_lock_free ||
10984             Size == CharUnits::One() ||
10985             E->getArg(1)->isNullPointerConstant(Info.Ctx,
10986                                                 Expr::NPC_NeverValueDependent))
10987           // OK, we will inline appropriately-aligned operations of this size,
10988           // and _Atomic(T) is appropriately-aligned.
10989           return Success(1, E);
10990 
10991         QualType PointeeType = E->getArg(1)->IgnoreImpCasts()->getType()->
10992           castAs<PointerType>()->getPointeeType();
10993         if (!PointeeType->isIncompleteType() &&
10994             Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) {
10995           // OK, we will inline operations on this object.
10996           return Success(1, E);
10997         }
10998       }
10999     }
11000 
11001     return BuiltinOp == Builtin::BI__atomic_always_lock_free ?
11002         Success(0, E) : Error(E);
11003   }
11004   case Builtin::BIomp_is_initial_device:
11005     // We can decide statically which value the runtime would return if called.
11006     return Success(Info.getLangOpts().OpenMPIsDevice ? 0 : 1, E);
11007   case Builtin::BI__builtin_add_overflow:
11008   case Builtin::BI__builtin_sub_overflow:
11009   case Builtin::BI__builtin_mul_overflow:
11010   case Builtin::BI__builtin_sadd_overflow:
11011   case Builtin::BI__builtin_uadd_overflow:
11012   case Builtin::BI__builtin_uaddl_overflow:
11013   case Builtin::BI__builtin_uaddll_overflow:
11014   case Builtin::BI__builtin_usub_overflow:
11015   case Builtin::BI__builtin_usubl_overflow:
11016   case Builtin::BI__builtin_usubll_overflow:
11017   case Builtin::BI__builtin_umul_overflow:
11018   case Builtin::BI__builtin_umull_overflow:
11019   case Builtin::BI__builtin_umulll_overflow:
11020   case Builtin::BI__builtin_saddl_overflow:
11021   case Builtin::BI__builtin_saddll_overflow:
11022   case Builtin::BI__builtin_ssub_overflow:
11023   case Builtin::BI__builtin_ssubl_overflow:
11024   case Builtin::BI__builtin_ssubll_overflow:
11025   case Builtin::BI__builtin_smul_overflow:
11026   case Builtin::BI__builtin_smull_overflow:
11027   case Builtin::BI__builtin_smulll_overflow: {
11028     LValue ResultLValue;
11029     APSInt LHS, RHS;
11030 
11031     QualType ResultType = E->getArg(2)->getType()->getPointeeType();
11032     if (!EvaluateInteger(E->getArg(0), LHS, Info) ||
11033         !EvaluateInteger(E->getArg(1), RHS, Info) ||
11034         !EvaluatePointer(E->getArg(2), ResultLValue, Info))
11035       return false;
11036 
11037     APSInt Result;
11038     bool DidOverflow = false;
11039 
11040     // If the types don't have to match, enlarge all 3 to the largest of them.
11041     if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
11042         BuiltinOp == Builtin::BI__builtin_sub_overflow ||
11043         BuiltinOp == Builtin::BI__builtin_mul_overflow) {
11044       bool IsSigned = LHS.isSigned() || RHS.isSigned() ||
11045                       ResultType->isSignedIntegerOrEnumerationType();
11046       bool AllSigned = LHS.isSigned() && RHS.isSigned() &&
11047                       ResultType->isSignedIntegerOrEnumerationType();
11048       uint64_t LHSSize = LHS.getBitWidth();
11049       uint64_t RHSSize = RHS.getBitWidth();
11050       uint64_t ResultSize = Info.Ctx.getTypeSize(ResultType);
11051       uint64_t MaxBits = std::max(std::max(LHSSize, RHSSize), ResultSize);
11052 
11053       // Add an additional bit if the signedness isn't uniformly agreed to. We
11054       // could do this ONLY if there is a signed and an unsigned that both have
11055       // MaxBits, but the code to check that is pretty nasty.  The issue will be
11056       // caught in the shrink-to-result later anyway.
11057       if (IsSigned && !AllSigned)
11058         ++MaxBits;
11059 
11060       LHS = APSInt(LHS.extOrTrunc(MaxBits), !IsSigned);
11061       RHS = APSInt(RHS.extOrTrunc(MaxBits), !IsSigned);
11062       Result = APSInt(MaxBits, !IsSigned);
11063     }
11064 
11065     // Find largest int.
11066     switch (BuiltinOp) {
11067     default:
11068       llvm_unreachable("Invalid value for BuiltinOp");
11069     case Builtin::BI__builtin_add_overflow:
11070     case Builtin::BI__builtin_sadd_overflow:
11071     case Builtin::BI__builtin_saddl_overflow:
11072     case Builtin::BI__builtin_saddll_overflow:
11073     case Builtin::BI__builtin_uadd_overflow:
11074     case Builtin::BI__builtin_uaddl_overflow:
11075     case Builtin::BI__builtin_uaddll_overflow:
11076       Result = LHS.isSigned() ? LHS.sadd_ov(RHS, DidOverflow)
11077                               : LHS.uadd_ov(RHS, DidOverflow);
11078       break;
11079     case Builtin::BI__builtin_sub_overflow:
11080     case Builtin::BI__builtin_ssub_overflow:
11081     case Builtin::BI__builtin_ssubl_overflow:
11082     case Builtin::BI__builtin_ssubll_overflow:
11083     case Builtin::BI__builtin_usub_overflow:
11084     case Builtin::BI__builtin_usubl_overflow:
11085     case Builtin::BI__builtin_usubll_overflow:
11086       Result = LHS.isSigned() ? LHS.ssub_ov(RHS, DidOverflow)
11087                               : LHS.usub_ov(RHS, DidOverflow);
11088       break;
11089     case Builtin::BI__builtin_mul_overflow:
11090     case Builtin::BI__builtin_smul_overflow:
11091     case Builtin::BI__builtin_smull_overflow:
11092     case Builtin::BI__builtin_smulll_overflow:
11093     case Builtin::BI__builtin_umul_overflow:
11094     case Builtin::BI__builtin_umull_overflow:
11095     case Builtin::BI__builtin_umulll_overflow:
11096       Result = LHS.isSigned() ? LHS.smul_ov(RHS, DidOverflow)
11097                               : LHS.umul_ov(RHS, DidOverflow);
11098       break;
11099     }
11100 
11101     // In the case where multiple sizes are allowed, truncate and see if
11102     // the values are the same.
11103     if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
11104         BuiltinOp == Builtin::BI__builtin_sub_overflow ||
11105         BuiltinOp == Builtin::BI__builtin_mul_overflow) {
11106       // APSInt doesn't have a TruncOrSelf, so we use extOrTrunc instead,
11107       // since it will give us the behavior of a TruncOrSelf in the case where
11108       // its parameter <= its size.  We previously set Result to be at least the
11109       // type-size of the result, so getTypeSize(ResultType) <= Result.BitWidth
11110       // will work exactly like TruncOrSelf.
11111       APSInt Temp = Result.extOrTrunc(Info.Ctx.getTypeSize(ResultType));
11112       Temp.setIsSigned(ResultType->isSignedIntegerOrEnumerationType());
11113 
11114       if (!APSInt::isSameValue(Temp, Result))
11115         DidOverflow = true;
11116       Result = Temp;
11117     }
11118 
11119     APValue APV{Result};
11120     if (!handleAssignment(Info, E, ResultLValue, ResultType, APV))
11121       return false;
11122     return Success(DidOverflow, E);
11123   }
11124   }
11125 }
11126 
11127 /// Determine whether this is a pointer past the end of the complete
11128 /// object referred to by the lvalue.
11129 static bool isOnePastTheEndOfCompleteObject(const ASTContext &Ctx,
11130                                             const LValue &LV) {
11131   // A null pointer can be viewed as being "past the end" but we don't
11132   // choose to look at it that way here.
11133   if (!LV.getLValueBase())
11134     return false;
11135 
11136   // If the designator is valid and refers to a subobject, we're not pointing
11137   // past the end.
11138   if (!LV.getLValueDesignator().Invalid &&
11139       !LV.getLValueDesignator().isOnePastTheEnd())
11140     return false;
11141 
11142   // A pointer to an incomplete type might be past-the-end if the type's size is
11143   // zero.  We cannot tell because the type is incomplete.
11144   QualType Ty = getType(LV.getLValueBase());
11145   if (Ty->isIncompleteType())
11146     return true;
11147 
11148   // We're a past-the-end pointer if we point to the byte after the object,
11149   // no matter what our type or path is.
11150   auto Size = Ctx.getTypeSizeInChars(Ty);
11151   return LV.getLValueOffset() == Size;
11152 }
11153 
11154 namespace {
11155 
11156 /// Data recursive integer evaluator of certain binary operators.
11157 ///
11158 /// We use a data recursive algorithm for binary operators so that we are able
11159 /// to handle extreme cases of chained binary operators without causing stack
11160 /// overflow.
11161 class DataRecursiveIntBinOpEvaluator {
11162   struct EvalResult {
11163     APValue Val;
11164     bool Failed;
11165 
11166     EvalResult() : Failed(false) { }
11167 
11168     void swap(EvalResult &RHS) {
11169       Val.swap(RHS.Val);
11170       Failed = RHS.Failed;
11171       RHS.Failed = false;
11172     }
11173   };
11174 
11175   struct Job {
11176     const Expr *E;
11177     EvalResult LHSResult; // meaningful only for binary operator expression.
11178     enum { AnyExprKind, BinOpKind, BinOpVisitedLHSKind } Kind;
11179 
11180     Job() = default;
11181     Job(Job &&) = default;
11182 
11183     void startSpeculativeEval(EvalInfo &Info) {
11184       SpecEvalRAII = SpeculativeEvaluationRAII(Info);
11185     }
11186 
11187   private:
11188     SpeculativeEvaluationRAII SpecEvalRAII;
11189   };
11190 
11191   SmallVector<Job, 16> Queue;
11192 
11193   IntExprEvaluator &IntEval;
11194   EvalInfo &Info;
11195   APValue &FinalResult;
11196 
11197 public:
11198   DataRecursiveIntBinOpEvaluator(IntExprEvaluator &IntEval, APValue &Result)
11199     : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { }
11200 
11201   /// True if \param E is a binary operator that we are going to handle
11202   /// data recursively.
11203   /// We handle binary operators that are comma, logical, or that have operands
11204   /// with integral or enumeration type.
11205   static bool shouldEnqueue(const BinaryOperator *E) {
11206     return E->getOpcode() == BO_Comma || E->isLogicalOp() ||
11207            (E->isRValue() && E->getType()->isIntegralOrEnumerationType() &&
11208             E->getLHS()->getType()->isIntegralOrEnumerationType() &&
11209             E->getRHS()->getType()->isIntegralOrEnumerationType());
11210   }
11211 
11212   bool Traverse(const BinaryOperator *E) {
11213     enqueue(E);
11214     EvalResult PrevResult;
11215     while (!Queue.empty())
11216       process(PrevResult);
11217 
11218     if (PrevResult.Failed) return false;
11219 
11220     FinalResult.swap(PrevResult.Val);
11221     return true;
11222   }
11223 
11224 private:
11225   bool Success(uint64_t Value, const Expr *E, APValue &Result) {
11226     return IntEval.Success(Value, E, Result);
11227   }
11228   bool Success(const APSInt &Value, const Expr *E, APValue &Result) {
11229     return IntEval.Success(Value, E, Result);
11230   }
11231   bool Error(const Expr *E) {
11232     return IntEval.Error(E);
11233   }
11234   bool Error(const Expr *E, diag::kind D) {
11235     return IntEval.Error(E, D);
11236   }
11237 
11238   OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
11239     return Info.CCEDiag(E, D);
11240   }
11241 
11242   // Returns true if visiting the RHS is necessary, false otherwise.
11243   bool VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
11244                          bool &SuppressRHSDiags);
11245 
11246   bool VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
11247                   const BinaryOperator *E, APValue &Result);
11248 
11249   void EvaluateExpr(const Expr *E, EvalResult &Result) {
11250     Result.Failed = !Evaluate(Result.Val, Info, E);
11251     if (Result.Failed)
11252       Result.Val = APValue();
11253   }
11254 
11255   void process(EvalResult &Result);
11256 
11257   void enqueue(const Expr *E) {
11258     E = E->IgnoreParens();
11259     Queue.resize(Queue.size()+1);
11260     Queue.back().E = E;
11261     Queue.back().Kind = Job::AnyExprKind;
11262   }
11263 };
11264 
11265 }
11266 
11267 bool DataRecursiveIntBinOpEvaluator::
11268        VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
11269                          bool &SuppressRHSDiags) {
11270   if (E->getOpcode() == BO_Comma) {
11271     // Ignore LHS but note if we could not evaluate it.
11272     if (LHSResult.Failed)
11273       return Info.noteSideEffect();
11274     return true;
11275   }
11276 
11277   if (E->isLogicalOp()) {
11278     bool LHSAsBool;
11279     if (!LHSResult.Failed && HandleConversionToBool(LHSResult.Val, LHSAsBool)) {
11280       // We were able to evaluate the LHS, see if we can get away with not
11281       // evaluating the RHS: 0 && X -> 0, 1 || X -> 1
11282       if (LHSAsBool == (E->getOpcode() == BO_LOr)) {
11283         Success(LHSAsBool, E, LHSResult.Val);
11284         return false; // Ignore RHS
11285       }
11286     } else {
11287       LHSResult.Failed = true;
11288 
11289       // Since we weren't able to evaluate the left hand side, it
11290       // might have had side effects.
11291       if (!Info.noteSideEffect())
11292         return false;
11293 
11294       // We can't evaluate the LHS; however, sometimes the result
11295       // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
11296       // Don't ignore RHS and suppress diagnostics from this arm.
11297       SuppressRHSDiags = true;
11298     }
11299 
11300     return true;
11301   }
11302 
11303   assert(E->getLHS()->getType()->isIntegralOrEnumerationType() &&
11304          E->getRHS()->getType()->isIntegralOrEnumerationType());
11305 
11306   if (LHSResult.Failed && !Info.noteFailure())
11307     return false; // Ignore RHS;
11308 
11309   return true;
11310 }
11311 
11312 static void addOrSubLValueAsInteger(APValue &LVal, const APSInt &Index,
11313                                     bool IsSub) {
11314   // Compute the new offset in the appropriate width, wrapping at 64 bits.
11315   // FIXME: When compiling for a 32-bit target, we should use 32-bit
11316   // offsets.
11317   assert(!LVal.hasLValuePath() && "have designator for integer lvalue");
11318   CharUnits &Offset = LVal.getLValueOffset();
11319   uint64_t Offset64 = Offset.getQuantity();
11320   uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
11321   Offset = CharUnits::fromQuantity(IsSub ? Offset64 - Index64
11322                                          : Offset64 + Index64);
11323 }
11324 
11325 bool DataRecursiveIntBinOpEvaluator::
11326        VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
11327                   const BinaryOperator *E, APValue &Result) {
11328   if (E->getOpcode() == BO_Comma) {
11329     if (RHSResult.Failed)
11330       return false;
11331     Result = RHSResult.Val;
11332     return true;
11333   }
11334 
11335   if (E->isLogicalOp()) {
11336     bool lhsResult, rhsResult;
11337     bool LHSIsOK = HandleConversionToBool(LHSResult.Val, lhsResult);
11338     bool RHSIsOK = HandleConversionToBool(RHSResult.Val, rhsResult);
11339 
11340     if (LHSIsOK) {
11341       if (RHSIsOK) {
11342         if (E->getOpcode() == BO_LOr)
11343           return Success(lhsResult || rhsResult, E, Result);
11344         else
11345           return Success(lhsResult && rhsResult, E, Result);
11346       }
11347     } else {
11348       if (RHSIsOK) {
11349         // We can't evaluate the LHS; however, sometimes the result
11350         // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
11351         if (rhsResult == (E->getOpcode() == BO_LOr))
11352           return Success(rhsResult, E, Result);
11353       }
11354     }
11355 
11356     return false;
11357   }
11358 
11359   assert(E->getLHS()->getType()->isIntegralOrEnumerationType() &&
11360          E->getRHS()->getType()->isIntegralOrEnumerationType());
11361 
11362   if (LHSResult.Failed || RHSResult.Failed)
11363     return false;
11364 
11365   const APValue &LHSVal = LHSResult.Val;
11366   const APValue &RHSVal = RHSResult.Val;
11367 
11368   // Handle cases like (unsigned long)&a + 4.
11369   if (E->isAdditiveOp() && LHSVal.isLValue() && RHSVal.isInt()) {
11370     Result = LHSVal;
11371     addOrSubLValueAsInteger(Result, RHSVal.getInt(), E->getOpcode() == BO_Sub);
11372     return true;
11373   }
11374 
11375   // Handle cases like 4 + (unsigned long)&a
11376   if (E->getOpcode() == BO_Add &&
11377       RHSVal.isLValue() && LHSVal.isInt()) {
11378     Result = RHSVal;
11379     addOrSubLValueAsInteger(Result, LHSVal.getInt(), /*IsSub*/false);
11380     return true;
11381   }
11382 
11383   if (E->getOpcode() == BO_Sub && LHSVal.isLValue() && RHSVal.isLValue()) {
11384     // Handle (intptr_t)&&A - (intptr_t)&&B.
11385     if (!LHSVal.getLValueOffset().isZero() ||
11386         !RHSVal.getLValueOffset().isZero())
11387       return false;
11388     const Expr *LHSExpr = LHSVal.getLValueBase().dyn_cast<const Expr*>();
11389     const Expr *RHSExpr = RHSVal.getLValueBase().dyn_cast<const Expr*>();
11390     if (!LHSExpr || !RHSExpr)
11391       return false;
11392     const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
11393     const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
11394     if (!LHSAddrExpr || !RHSAddrExpr)
11395       return false;
11396     // Make sure both labels come from the same function.
11397     if (LHSAddrExpr->getLabel()->getDeclContext() !=
11398         RHSAddrExpr->getLabel()->getDeclContext())
11399       return false;
11400     Result = APValue(LHSAddrExpr, RHSAddrExpr);
11401     return true;
11402   }
11403 
11404   // All the remaining cases expect both operands to be an integer
11405   if (!LHSVal.isInt() || !RHSVal.isInt())
11406     return Error(E);
11407 
11408   // Set up the width and signedness manually, in case it can't be deduced
11409   // from the operation we're performing.
11410   // FIXME: Don't do this in the cases where we can deduce it.
11411   APSInt Value(Info.Ctx.getIntWidth(E->getType()),
11412                E->getType()->isUnsignedIntegerOrEnumerationType());
11413   if (!handleIntIntBinOp(Info, E, LHSVal.getInt(), E->getOpcode(),
11414                          RHSVal.getInt(), Value))
11415     return false;
11416   return Success(Value, E, Result);
11417 }
11418 
11419 void DataRecursiveIntBinOpEvaluator::process(EvalResult &Result) {
11420   Job &job = Queue.back();
11421 
11422   switch (job.Kind) {
11423     case Job::AnyExprKind: {
11424       if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(job.E)) {
11425         if (shouldEnqueue(Bop)) {
11426           job.Kind = Job::BinOpKind;
11427           enqueue(Bop->getLHS());
11428           return;
11429         }
11430       }
11431 
11432       EvaluateExpr(job.E, Result);
11433       Queue.pop_back();
11434       return;
11435     }
11436 
11437     case Job::BinOpKind: {
11438       const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
11439       bool SuppressRHSDiags = false;
11440       if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) {
11441         Queue.pop_back();
11442         return;
11443       }
11444       if (SuppressRHSDiags)
11445         job.startSpeculativeEval(Info);
11446       job.LHSResult.swap(Result);
11447       job.Kind = Job::BinOpVisitedLHSKind;
11448       enqueue(Bop->getRHS());
11449       return;
11450     }
11451 
11452     case Job::BinOpVisitedLHSKind: {
11453       const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
11454       EvalResult RHS;
11455       RHS.swap(Result);
11456       Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val);
11457       Queue.pop_back();
11458       return;
11459     }
11460   }
11461 
11462   llvm_unreachable("Invalid Job::Kind!");
11463 }
11464 
11465 namespace {
11466 /// Used when we determine that we should fail, but can keep evaluating prior to
11467 /// noting that we had a failure.
11468 class DelayedNoteFailureRAII {
11469   EvalInfo &Info;
11470   bool NoteFailure;
11471 
11472 public:
11473   DelayedNoteFailureRAII(EvalInfo &Info, bool NoteFailure = true)
11474       : Info(Info), NoteFailure(NoteFailure) {}
11475   ~DelayedNoteFailureRAII() {
11476     if (NoteFailure) {
11477       bool ContinueAfterFailure = Info.noteFailure();
11478       (void)ContinueAfterFailure;
11479       assert(ContinueAfterFailure &&
11480              "Shouldn't have kept evaluating on failure.");
11481     }
11482   }
11483 };
11484 }
11485 
11486 template <class SuccessCB, class AfterCB>
11487 static bool
11488 EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E,
11489                                  SuccessCB &&Success, AfterCB &&DoAfter) {
11490   assert(E->isComparisonOp() && "expected comparison operator");
11491   assert((E->getOpcode() == BO_Cmp ||
11492           E->getType()->isIntegralOrEnumerationType()) &&
11493          "unsupported binary expression evaluation");
11494   auto Error = [&](const Expr *E) {
11495     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
11496     return false;
11497   };
11498 
11499   using CCR = ComparisonCategoryResult;
11500   bool IsRelational = E->isRelationalOp();
11501   bool IsEquality = E->isEqualityOp();
11502   if (E->getOpcode() == BO_Cmp) {
11503     const ComparisonCategoryInfo &CmpInfo =
11504         Info.Ctx.CompCategories.getInfoForType(E->getType());
11505     IsRelational = CmpInfo.isOrdered();
11506     IsEquality = CmpInfo.isEquality();
11507   }
11508 
11509   QualType LHSTy = E->getLHS()->getType();
11510   QualType RHSTy = E->getRHS()->getType();
11511 
11512   if (LHSTy->isIntegralOrEnumerationType() &&
11513       RHSTy->isIntegralOrEnumerationType()) {
11514     APSInt LHS, RHS;
11515     bool LHSOK = EvaluateInteger(E->getLHS(), LHS, Info);
11516     if (!LHSOK && !Info.noteFailure())
11517       return false;
11518     if (!EvaluateInteger(E->getRHS(), RHS, Info) || !LHSOK)
11519       return false;
11520     if (LHS < RHS)
11521       return Success(CCR::Less, E);
11522     if (LHS > RHS)
11523       return Success(CCR::Greater, E);
11524     return Success(CCR::Equal, E);
11525   }
11526 
11527   if (LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) {
11528     APFixedPoint LHSFX(Info.Ctx.getFixedPointSemantics(LHSTy));
11529     APFixedPoint RHSFX(Info.Ctx.getFixedPointSemantics(RHSTy));
11530 
11531     bool LHSOK = EvaluateFixedPointOrInteger(E->getLHS(), LHSFX, Info);
11532     if (!LHSOK && !Info.noteFailure())
11533       return false;
11534     if (!EvaluateFixedPointOrInteger(E->getRHS(), RHSFX, Info) || !LHSOK)
11535       return false;
11536     if (LHSFX < RHSFX)
11537       return Success(CCR::Less, E);
11538     if (LHSFX > RHSFX)
11539       return Success(CCR::Greater, E);
11540     return Success(CCR::Equal, E);
11541   }
11542 
11543   if (LHSTy->isAnyComplexType() || RHSTy->isAnyComplexType()) {
11544     ComplexValue LHS, RHS;
11545     bool LHSOK;
11546     if (E->isAssignmentOp()) {
11547       LValue LV;
11548       EvaluateLValue(E->getLHS(), LV, Info);
11549       LHSOK = false;
11550     } else if (LHSTy->isRealFloatingType()) {
11551       LHSOK = EvaluateFloat(E->getLHS(), LHS.FloatReal, Info);
11552       if (LHSOK) {
11553         LHS.makeComplexFloat();
11554         LHS.FloatImag = APFloat(LHS.FloatReal.getSemantics());
11555       }
11556     } else {
11557       LHSOK = EvaluateComplex(E->getLHS(), LHS, Info);
11558     }
11559     if (!LHSOK && !Info.noteFailure())
11560       return false;
11561 
11562     if (E->getRHS()->getType()->isRealFloatingType()) {
11563       if (!EvaluateFloat(E->getRHS(), RHS.FloatReal, Info) || !LHSOK)
11564         return false;
11565       RHS.makeComplexFloat();
11566       RHS.FloatImag = APFloat(RHS.FloatReal.getSemantics());
11567     } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
11568       return false;
11569 
11570     if (LHS.isComplexFloat()) {
11571       APFloat::cmpResult CR_r =
11572         LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal());
11573       APFloat::cmpResult CR_i =
11574         LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag());
11575       bool IsEqual = CR_r == APFloat::cmpEqual && CR_i == APFloat::cmpEqual;
11576       return Success(IsEqual ? CCR::Equal : CCR::Nonequal, E);
11577     } else {
11578       assert(IsEquality && "invalid complex comparison");
11579       bool IsEqual = LHS.getComplexIntReal() == RHS.getComplexIntReal() &&
11580                      LHS.getComplexIntImag() == RHS.getComplexIntImag();
11581       return Success(IsEqual ? CCR::Equal : CCR::Nonequal, E);
11582     }
11583   }
11584 
11585   if (LHSTy->isRealFloatingType() &&
11586       RHSTy->isRealFloatingType()) {
11587     APFloat RHS(0.0), LHS(0.0);
11588 
11589     bool LHSOK = EvaluateFloat(E->getRHS(), RHS, Info);
11590     if (!LHSOK && !Info.noteFailure())
11591       return false;
11592 
11593     if (!EvaluateFloat(E->getLHS(), LHS, Info) || !LHSOK)
11594       return false;
11595 
11596     assert(E->isComparisonOp() && "Invalid binary operator!");
11597     auto GetCmpRes = [&]() {
11598       switch (LHS.compare(RHS)) {
11599       case APFloat::cmpEqual:
11600         return CCR::Equal;
11601       case APFloat::cmpLessThan:
11602         return CCR::Less;
11603       case APFloat::cmpGreaterThan:
11604         return CCR::Greater;
11605       case APFloat::cmpUnordered:
11606         return CCR::Unordered;
11607       }
11608       llvm_unreachable("Unrecognised APFloat::cmpResult enum");
11609     };
11610     return Success(GetCmpRes(), E);
11611   }
11612 
11613   if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
11614     LValue LHSValue, RHSValue;
11615 
11616     bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info);
11617     if (!LHSOK && !Info.noteFailure())
11618       return false;
11619 
11620     if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK)
11621       return false;
11622 
11623     // Reject differing bases from the normal codepath; we special-case
11624     // comparisons to null.
11625     if (!HasSameBase(LHSValue, RHSValue)) {
11626       // Inequalities and subtractions between unrelated pointers have
11627       // unspecified or undefined behavior.
11628       if (!IsEquality)
11629         return Error(E);
11630       // A constant address may compare equal to the address of a symbol.
11631       // The one exception is that address of an object cannot compare equal
11632       // to a null pointer constant.
11633       if ((!LHSValue.Base && !LHSValue.Offset.isZero()) ||
11634           (!RHSValue.Base && !RHSValue.Offset.isZero()))
11635         return Error(E);
11636       // It's implementation-defined whether distinct literals will have
11637       // distinct addresses. In clang, the result of such a comparison is
11638       // unspecified, so it is not a constant expression. However, we do know
11639       // that the address of a literal will be non-null.
11640       if ((IsLiteralLValue(LHSValue) || IsLiteralLValue(RHSValue)) &&
11641           LHSValue.Base && RHSValue.Base)
11642         return Error(E);
11643       // We can't tell whether weak symbols will end up pointing to the same
11644       // object.
11645       if (IsWeakLValue(LHSValue) || IsWeakLValue(RHSValue))
11646         return Error(E);
11647       // We can't compare the address of the start of one object with the
11648       // past-the-end address of another object, per C++ DR1652.
11649       if ((LHSValue.Base && LHSValue.Offset.isZero() &&
11650            isOnePastTheEndOfCompleteObject(Info.Ctx, RHSValue)) ||
11651           (RHSValue.Base && RHSValue.Offset.isZero() &&
11652            isOnePastTheEndOfCompleteObject(Info.Ctx, LHSValue)))
11653         return Error(E);
11654       // We can't tell whether an object is at the same address as another
11655       // zero sized object.
11656       if ((RHSValue.Base && isZeroSized(LHSValue)) ||
11657           (LHSValue.Base && isZeroSized(RHSValue)))
11658         return Error(E);
11659       return Success(CCR::Nonequal, E);
11660     }
11661 
11662     const CharUnits &LHSOffset = LHSValue.getLValueOffset();
11663     const CharUnits &RHSOffset = RHSValue.getLValueOffset();
11664 
11665     SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
11666     SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
11667 
11668     // C++11 [expr.rel]p3:
11669     //   Pointers to void (after pointer conversions) can be compared, with a
11670     //   result defined as follows: If both pointers represent the same
11671     //   address or are both the null pointer value, the result is true if the
11672     //   operator is <= or >= and false otherwise; otherwise the result is
11673     //   unspecified.
11674     // We interpret this as applying to pointers to *cv* void.
11675     if (LHSTy->isVoidPointerType() && LHSOffset != RHSOffset && IsRelational)
11676       Info.CCEDiag(E, diag::note_constexpr_void_comparison);
11677 
11678     // C++11 [expr.rel]p2:
11679     // - If two pointers point to non-static data members of the same object,
11680     //   or to subobjects or array elements fo such members, recursively, the
11681     //   pointer to the later declared member compares greater provided the
11682     //   two members have the same access control and provided their class is
11683     //   not a union.
11684     //   [...]
11685     // - Otherwise pointer comparisons are unspecified.
11686     if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && IsRelational) {
11687       bool WasArrayIndex;
11688       unsigned Mismatch = FindDesignatorMismatch(
11689           getType(LHSValue.Base), LHSDesignator, RHSDesignator, WasArrayIndex);
11690       // At the point where the designators diverge, the comparison has a
11691       // specified value if:
11692       //  - we are comparing array indices
11693       //  - we are comparing fields of a union, or fields with the same access
11694       // Otherwise, the result is unspecified and thus the comparison is not a
11695       // constant expression.
11696       if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() &&
11697           Mismatch < RHSDesignator.Entries.size()) {
11698         const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]);
11699         const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]);
11700         if (!LF && !RF)
11701           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes);
11702         else if (!LF)
11703           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
11704               << getAsBaseClass(LHSDesignator.Entries[Mismatch])
11705               << RF->getParent() << RF;
11706         else if (!RF)
11707           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
11708               << getAsBaseClass(RHSDesignator.Entries[Mismatch])
11709               << LF->getParent() << LF;
11710         else if (!LF->getParent()->isUnion() &&
11711                  LF->getAccess() != RF->getAccess())
11712           Info.CCEDiag(E,
11713                        diag::note_constexpr_pointer_comparison_differing_access)
11714               << LF << LF->getAccess() << RF << RF->getAccess()
11715               << LF->getParent();
11716       }
11717     }
11718 
11719     // The comparison here must be unsigned, and performed with the same
11720     // width as the pointer.
11721     unsigned PtrSize = Info.Ctx.getTypeSize(LHSTy);
11722     uint64_t CompareLHS = LHSOffset.getQuantity();
11723     uint64_t CompareRHS = RHSOffset.getQuantity();
11724     assert(PtrSize <= 64 && "Unexpected pointer width");
11725     uint64_t Mask = ~0ULL >> (64 - PtrSize);
11726     CompareLHS &= Mask;
11727     CompareRHS &= Mask;
11728 
11729     // If there is a base and this is a relational operator, we can only
11730     // compare pointers within the object in question; otherwise, the result
11731     // depends on where the object is located in memory.
11732     if (!LHSValue.Base.isNull() && IsRelational) {
11733       QualType BaseTy = getType(LHSValue.Base);
11734       if (BaseTy->isIncompleteType())
11735         return Error(E);
11736       CharUnits Size = Info.Ctx.getTypeSizeInChars(BaseTy);
11737       uint64_t OffsetLimit = Size.getQuantity();
11738       if (CompareLHS > OffsetLimit || CompareRHS > OffsetLimit)
11739         return Error(E);
11740     }
11741 
11742     if (CompareLHS < CompareRHS)
11743       return Success(CCR::Less, E);
11744     if (CompareLHS > CompareRHS)
11745       return Success(CCR::Greater, E);
11746     return Success(CCR::Equal, E);
11747   }
11748 
11749   if (LHSTy->isMemberPointerType()) {
11750     assert(IsEquality && "unexpected member pointer operation");
11751     assert(RHSTy->isMemberPointerType() && "invalid comparison");
11752 
11753     MemberPtr LHSValue, RHSValue;
11754 
11755     bool LHSOK = EvaluateMemberPointer(E->getLHS(), LHSValue, Info);
11756     if (!LHSOK && !Info.noteFailure())
11757       return false;
11758 
11759     if (!EvaluateMemberPointer(E->getRHS(), RHSValue, Info) || !LHSOK)
11760       return false;
11761 
11762     // C++11 [expr.eq]p2:
11763     //   If both operands are null, they compare equal. Otherwise if only one is
11764     //   null, they compare unequal.
11765     if (!LHSValue.getDecl() || !RHSValue.getDecl()) {
11766       bool Equal = !LHSValue.getDecl() && !RHSValue.getDecl();
11767       return Success(Equal ? CCR::Equal : CCR::Nonequal, E);
11768     }
11769 
11770     //   Otherwise if either is a pointer to a virtual member function, the
11771     //   result is unspecified.
11772     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl()))
11773       if (MD->isVirtual())
11774         Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
11775     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl()))
11776       if (MD->isVirtual())
11777         Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
11778 
11779     //   Otherwise they compare equal if and only if they would refer to the
11780     //   same member of the same most derived object or the same subobject if
11781     //   they were dereferenced with a hypothetical object of the associated
11782     //   class type.
11783     bool Equal = LHSValue == RHSValue;
11784     return Success(Equal ? CCR::Equal : CCR::Nonequal, E);
11785   }
11786 
11787   if (LHSTy->isNullPtrType()) {
11788     assert(E->isComparisonOp() && "unexpected nullptr operation");
11789     assert(RHSTy->isNullPtrType() && "missing pointer conversion");
11790     // C++11 [expr.rel]p4, [expr.eq]p3: If two operands of type std::nullptr_t
11791     // are compared, the result is true of the operator is <=, >= or ==, and
11792     // false otherwise.
11793     return Success(CCR::Equal, E);
11794   }
11795 
11796   return DoAfter();
11797 }
11798 
11799 bool RecordExprEvaluator::VisitBinCmp(const BinaryOperator *E) {
11800   if (!CheckLiteralType(Info, E))
11801     return false;
11802 
11803   auto OnSuccess = [&](ComparisonCategoryResult ResKind,
11804                        const BinaryOperator *E) {
11805     // Evaluation succeeded. Lookup the information for the comparison category
11806     // type and fetch the VarDecl for the result.
11807     const ComparisonCategoryInfo &CmpInfo =
11808         Info.Ctx.CompCategories.getInfoForType(E->getType());
11809     const VarDecl *VD =
11810         CmpInfo.getValueInfo(CmpInfo.makeWeakResult(ResKind))->VD;
11811     // Check and evaluate the result as a constant expression.
11812     LValue LV;
11813     LV.set(VD);
11814     if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
11815       return false;
11816     return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result);
11817   };
11818   return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
11819     return ExprEvaluatorBaseTy::VisitBinCmp(E);
11820   });
11821 }
11822 
11823 bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
11824   // We don't call noteFailure immediately because the assignment happens after
11825   // we evaluate LHS and RHS.
11826   if (!Info.keepEvaluatingAfterFailure() && E->isAssignmentOp())
11827     return Error(E);
11828 
11829   DelayedNoteFailureRAII MaybeNoteFailureLater(Info, E->isAssignmentOp());
11830   if (DataRecursiveIntBinOpEvaluator::shouldEnqueue(E))
11831     return DataRecursiveIntBinOpEvaluator(*this, Result).Traverse(E);
11832 
11833   assert((!E->getLHS()->getType()->isIntegralOrEnumerationType() ||
11834           !E->getRHS()->getType()->isIntegralOrEnumerationType()) &&
11835          "DataRecursiveIntBinOpEvaluator should have handled integral types");
11836 
11837   if (E->isComparisonOp()) {
11838     // Evaluate builtin binary comparisons by evaluating them as C++2a three-way
11839     // comparisons and then translating the result.
11840     auto OnSuccess = [&](ComparisonCategoryResult ResKind,
11841                          const BinaryOperator *E) {
11842       using CCR = ComparisonCategoryResult;
11843       bool IsEqual   = ResKind == CCR::Equal,
11844            IsLess    = ResKind == CCR::Less,
11845            IsGreater = ResKind == CCR::Greater;
11846       auto Op = E->getOpcode();
11847       switch (Op) {
11848       default:
11849         llvm_unreachable("unsupported binary operator");
11850       case BO_EQ:
11851       case BO_NE:
11852         return Success(IsEqual == (Op == BO_EQ), E);
11853       case BO_LT: return Success(IsLess, E);
11854       case BO_GT: return Success(IsGreater, E);
11855       case BO_LE: return Success(IsEqual || IsLess, E);
11856       case BO_GE: return Success(IsEqual || IsGreater, E);
11857       }
11858     };
11859     return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
11860       return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
11861     });
11862   }
11863 
11864   QualType LHSTy = E->getLHS()->getType();
11865   QualType RHSTy = E->getRHS()->getType();
11866 
11867   if (LHSTy->isPointerType() && RHSTy->isPointerType() &&
11868       E->getOpcode() == BO_Sub) {
11869     LValue LHSValue, RHSValue;
11870 
11871     bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info);
11872     if (!LHSOK && !Info.noteFailure())
11873       return false;
11874 
11875     if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK)
11876       return false;
11877 
11878     // Reject differing bases from the normal codepath; we special-case
11879     // comparisons to null.
11880     if (!HasSameBase(LHSValue, RHSValue)) {
11881       // Handle &&A - &&B.
11882       if (!LHSValue.Offset.isZero() || !RHSValue.Offset.isZero())
11883         return Error(E);
11884       const Expr *LHSExpr = LHSValue.Base.dyn_cast<const Expr *>();
11885       const Expr *RHSExpr = RHSValue.Base.dyn_cast<const Expr *>();
11886       if (!LHSExpr || !RHSExpr)
11887         return Error(E);
11888       const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
11889       const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
11890       if (!LHSAddrExpr || !RHSAddrExpr)
11891         return Error(E);
11892       // Make sure both labels come from the same function.
11893       if (LHSAddrExpr->getLabel()->getDeclContext() !=
11894           RHSAddrExpr->getLabel()->getDeclContext())
11895         return Error(E);
11896       return Success(APValue(LHSAddrExpr, RHSAddrExpr), E);
11897     }
11898     const CharUnits &LHSOffset = LHSValue.getLValueOffset();
11899     const CharUnits &RHSOffset = RHSValue.getLValueOffset();
11900 
11901     SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
11902     SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
11903 
11904     // C++11 [expr.add]p6:
11905     //   Unless both pointers point to elements of the same array object, or
11906     //   one past the last element of the array object, the behavior is
11907     //   undefined.
11908     if (!LHSDesignator.Invalid && !RHSDesignator.Invalid &&
11909         !AreElementsOfSameArray(getType(LHSValue.Base), LHSDesignator,
11910                                 RHSDesignator))
11911       Info.CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array);
11912 
11913     QualType Type = E->getLHS()->getType();
11914     QualType ElementType = Type->castAs<PointerType>()->getPointeeType();
11915 
11916     CharUnits ElementSize;
11917     if (!HandleSizeof(Info, E->getExprLoc(), ElementType, ElementSize))
11918       return false;
11919 
11920     // As an extension, a type may have zero size (empty struct or union in
11921     // C, array of zero length). Pointer subtraction in such cases has
11922     // undefined behavior, so is not constant.
11923     if (ElementSize.isZero()) {
11924       Info.FFDiag(E, diag::note_constexpr_pointer_subtraction_zero_size)
11925           << ElementType;
11926       return false;
11927     }
11928 
11929     // FIXME: LLVM and GCC both compute LHSOffset - RHSOffset at runtime,
11930     // and produce incorrect results when it overflows. Such behavior
11931     // appears to be non-conforming, but is common, so perhaps we should
11932     // assume the standard intended for such cases to be undefined behavior
11933     // and check for them.
11934 
11935     // Compute (LHSOffset - RHSOffset) / Size carefully, checking for
11936     // overflow in the final conversion to ptrdiff_t.
11937     APSInt LHS(llvm::APInt(65, (int64_t)LHSOffset.getQuantity(), true), false);
11938     APSInt RHS(llvm::APInt(65, (int64_t)RHSOffset.getQuantity(), true), false);
11939     APSInt ElemSize(llvm::APInt(65, (int64_t)ElementSize.getQuantity(), true),
11940                     false);
11941     APSInt TrueResult = (LHS - RHS) / ElemSize;
11942     APSInt Result = TrueResult.trunc(Info.Ctx.getIntWidth(E->getType()));
11943 
11944     if (Result.extend(65) != TrueResult &&
11945         !HandleOverflow(Info, E, TrueResult, E->getType()))
11946       return false;
11947     return Success(Result, E);
11948   }
11949 
11950   return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
11951 }
11952 
11953 /// VisitUnaryExprOrTypeTraitExpr - Evaluate a sizeof, alignof or vec_step with
11954 /// a result as the expression's type.
11955 bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr(
11956                                     const UnaryExprOrTypeTraitExpr *E) {
11957   switch(E->getKind()) {
11958   case UETT_PreferredAlignOf:
11959   case UETT_AlignOf: {
11960     if (E->isArgumentType())
11961       return Success(GetAlignOfType(Info, E->getArgumentType(), E->getKind()),
11962                      E);
11963     else
11964       return Success(GetAlignOfExpr(Info, E->getArgumentExpr(), E->getKind()),
11965                      E);
11966   }
11967 
11968   case UETT_VecStep: {
11969     QualType Ty = E->getTypeOfArgument();
11970 
11971     if (Ty->isVectorType()) {
11972       unsigned n = Ty->castAs<VectorType>()->getNumElements();
11973 
11974       // The vec_step built-in functions that take a 3-component
11975       // vector return 4. (OpenCL 1.1 spec 6.11.12)
11976       if (n == 3)
11977         n = 4;
11978 
11979       return Success(n, E);
11980     } else
11981       return Success(1, E);
11982   }
11983 
11984   case UETT_SizeOf: {
11985     QualType SrcTy = E->getTypeOfArgument();
11986     // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
11987     //   the result is the size of the referenced type."
11988     if (const ReferenceType *Ref = SrcTy->getAs<ReferenceType>())
11989       SrcTy = Ref->getPointeeType();
11990 
11991     CharUnits Sizeof;
11992     if (!HandleSizeof(Info, E->getExprLoc(), SrcTy, Sizeof))
11993       return false;
11994     return Success(Sizeof, E);
11995   }
11996   case UETT_OpenMPRequiredSimdAlign:
11997     assert(E->isArgumentType());
11998     return Success(
11999         Info.Ctx.toCharUnitsFromBits(
12000                     Info.Ctx.getOpenMPDefaultSimdAlign(E->getArgumentType()))
12001             .getQuantity(),
12002         E);
12003   }
12004 
12005   llvm_unreachable("unknown expr/type trait");
12006 }
12007 
12008 bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *OOE) {
12009   CharUnits Result;
12010   unsigned n = OOE->getNumComponents();
12011   if (n == 0)
12012     return Error(OOE);
12013   QualType CurrentType = OOE->getTypeSourceInfo()->getType();
12014   for (unsigned i = 0; i != n; ++i) {
12015     OffsetOfNode ON = OOE->getComponent(i);
12016     switch (ON.getKind()) {
12017     case OffsetOfNode::Array: {
12018       const Expr *Idx = OOE->getIndexExpr(ON.getArrayExprIndex());
12019       APSInt IdxResult;
12020       if (!EvaluateInteger(Idx, IdxResult, Info))
12021         return false;
12022       const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType);
12023       if (!AT)
12024         return Error(OOE);
12025       CurrentType = AT->getElementType();
12026       CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType);
12027       Result += IdxResult.getSExtValue() * ElementSize;
12028       break;
12029     }
12030 
12031     case OffsetOfNode::Field: {
12032       FieldDecl *MemberDecl = ON.getField();
12033       const RecordType *RT = CurrentType->getAs<RecordType>();
12034       if (!RT)
12035         return Error(OOE);
12036       RecordDecl *RD = RT->getDecl();
12037       if (RD->isInvalidDecl()) return false;
12038       const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
12039       unsigned i = MemberDecl->getFieldIndex();
12040       assert(i < RL.getFieldCount() && "offsetof field in wrong type");
12041       Result += Info.Ctx.toCharUnitsFromBits(RL.getFieldOffset(i));
12042       CurrentType = MemberDecl->getType().getNonReferenceType();
12043       break;
12044     }
12045 
12046     case OffsetOfNode::Identifier:
12047       llvm_unreachable("dependent __builtin_offsetof");
12048 
12049     case OffsetOfNode::Base: {
12050       CXXBaseSpecifier *BaseSpec = ON.getBase();
12051       if (BaseSpec->isVirtual())
12052         return Error(OOE);
12053 
12054       // Find the layout of the class whose base we are looking into.
12055       const RecordType *RT = CurrentType->getAs<RecordType>();
12056       if (!RT)
12057         return Error(OOE);
12058       RecordDecl *RD = RT->getDecl();
12059       if (RD->isInvalidDecl()) return false;
12060       const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
12061 
12062       // Find the base class itself.
12063       CurrentType = BaseSpec->getType();
12064       const RecordType *BaseRT = CurrentType->getAs<RecordType>();
12065       if (!BaseRT)
12066         return Error(OOE);
12067 
12068       // Add the offset to the base.
12069       Result += RL.getBaseClassOffset(cast<CXXRecordDecl>(BaseRT->getDecl()));
12070       break;
12071     }
12072     }
12073   }
12074   return Success(Result, OOE);
12075 }
12076 
12077 bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
12078   switch (E->getOpcode()) {
12079   default:
12080     // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
12081     // See C99 6.6p3.
12082     return Error(E);
12083   case UO_Extension:
12084     // FIXME: Should extension allow i-c-e extension expressions in its scope?
12085     // If so, we could clear the diagnostic ID.
12086     return Visit(E->getSubExpr());
12087   case UO_Plus:
12088     // The result is just the value.
12089     return Visit(E->getSubExpr());
12090   case UO_Minus: {
12091     if (!Visit(E->getSubExpr()))
12092       return false;
12093     if (!Result.isInt()) return Error(E);
12094     const APSInt &Value = Result.getInt();
12095     if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow() &&
12096         !HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1),
12097                         E->getType()))
12098       return false;
12099     return Success(-Value, E);
12100   }
12101   case UO_Not: {
12102     if (!Visit(E->getSubExpr()))
12103       return false;
12104     if (!Result.isInt()) return Error(E);
12105     return Success(~Result.getInt(), E);
12106   }
12107   case UO_LNot: {
12108     bool bres;
12109     if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
12110       return false;
12111     return Success(!bres, E);
12112   }
12113   }
12114 }
12115 
12116 /// HandleCast - This is used to evaluate implicit or explicit casts where the
12117 /// result type is integer.
12118 bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
12119   const Expr *SubExpr = E->getSubExpr();
12120   QualType DestType = E->getType();
12121   QualType SrcType = SubExpr->getType();
12122 
12123   switch (E->getCastKind()) {
12124   case CK_BaseToDerived:
12125   case CK_DerivedToBase:
12126   case CK_UncheckedDerivedToBase:
12127   case CK_Dynamic:
12128   case CK_ToUnion:
12129   case CK_ArrayToPointerDecay:
12130   case CK_FunctionToPointerDecay:
12131   case CK_NullToPointer:
12132   case CK_NullToMemberPointer:
12133   case CK_BaseToDerivedMemberPointer:
12134   case CK_DerivedToBaseMemberPointer:
12135   case CK_ReinterpretMemberPointer:
12136   case CK_ConstructorConversion:
12137   case CK_IntegralToPointer:
12138   case CK_ToVoid:
12139   case CK_VectorSplat:
12140   case CK_IntegralToFloating:
12141   case CK_FloatingCast:
12142   case CK_CPointerToObjCPointerCast:
12143   case CK_BlockPointerToObjCPointerCast:
12144   case CK_AnyPointerToBlockPointerCast:
12145   case CK_ObjCObjectLValueCast:
12146   case CK_FloatingRealToComplex:
12147   case CK_FloatingComplexToReal:
12148   case CK_FloatingComplexCast:
12149   case CK_FloatingComplexToIntegralComplex:
12150   case CK_IntegralRealToComplex:
12151   case CK_IntegralComplexCast:
12152   case CK_IntegralComplexToFloatingComplex:
12153   case CK_BuiltinFnToFnPtr:
12154   case CK_ZeroToOCLOpaqueType:
12155   case CK_NonAtomicToAtomic:
12156   case CK_AddressSpaceConversion:
12157   case CK_IntToOCLSampler:
12158   case CK_FixedPointCast:
12159   case CK_IntegralToFixedPoint:
12160     llvm_unreachable("invalid cast kind for integral value");
12161 
12162   case CK_BitCast:
12163   case CK_Dependent:
12164   case CK_LValueBitCast:
12165   case CK_ARCProduceObject:
12166   case CK_ARCConsumeObject:
12167   case CK_ARCReclaimReturnedObject:
12168   case CK_ARCExtendBlockObject:
12169   case CK_CopyAndAutoreleaseBlockObject:
12170     return Error(E);
12171 
12172   case CK_UserDefinedConversion:
12173   case CK_LValueToRValue:
12174   case CK_AtomicToNonAtomic:
12175   case CK_NoOp:
12176   case CK_LValueToRValueBitCast:
12177     return ExprEvaluatorBaseTy::VisitCastExpr(E);
12178 
12179   case CK_MemberPointerToBoolean:
12180   case CK_PointerToBoolean:
12181   case CK_IntegralToBoolean:
12182   case CK_FloatingToBoolean:
12183   case CK_BooleanToSignedIntegral:
12184   case CK_FloatingComplexToBoolean:
12185   case CK_IntegralComplexToBoolean: {
12186     bool BoolResult;
12187     if (!EvaluateAsBooleanCondition(SubExpr, BoolResult, Info))
12188       return false;
12189     uint64_t IntResult = BoolResult;
12190     if (BoolResult && E->getCastKind() == CK_BooleanToSignedIntegral)
12191       IntResult = (uint64_t)-1;
12192     return Success(IntResult, E);
12193   }
12194 
12195   case CK_FixedPointToIntegral: {
12196     APFixedPoint Src(Info.Ctx.getFixedPointSemantics(SrcType));
12197     if (!EvaluateFixedPoint(SubExpr, Src, Info))
12198       return false;
12199     bool Overflowed;
12200     llvm::APSInt Result = Src.convertToInt(
12201         Info.Ctx.getIntWidth(DestType),
12202         DestType->isSignedIntegerOrEnumerationType(), &Overflowed);
12203     if (Overflowed && !HandleOverflow(Info, E, Result, DestType))
12204       return false;
12205     return Success(Result, E);
12206   }
12207 
12208   case CK_FixedPointToBoolean: {
12209     // Unsigned padding does not affect this.
12210     APValue Val;
12211     if (!Evaluate(Val, Info, SubExpr))
12212       return false;
12213     return Success(Val.getFixedPoint().getBoolValue(), E);
12214   }
12215 
12216   case CK_IntegralCast: {
12217     if (!Visit(SubExpr))
12218       return false;
12219 
12220     if (!Result.isInt()) {
12221       // Allow casts of address-of-label differences if they are no-ops
12222       // or narrowing.  (The narrowing case isn't actually guaranteed to
12223       // be constant-evaluatable except in some narrow cases which are hard
12224       // to detect here.  We let it through on the assumption the user knows
12225       // what they are doing.)
12226       if (Result.isAddrLabelDiff())
12227         return Info.Ctx.getTypeSize(DestType) <= Info.Ctx.getTypeSize(SrcType);
12228       // Only allow casts of lvalues if they are lossless.
12229       return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
12230     }
12231 
12232     return Success(HandleIntToIntCast(Info, E, DestType, SrcType,
12233                                       Result.getInt()), E);
12234   }
12235 
12236   case CK_PointerToIntegral: {
12237     CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
12238 
12239     LValue LV;
12240     if (!EvaluatePointer(SubExpr, LV, Info))
12241       return false;
12242 
12243     if (LV.getLValueBase()) {
12244       // Only allow based lvalue casts if they are lossless.
12245       // FIXME: Allow a larger integer size than the pointer size, and allow
12246       // narrowing back down to pointer width in subsequent integral casts.
12247       // FIXME: Check integer type's active bits, not its type size.
12248       if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(SrcType))
12249         return Error(E);
12250 
12251       LV.Designator.setInvalid();
12252       LV.moveInto(Result);
12253       return true;
12254     }
12255 
12256     APSInt AsInt;
12257     APValue V;
12258     LV.moveInto(V);
12259     if (!V.toIntegralConstant(AsInt, SrcType, Info.Ctx))
12260       llvm_unreachable("Can't cast this!");
12261 
12262     return Success(HandleIntToIntCast(Info, E, DestType, SrcType, AsInt), E);
12263   }
12264 
12265   case CK_IntegralComplexToReal: {
12266     ComplexValue C;
12267     if (!EvaluateComplex(SubExpr, C, Info))
12268       return false;
12269     return Success(C.getComplexIntReal(), E);
12270   }
12271 
12272   case CK_FloatingToIntegral: {
12273     APFloat F(0.0);
12274     if (!EvaluateFloat(SubExpr, F, Info))
12275       return false;
12276 
12277     APSInt Value;
12278     if (!HandleFloatToIntCast(Info, E, SrcType, F, DestType, Value))
12279       return false;
12280     return Success(Value, E);
12281   }
12282   }
12283 
12284   llvm_unreachable("unknown cast resulting in integral value");
12285 }
12286 
12287 bool IntExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
12288   if (E->getSubExpr()->getType()->isAnyComplexType()) {
12289     ComplexValue LV;
12290     if (!EvaluateComplex(E->getSubExpr(), LV, Info))
12291       return false;
12292     if (!LV.isComplexInt())
12293       return Error(E);
12294     return Success(LV.getComplexIntReal(), E);
12295   }
12296 
12297   return Visit(E->getSubExpr());
12298 }
12299 
12300 bool IntExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
12301   if (E->getSubExpr()->getType()->isComplexIntegerType()) {
12302     ComplexValue LV;
12303     if (!EvaluateComplex(E->getSubExpr(), LV, Info))
12304       return false;
12305     if (!LV.isComplexInt())
12306       return Error(E);
12307     return Success(LV.getComplexIntImag(), E);
12308   }
12309 
12310   VisitIgnoredValue(E->getSubExpr());
12311   return Success(0, E);
12312 }
12313 
12314 bool IntExprEvaluator::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
12315   return Success(E->getPackLength(), E);
12316 }
12317 
12318 bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
12319   return Success(E->getValue(), E);
12320 }
12321 
12322 bool IntExprEvaluator::VisitConceptSpecializationExpr(
12323        const ConceptSpecializationExpr *E) {
12324   return Success(E->isSatisfied(), E);
12325 }
12326 
12327 
12328 bool FixedPointExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
12329   switch (E->getOpcode()) {
12330     default:
12331       // Invalid unary operators
12332       return Error(E);
12333     case UO_Plus:
12334       // The result is just the value.
12335       return Visit(E->getSubExpr());
12336     case UO_Minus: {
12337       if (!Visit(E->getSubExpr())) return false;
12338       if (!Result.isFixedPoint())
12339         return Error(E);
12340       bool Overflowed;
12341       APFixedPoint Negated = Result.getFixedPoint().negate(&Overflowed);
12342       if (Overflowed && !HandleOverflow(Info, E, Negated, E->getType()))
12343         return false;
12344       return Success(Negated, E);
12345     }
12346     case UO_LNot: {
12347       bool bres;
12348       if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
12349         return false;
12350       return Success(!bres, E);
12351     }
12352   }
12353 }
12354 
12355 bool FixedPointExprEvaluator::VisitCastExpr(const CastExpr *E) {
12356   const Expr *SubExpr = E->getSubExpr();
12357   QualType DestType = E->getType();
12358   assert(DestType->isFixedPointType() &&
12359          "Expected destination type to be a fixed point type");
12360   auto DestFXSema = Info.Ctx.getFixedPointSemantics(DestType);
12361 
12362   switch (E->getCastKind()) {
12363   case CK_FixedPointCast: {
12364     APFixedPoint Src(Info.Ctx.getFixedPointSemantics(SubExpr->getType()));
12365     if (!EvaluateFixedPoint(SubExpr, Src, Info))
12366       return false;
12367     bool Overflowed;
12368     APFixedPoint Result = Src.convert(DestFXSema, &Overflowed);
12369     if (Overflowed && !HandleOverflow(Info, E, Result, DestType))
12370       return false;
12371     return Success(Result, E);
12372   }
12373   case CK_IntegralToFixedPoint: {
12374     APSInt Src;
12375     if (!EvaluateInteger(SubExpr, Src, Info))
12376       return false;
12377 
12378     bool Overflowed;
12379     APFixedPoint IntResult = APFixedPoint::getFromIntValue(
12380         Src, Info.Ctx.getFixedPointSemantics(DestType), &Overflowed);
12381 
12382     if (Overflowed && !HandleOverflow(Info, E, IntResult, DestType))
12383       return false;
12384 
12385     return Success(IntResult, E);
12386   }
12387   case CK_NoOp:
12388   case CK_LValueToRValue:
12389     return ExprEvaluatorBaseTy::VisitCastExpr(E);
12390   default:
12391     return Error(E);
12392   }
12393 }
12394 
12395 bool FixedPointExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
12396   const Expr *LHS = E->getLHS();
12397   const Expr *RHS = E->getRHS();
12398   FixedPointSemantics ResultFXSema =
12399       Info.Ctx.getFixedPointSemantics(E->getType());
12400 
12401   APFixedPoint LHSFX(Info.Ctx.getFixedPointSemantics(LHS->getType()));
12402   if (!EvaluateFixedPointOrInteger(LHS, LHSFX, Info))
12403     return false;
12404   APFixedPoint RHSFX(Info.Ctx.getFixedPointSemantics(RHS->getType()));
12405   if (!EvaluateFixedPointOrInteger(RHS, RHSFX, Info))
12406     return false;
12407 
12408   switch (E->getOpcode()) {
12409   case BO_Add: {
12410     bool AddOverflow, ConversionOverflow;
12411     APFixedPoint Result = LHSFX.add(RHSFX, &AddOverflow)
12412                               .convert(ResultFXSema, &ConversionOverflow);
12413     if ((AddOverflow || ConversionOverflow) &&
12414         !HandleOverflow(Info, E, Result, E->getType()))
12415       return false;
12416     return Success(Result, E);
12417   }
12418   default:
12419     return false;
12420   }
12421   llvm_unreachable("Should've exited before this");
12422 }
12423 
12424 //===----------------------------------------------------------------------===//
12425 // Float Evaluation
12426 //===----------------------------------------------------------------------===//
12427 
12428 namespace {
12429 class FloatExprEvaluator
12430   : public ExprEvaluatorBase<FloatExprEvaluator> {
12431   APFloat &Result;
12432 public:
12433   FloatExprEvaluator(EvalInfo &info, APFloat &result)
12434     : ExprEvaluatorBaseTy(info), Result(result) {}
12435 
12436   bool Success(const APValue &V, const Expr *e) {
12437     Result = V.getFloat();
12438     return true;
12439   }
12440 
12441   bool ZeroInitialization(const Expr *E) {
12442     Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
12443     return true;
12444   }
12445 
12446   bool VisitCallExpr(const CallExpr *E);
12447 
12448   bool VisitUnaryOperator(const UnaryOperator *E);
12449   bool VisitBinaryOperator(const BinaryOperator *E);
12450   bool VisitFloatingLiteral(const FloatingLiteral *E);
12451   bool VisitCastExpr(const CastExpr *E);
12452 
12453   bool VisitUnaryReal(const UnaryOperator *E);
12454   bool VisitUnaryImag(const UnaryOperator *E);
12455 
12456   // FIXME: Missing: array subscript of vector, member of vector
12457 };
12458 } // end anonymous namespace
12459 
12460 static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
12461   assert(E->isRValue() && E->getType()->isRealFloatingType());
12462   return FloatExprEvaluator(Info, Result).Visit(E);
12463 }
12464 
12465 static bool TryEvaluateBuiltinNaN(const ASTContext &Context,
12466                                   QualType ResultTy,
12467                                   const Expr *Arg,
12468                                   bool SNaN,
12469                                   llvm::APFloat &Result) {
12470   const StringLiteral *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
12471   if (!S) return false;
12472 
12473   const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(ResultTy);
12474 
12475   llvm::APInt fill;
12476 
12477   // Treat empty strings as if they were zero.
12478   if (S->getString().empty())
12479     fill = llvm::APInt(32, 0);
12480   else if (S->getString().getAsInteger(0, fill))
12481     return false;
12482 
12483   if (Context.getTargetInfo().isNan2008()) {
12484     if (SNaN)
12485       Result = llvm::APFloat::getSNaN(Sem, false, &fill);
12486     else
12487       Result = llvm::APFloat::getQNaN(Sem, false, &fill);
12488   } else {
12489     // Prior to IEEE 754-2008, architectures were allowed to choose whether
12490     // the first bit of their significand was set for qNaN or sNaN. MIPS chose
12491     // a different encoding to what became a standard in 2008, and for pre-
12492     // 2008 revisions, MIPS interpreted sNaN-2008 as qNan and qNaN-2008 as
12493     // sNaN. This is now known as "legacy NaN" encoding.
12494     if (SNaN)
12495       Result = llvm::APFloat::getQNaN(Sem, false, &fill);
12496     else
12497       Result = llvm::APFloat::getSNaN(Sem, false, &fill);
12498   }
12499 
12500   return true;
12501 }
12502 
12503 bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) {
12504   switch (E->getBuiltinCallee()) {
12505   default:
12506     return ExprEvaluatorBaseTy::VisitCallExpr(E);
12507 
12508   case Builtin::BI__builtin_huge_val:
12509   case Builtin::BI__builtin_huge_valf:
12510   case Builtin::BI__builtin_huge_vall:
12511   case Builtin::BI__builtin_huge_valf128:
12512   case Builtin::BI__builtin_inf:
12513   case Builtin::BI__builtin_inff:
12514   case Builtin::BI__builtin_infl:
12515   case Builtin::BI__builtin_inff128: {
12516     const llvm::fltSemantics &Sem =
12517       Info.Ctx.getFloatTypeSemantics(E->getType());
12518     Result = llvm::APFloat::getInf(Sem);
12519     return true;
12520   }
12521 
12522   case Builtin::BI__builtin_nans:
12523   case Builtin::BI__builtin_nansf:
12524   case Builtin::BI__builtin_nansl:
12525   case Builtin::BI__builtin_nansf128:
12526     if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
12527                                true, Result))
12528       return Error(E);
12529     return true;
12530 
12531   case Builtin::BI__builtin_nan:
12532   case Builtin::BI__builtin_nanf:
12533   case Builtin::BI__builtin_nanl:
12534   case Builtin::BI__builtin_nanf128:
12535     // If this is __builtin_nan() turn this into a nan, otherwise we
12536     // can't constant fold it.
12537     if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
12538                                false, Result))
12539       return Error(E);
12540     return true;
12541 
12542   case Builtin::BI__builtin_fabs:
12543   case Builtin::BI__builtin_fabsf:
12544   case Builtin::BI__builtin_fabsl:
12545   case Builtin::BI__builtin_fabsf128:
12546     if (!EvaluateFloat(E->getArg(0), Result, Info))
12547       return false;
12548 
12549     if (Result.isNegative())
12550       Result.changeSign();
12551     return true;
12552 
12553   // FIXME: Builtin::BI__builtin_powi
12554   // FIXME: Builtin::BI__builtin_powif
12555   // FIXME: Builtin::BI__builtin_powil
12556 
12557   case Builtin::BI__builtin_copysign:
12558   case Builtin::BI__builtin_copysignf:
12559   case Builtin::BI__builtin_copysignl:
12560   case Builtin::BI__builtin_copysignf128: {
12561     APFloat RHS(0.);
12562     if (!EvaluateFloat(E->getArg(0), Result, Info) ||
12563         !EvaluateFloat(E->getArg(1), RHS, Info))
12564       return false;
12565     Result.copySign(RHS);
12566     return true;
12567   }
12568   }
12569 }
12570 
12571 bool FloatExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
12572   if (E->getSubExpr()->getType()->isAnyComplexType()) {
12573     ComplexValue CV;
12574     if (!EvaluateComplex(E->getSubExpr(), CV, Info))
12575       return false;
12576     Result = CV.FloatReal;
12577     return true;
12578   }
12579 
12580   return Visit(E->getSubExpr());
12581 }
12582 
12583 bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
12584   if (E->getSubExpr()->getType()->isAnyComplexType()) {
12585     ComplexValue CV;
12586     if (!EvaluateComplex(E->getSubExpr(), CV, Info))
12587       return false;
12588     Result = CV.FloatImag;
12589     return true;
12590   }
12591 
12592   VisitIgnoredValue(E->getSubExpr());
12593   const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType());
12594   Result = llvm::APFloat::getZero(Sem);
12595   return true;
12596 }
12597 
12598 bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
12599   switch (E->getOpcode()) {
12600   default: return Error(E);
12601   case UO_Plus:
12602     return EvaluateFloat(E->getSubExpr(), Result, Info);
12603   case UO_Minus:
12604     if (!EvaluateFloat(E->getSubExpr(), Result, Info))
12605       return false;
12606     Result.changeSign();
12607     return true;
12608   }
12609 }
12610 
12611 bool FloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
12612   if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
12613     return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
12614 
12615   APFloat RHS(0.0);
12616   bool LHSOK = EvaluateFloat(E->getLHS(), Result, Info);
12617   if (!LHSOK && !Info.noteFailure())
12618     return false;
12619   return EvaluateFloat(E->getRHS(), RHS, Info) && LHSOK &&
12620          handleFloatFloatBinOp(Info, E, Result, E->getOpcode(), RHS);
12621 }
12622 
12623 bool FloatExprEvaluator::VisitFloatingLiteral(const FloatingLiteral *E) {
12624   Result = E->getValue();
12625   return true;
12626 }
12627 
12628 bool FloatExprEvaluator::VisitCastExpr(const CastExpr *E) {
12629   const Expr* SubExpr = E->getSubExpr();
12630 
12631   switch (E->getCastKind()) {
12632   default:
12633     return ExprEvaluatorBaseTy::VisitCastExpr(E);
12634 
12635   case CK_IntegralToFloating: {
12636     APSInt IntResult;
12637     return EvaluateInteger(SubExpr, IntResult, Info) &&
12638            HandleIntToFloatCast(Info, E, SubExpr->getType(), IntResult,
12639                                 E->getType(), Result);
12640   }
12641 
12642   case CK_FloatingCast: {
12643     if (!Visit(SubExpr))
12644       return false;
12645     return HandleFloatToFloatCast(Info, E, SubExpr->getType(), E->getType(),
12646                                   Result);
12647   }
12648 
12649   case CK_FloatingComplexToReal: {
12650     ComplexValue V;
12651     if (!EvaluateComplex(SubExpr, V, Info))
12652       return false;
12653     Result = V.getComplexFloatReal();
12654     return true;
12655   }
12656   }
12657 }
12658 
12659 //===----------------------------------------------------------------------===//
12660 // Complex Evaluation (for float and integer)
12661 //===----------------------------------------------------------------------===//
12662 
12663 namespace {
12664 class ComplexExprEvaluator
12665   : public ExprEvaluatorBase<ComplexExprEvaluator> {
12666   ComplexValue &Result;
12667 
12668 public:
12669   ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result)
12670     : ExprEvaluatorBaseTy(info), Result(Result) {}
12671 
12672   bool Success(const APValue &V, const Expr *e) {
12673     Result.setFrom(V);
12674     return true;
12675   }
12676 
12677   bool ZeroInitialization(const Expr *E);
12678 
12679   //===--------------------------------------------------------------------===//
12680   //                            Visitor Methods
12681   //===--------------------------------------------------------------------===//
12682 
12683   bool VisitImaginaryLiteral(const ImaginaryLiteral *E);
12684   bool VisitCastExpr(const CastExpr *E);
12685   bool VisitBinaryOperator(const BinaryOperator *E);
12686   bool VisitUnaryOperator(const UnaryOperator *E);
12687   bool VisitInitListExpr(const InitListExpr *E);
12688 };
12689 } // end anonymous namespace
12690 
12691 static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
12692                             EvalInfo &Info) {
12693   assert(E->isRValue() && E->getType()->isAnyComplexType());
12694   return ComplexExprEvaluator(Info, Result).Visit(E);
12695 }
12696 
12697 bool ComplexExprEvaluator::ZeroInitialization(const Expr *E) {
12698   QualType ElemTy = E->getType()->castAs<ComplexType>()->getElementType();
12699   if (ElemTy->isRealFloatingType()) {
12700     Result.makeComplexFloat();
12701     APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy));
12702     Result.FloatReal = Zero;
12703     Result.FloatImag = Zero;
12704   } else {
12705     Result.makeComplexInt();
12706     APSInt Zero = Info.Ctx.MakeIntValue(0, ElemTy);
12707     Result.IntReal = Zero;
12708     Result.IntImag = Zero;
12709   }
12710   return true;
12711 }
12712 
12713 bool ComplexExprEvaluator::VisitImaginaryLiteral(const ImaginaryLiteral *E) {
12714   const Expr* SubExpr = E->getSubExpr();
12715 
12716   if (SubExpr->getType()->isRealFloatingType()) {
12717     Result.makeComplexFloat();
12718     APFloat &Imag = Result.FloatImag;
12719     if (!EvaluateFloat(SubExpr, Imag, Info))
12720       return false;
12721 
12722     Result.FloatReal = APFloat(Imag.getSemantics());
12723     return true;
12724   } else {
12725     assert(SubExpr->getType()->isIntegerType() &&
12726            "Unexpected imaginary literal.");
12727 
12728     Result.makeComplexInt();
12729     APSInt &Imag = Result.IntImag;
12730     if (!EvaluateInteger(SubExpr, Imag, Info))
12731       return false;
12732 
12733     Result.IntReal = APSInt(Imag.getBitWidth(), !Imag.isSigned());
12734     return true;
12735   }
12736 }
12737 
12738 bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
12739 
12740   switch (E->getCastKind()) {
12741   case CK_BitCast:
12742   case CK_BaseToDerived:
12743   case CK_DerivedToBase:
12744   case CK_UncheckedDerivedToBase:
12745   case CK_Dynamic:
12746   case CK_ToUnion:
12747   case CK_ArrayToPointerDecay:
12748   case CK_FunctionToPointerDecay:
12749   case CK_NullToPointer:
12750   case CK_NullToMemberPointer:
12751   case CK_BaseToDerivedMemberPointer:
12752   case CK_DerivedToBaseMemberPointer:
12753   case CK_MemberPointerToBoolean:
12754   case CK_ReinterpretMemberPointer:
12755   case CK_ConstructorConversion:
12756   case CK_IntegralToPointer:
12757   case CK_PointerToIntegral:
12758   case CK_PointerToBoolean:
12759   case CK_ToVoid:
12760   case CK_VectorSplat:
12761   case CK_IntegralCast:
12762   case CK_BooleanToSignedIntegral:
12763   case CK_IntegralToBoolean:
12764   case CK_IntegralToFloating:
12765   case CK_FloatingToIntegral:
12766   case CK_FloatingToBoolean:
12767   case CK_FloatingCast:
12768   case CK_CPointerToObjCPointerCast:
12769   case CK_BlockPointerToObjCPointerCast:
12770   case CK_AnyPointerToBlockPointerCast:
12771   case CK_ObjCObjectLValueCast:
12772   case CK_FloatingComplexToReal:
12773   case CK_FloatingComplexToBoolean:
12774   case CK_IntegralComplexToReal:
12775   case CK_IntegralComplexToBoolean:
12776   case CK_ARCProduceObject:
12777   case CK_ARCConsumeObject:
12778   case CK_ARCReclaimReturnedObject:
12779   case CK_ARCExtendBlockObject:
12780   case CK_CopyAndAutoreleaseBlockObject:
12781   case CK_BuiltinFnToFnPtr:
12782   case CK_ZeroToOCLOpaqueType:
12783   case CK_NonAtomicToAtomic:
12784   case CK_AddressSpaceConversion:
12785   case CK_IntToOCLSampler:
12786   case CK_FixedPointCast:
12787   case CK_FixedPointToBoolean:
12788   case CK_FixedPointToIntegral:
12789   case CK_IntegralToFixedPoint:
12790     llvm_unreachable("invalid cast kind for complex value");
12791 
12792   case CK_LValueToRValue:
12793   case CK_AtomicToNonAtomic:
12794   case CK_NoOp:
12795   case CK_LValueToRValueBitCast:
12796     return ExprEvaluatorBaseTy::VisitCastExpr(E);
12797 
12798   case CK_Dependent:
12799   case CK_LValueBitCast:
12800   case CK_UserDefinedConversion:
12801     return Error(E);
12802 
12803   case CK_FloatingRealToComplex: {
12804     APFloat &Real = Result.FloatReal;
12805     if (!EvaluateFloat(E->getSubExpr(), Real, Info))
12806       return false;
12807 
12808     Result.makeComplexFloat();
12809     Result.FloatImag = APFloat(Real.getSemantics());
12810     return true;
12811   }
12812 
12813   case CK_FloatingComplexCast: {
12814     if (!Visit(E->getSubExpr()))
12815       return false;
12816 
12817     QualType To = E->getType()->castAs<ComplexType>()->getElementType();
12818     QualType From
12819       = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
12820 
12821     return HandleFloatToFloatCast(Info, E, From, To, Result.FloatReal) &&
12822            HandleFloatToFloatCast(Info, E, From, To, Result.FloatImag);
12823   }
12824 
12825   case CK_FloatingComplexToIntegralComplex: {
12826     if (!Visit(E->getSubExpr()))
12827       return false;
12828 
12829     QualType To = E->getType()->castAs<ComplexType>()->getElementType();
12830     QualType From
12831       = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
12832     Result.makeComplexInt();
12833     return HandleFloatToIntCast(Info, E, From, Result.FloatReal,
12834                                 To, Result.IntReal) &&
12835            HandleFloatToIntCast(Info, E, From, Result.FloatImag,
12836                                 To, Result.IntImag);
12837   }
12838 
12839   case CK_IntegralRealToComplex: {
12840     APSInt &Real = Result.IntReal;
12841     if (!EvaluateInteger(E->getSubExpr(), Real, Info))
12842       return false;
12843 
12844     Result.makeComplexInt();
12845     Result.IntImag = APSInt(Real.getBitWidth(), !Real.isSigned());
12846     return true;
12847   }
12848 
12849   case CK_IntegralComplexCast: {
12850     if (!Visit(E->getSubExpr()))
12851       return false;
12852 
12853     QualType To = E->getType()->castAs<ComplexType>()->getElementType();
12854     QualType From
12855       = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
12856 
12857     Result.IntReal = HandleIntToIntCast(Info, E, To, From, Result.IntReal);
12858     Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag);
12859     return true;
12860   }
12861 
12862   case CK_IntegralComplexToFloatingComplex: {
12863     if (!Visit(E->getSubExpr()))
12864       return false;
12865 
12866     QualType To = E->getType()->castAs<ComplexType>()->getElementType();
12867     QualType From
12868       = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
12869     Result.makeComplexFloat();
12870     return HandleIntToFloatCast(Info, E, From, Result.IntReal,
12871                                 To, Result.FloatReal) &&
12872            HandleIntToFloatCast(Info, E, From, Result.IntImag,
12873                                 To, Result.FloatImag);
12874   }
12875   }
12876 
12877   llvm_unreachable("unknown cast resulting in complex value");
12878 }
12879 
12880 bool ComplexExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
12881   if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
12882     return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
12883 
12884   // Track whether the LHS or RHS is real at the type system level. When this is
12885   // the case we can simplify our evaluation strategy.
12886   bool LHSReal = false, RHSReal = false;
12887 
12888   bool LHSOK;
12889   if (E->getLHS()->getType()->isRealFloatingType()) {
12890     LHSReal = true;
12891     APFloat &Real = Result.FloatReal;
12892     LHSOK = EvaluateFloat(E->getLHS(), Real, Info);
12893     if (LHSOK) {
12894       Result.makeComplexFloat();
12895       Result.FloatImag = APFloat(Real.getSemantics());
12896     }
12897   } else {
12898     LHSOK = Visit(E->getLHS());
12899   }
12900   if (!LHSOK && !Info.noteFailure())
12901     return false;
12902 
12903   ComplexValue RHS;
12904   if (E->getRHS()->getType()->isRealFloatingType()) {
12905     RHSReal = true;
12906     APFloat &Real = RHS.FloatReal;
12907     if (!EvaluateFloat(E->getRHS(), Real, Info) || !LHSOK)
12908       return false;
12909     RHS.makeComplexFloat();
12910     RHS.FloatImag = APFloat(Real.getSemantics());
12911   } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
12912     return false;
12913 
12914   assert(!(LHSReal && RHSReal) &&
12915          "Cannot have both operands of a complex operation be real.");
12916   switch (E->getOpcode()) {
12917   default: return Error(E);
12918   case BO_Add:
12919     if (Result.isComplexFloat()) {
12920       Result.getComplexFloatReal().add(RHS.getComplexFloatReal(),
12921                                        APFloat::rmNearestTiesToEven);
12922       if (LHSReal)
12923         Result.getComplexFloatImag() = RHS.getComplexFloatImag();
12924       else if (!RHSReal)
12925         Result.getComplexFloatImag().add(RHS.getComplexFloatImag(),
12926                                          APFloat::rmNearestTiesToEven);
12927     } else {
12928       Result.getComplexIntReal() += RHS.getComplexIntReal();
12929       Result.getComplexIntImag() += RHS.getComplexIntImag();
12930     }
12931     break;
12932   case BO_Sub:
12933     if (Result.isComplexFloat()) {
12934       Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(),
12935                                             APFloat::rmNearestTiesToEven);
12936       if (LHSReal) {
12937         Result.getComplexFloatImag() = RHS.getComplexFloatImag();
12938         Result.getComplexFloatImag().changeSign();
12939       } else if (!RHSReal) {
12940         Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(),
12941                                               APFloat::rmNearestTiesToEven);
12942       }
12943     } else {
12944       Result.getComplexIntReal() -= RHS.getComplexIntReal();
12945       Result.getComplexIntImag() -= RHS.getComplexIntImag();
12946     }
12947     break;
12948   case BO_Mul:
12949     if (Result.isComplexFloat()) {
12950       // This is an implementation of complex multiplication according to the
12951       // constraints laid out in C11 Annex G. The implementation uses the
12952       // following naming scheme:
12953       //   (a + ib) * (c + id)
12954       ComplexValue LHS = Result;
12955       APFloat &A = LHS.getComplexFloatReal();
12956       APFloat &B = LHS.getComplexFloatImag();
12957       APFloat &C = RHS.getComplexFloatReal();
12958       APFloat &D = RHS.getComplexFloatImag();
12959       APFloat &ResR = Result.getComplexFloatReal();
12960       APFloat &ResI = Result.getComplexFloatImag();
12961       if (LHSReal) {
12962         assert(!RHSReal && "Cannot have two real operands for a complex op!");
12963         ResR = A * C;
12964         ResI = A * D;
12965       } else if (RHSReal) {
12966         ResR = C * A;
12967         ResI = C * B;
12968       } else {
12969         // In the fully general case, we need to handle NaNs and infinities
12970         // robustly.
12971         APFloat AC = A * C;
12972         APFloat BD = B * D;
12973         APFloat AD = A * D;
12974         APFloat BC = B * C;
12975         ResR = AC - BD;
12976         ResI = AD + BC;
12977         if (ResR.isNaN() && ResI.isNaN()) {
12978           bool Recalc = false;
12979           if (A.isInfinity() || B.isInfinity()) {
12980             A = APFloat::copySign(
12981                 APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
12982             B = APFloat::copySign(
12983                 APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
12984             if (C.isNaN())
12985               C = APFloat::copySign(APFloat(C.getSemantics()), C);
12986             if (D.isNaN())
12987               D = APFloat::copySign(APFloat(D.getSemantics()), D);
12988             Recalc = true;
12989           }
12990           if (C.isInfinity() || D.isInfinity()) {
12991             C = APFloat::copySign(
12992                 APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
12993             D = APFloat::copySign(
12994                 APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
12995             if (A.isNaN())
12996               A = APFloat::copySign(APFloat(A.getSemantics()), A);
12997             if (B.isNaN())
12998               B = APFloat::copySign(APFloat(B.getSemantics()), B);
12999             Recalc = true;
13000           }
13001           if (!Recalc && (AC.isInfinity() || BD.isInfinity() ||
13002                           AD.isInfinity() || BC.isInfinity())) {
13003             if (A.isNaN())
13004               A = APFloat::copySign(APFloat(A.getSemantics()), A);
13005             if (B.isNaN())
13006               B = APFloat::copySign(APFloat(B.getSemantics()), B);
13007             if (C.isNaN())
13008               C = APFloat::copySign(APFloat(C.getSemantics()), C);
13009             if (D.isNaN())
13010               D = APFloat::copySign(APFloat(D.getSemantics()), D);
13011             Recalc = true;
13012           }
13013           if (Recalc) {
13014             ResR = APFloat::getInf(A.getSemantics()) * (A * C - B * D);
13015             ResI = APFloat::getInf(A.getSemantics()) * (A * D + B * C);
13016           }
13017         }
13018       }
13019     } else {
13020       ComplexValue LHS = Result;
13021       Result.getComplexIntReal() =
13022         (LHS.getComplexIntReal() * RHS.getComplexIntReal() -
13023          LHS.getComplexIntImag() * RHS.getComplexIntImag());
13024       Result.getComplexIntImag() =
13025         (LHS.getComplexIntReal() * RHS.getComplexIntImag() +
13026          LHS.getComplexIntImag() * RHS.getComplexIntReal());
13027     }
13028     break;
13029   case BO_Div:
13030     if (Result.isComplexFloat()) {
13031       // This is an implementation of complex division according to the
13032       // constraints laid out in C11 Annex G. The implementation uses the
13033       // following naming scheme:
13034       //   (a + ib) / (c + id)
13035       ComplexValue LHS = Result;
13036       APFloat &A = LHS.getComplexFloatReal();
13037       APFloat &B = LHS.getComplexFloatImag();
13038       APFloat &C = RHS.getComplexFloatReal();
13039       APFloat &D = RHS.getComplexFloatImag();
13040       APFloat &ResR = Result.getComplexFloatReal();
13041       APFloat &ResI = Result.getComplexFloatImag();
13042       if (RHSReal) {
13043         ResR = A / C;
13044         ResI = B / C;
13045       } else {
13046         if (LHSReal) {
13047           // No real optimizations we can do here, stub out with zero.
13048           B = APFloat::getZero(A.getSemantics());
13049         }
13050         int DenomLogB = 0;
13051         APFloat MaxCD = maxnum(abs(C), abs(D));
13052         if (MaxCD.isFinite()) {
13053           DenomLogB = ilogb(MaxCD);
13054           C = scalbn(C, -DenomLogB, APFloat::rmNearestTiesToEven);
13055           D = scalbn(D, -DenomLogB, APFloat::rmNearestTiesToEven);
13056         }
13057         APFloat Denom = C * C + D * D;
13058         ResR = scalbn((A * C + B * D) / Denom, -DenomLogB,
13059                       APFloat::rmNearestTiesToEven);
13060         ResI = scalbn((B * C - A * D) / Denom, -DenomLogB,
13061                       APFloat::rmNearestTiesToEven);
13062         if (ResR.isNaN() && ResI.isNaN()) {
13063           if (Denom.isPosZero() && (!A.isNaN() || !B.isNaN())) {
13064             ResR = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * A;
13065             ResI = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * B;
13066           } else if ((A.isInfinity() || B.isInfinity()) && C.isFinite() &&
13067                      D.isFinite()) {
13068             A = APFloat::copySign(
13069                 APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
13070             B = APFloat::copySign(
13071                 APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
13072             ResR = APFloat::getInf(ResR.getSemantics()) * (A * C + B * D);
13073             ResI = APFloat::getInf(ResI.getSemantics()) * (B * C - A * D);
13074           } else if (MaxCD.isInfinity() && A.isFinite() && B.isFinite()) {
13075             C = APFloat::copySign(
13076                 APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
13077             D = APFloat::copySign(
13078                 APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
13079             ResR = APFloat::getZero(ResR.getSemantics()) * (A * C + B * D);
13080             ResI = APFloat::getZero(ResI.getSemantics()) * (B * C - A * D);
13081           }
13082         }
13083       }
13084     } else {
13085       if (RHS.getComplexIntReal() == 0 && RHS.getComplexIntImag() == 0)
13086         return Error(E, diag::note_expr_divide_by_zero);
13087 
13088       ComplexValue LHS = Result;
13089       APSInt Den = RHS.getComplexIntReal() * RHS.getComplexIntReal() +
13090         RHS.getComplexIntImag() * RHS.getComplexIntImag();
13091       Result.getComplexIntReal() =
13092         (LHS.getComplexIntReal() * RHS.getComplexIntReal() +
13093          LHS.getComplexIntImag() * RHS.getComplexIntImag()) / Den;
13094       Result.getComplexIntImag() =
13095         (LHS.getComplexIntImag() * RHS.getComplexIntReal() -
13096          LHS.getComplexIntReal() * RHS.getComplexIntImag()) / Den;
13097     }
13098     break;
13099   }
13100 
13101   return true;
13102 }
13103 
13104 bool ComplexExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
13105   // Get the operand value into 'Result'.
13106   if (!Visit(E->getSubExpr()))
13107     return false;
13108 
13109   switch (E->getOpcode()) {
13110   default:
13111     return Error(E);
13112   case UO_Extension:
13113     return true;
13114   case UO_Plus:
13115     // The result is always just the subexpr.
13116     return true;
13117   case UO_Minus:
13118     if (Result.isComplexFloat()) {
13119       Result.getComplexFloatReal().changeSign();
13120       Result.getComplexFloatImag().changeSign();
13121     }
13122     else {
13123       Result.getComplexIntReal() = -Result.getComplexIntReal();
13124       Result.getComplexIntImag() = -Result.getComplexIntImag();
13125     }
13126     return true;
13127   case UO_Not:
13128     if (Result.isComplexFloat())
13129       Result.getComplexFloatImag().changeSign();
13130     else
13131       Result.getComplexIntImag() = -Result.getComplexIntImag();
13132     return true;
13133   }
13134 }
13135 
13136 bool ComplexExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
13137   if (E->getNumInits() == 2) {
13138     if (E->getType()->isComplexType()) {
13139       Result.makeComplexFloat();
13140       if (!EvaluateFloat(E->getInit(0), Result.FloatReal, Info))
13141         return false;
13142       if (!EvaluateFloat(E->getInit(1), Result.FloatImag, Info))
13143         return false;
13144     } else {
13145       Result.makeComplexInt();
13146       if (!EvaluateInteger(E->getInit(0), Result.IntReal, Info))
13147         return false;
13148       if (!EvaluateInteger(E->getInit(1), Result.IntImag, Info))
13149         return false;
13150     }
13151     return true;
13152   }
13153   return ExprEvaluatorBaseTy::VisitInitListExpr(E);
13154 }
13155 
13156 //===----------------------------------------------------------------------===//
13157 // Atomic expression evaluation, essentially just handling the NonAtomicToAtomic
13158 // implicit conversion.
13159 //===----------------------------------------------------------------------===//
13160 
13161 namespace {
13162 class AtomicExprEvaluator :
13163     public ExprEvaluatorBase<AtomicExprEvaluator> {
13164   const LValue *This;
13165   APValue &Result;
13166 public:
13167   AtomicExprEvaluator(EvalInfo &Info, const LValue *This, APValue &Result)
13168       : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
13169 
13170   bool Success(const APValue &V, const Expr *E) {
13171     Result = V;
13172     return true;
13173   }
13174 
13175   bool ZeroInitialization(const Expr *E) {
13176     ImplicitValueInitExpr VIE(
13177         E->getType()->castAs<AtomicType>()->getValueType());
13178     // For atomic-qualified class (and array) types in C++, initialize the
13179     // _Atomic-wrapped subobject directly, in-place.
13180     return This ? EvaluateInPlace(Result, Info, *This, &VIE)
13181                 : Evaluate(Result, Info, &VIE);
13182   }
13183 
13184   bool VisitCastExpr(const CastExpr *E) {
13185     switch (E->getCastKind()) {
13186     default:
13187       return ExprEvaluatorBaseTy::VisitCastExpr(E);
13188     case CK_NonAtomicToAtomic:
13189       return This ? EvaluateInPlace(Result, Info, *This, E->getSubExpr())
13190                   : Evaluate(Result, Info, E->getSubExpr());
13191     }
13192   }
13193 };
13194 } // end anonymous namespace
13195 
13196 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
13197                            EvalInfo &Info) {
13198   assert(E->isRValue() && E->getType()->isAtomicType());
13199   return AtomicExprEvaluator(Info, This, Result).Visit(E);
13200 }
13201 
13202 //===----------------------------------------------------------------------===//
13203 // Void expression evaluation, primarily for a cast to void on the LHS of a
13204 // comma operator
13205 //===----------------------------------------------------------------------===//
13206 
13207 namespace {
13208 class VoidExprEvaluator
13209   : public ExprEvaluatorBase<VoidExprEvaluator> {
13210 public:
13211   VoidExprEvaluator(EvalInfo &Info) : ExprEvaluatorBaseTy(Info) {}
13212 
13213   bool Success(const APValue &V, const Expr *e) { return true; }
13214 
13215   bool ZeroInitialization(const Expr *E) { return true; }
13216 
13217   bool VisitCastExpr(const CastExpr *E) {
13218     switch (E->getCastKind()) {
13219     default:
13220       return ExprEvaluatorBaseTy::VisitCastExpr(E);
13221     case CK_ToVoid:
13222       VisitIgnoredValue(E->getSubExpr());
13223       return true;
13224     }
13225   }
13226 
13227   bool VisitCallExpr(const CallExpr *E) {
13228     switch (E->getBuiltinCallee()) {
13229     case Builtin::BI__assume:
13230     case Builtin::BI__builtin_assume:
13231       // The argument is not evaluated!
13232       return true;
13233 
13234     case Builtin::BI__builtin_operator_delete:
13235       return HandleOperatorDeleteCall(Info, E);
13236 
13237     default:
13238       break;
13239     }
13240 
13241     return ExprEvaluatorBaseTy::VisitCallExpr(E);
13242   }
13243 
13244   bool VisitCXXDeleteExpr(const CXXDeleteExpr *E);
13245 };
13246 } // end anonymous namespace
13247 
13248 bool VoidExprEvaluator::VisitCXXDeleteExpr(const CXXDeleteExpr *E) {
13249   // We cannot speculatively evaluate a delete expression.
13250   if (Info.SpeculativeEvaluationDepth)
13251     return false;
13252 
13253   FunctionDecl *OperatorDelete = E->getOperatorDelete();
13254   if (!OperatorDelete->isReplaceableGlobalAllocationFunction()) {
13255     Info.FFDiag(E, diag::note_constexpr_new_non_replaceable)
13256         << isa<CXXMethodDecl>(OperatorDelete) << OperatorDelete;
13257     return false;
13258   }
13259 
13260   const Expr *Arg = E->getArgument();
13261 
13262   LValue Pointer;
13263   if (!EvaluatePointer(Arg, Pointer, Info))
13264     return false;
13265   if (Pointer.Designator.Invalid)
13266     return false;
13267 
13268   // Deleting a null pointer has no effect.
13269   if (Pointer.isNullPointer()) {
13270     // This is the only case where we need to produce an extension warning:
13271     // the only other way we can succeed is if we find a dynamic allocation,
13272     // and we will have warned when we allocated it in that case.
13273     if (!Info.getLangOpts().CPlusPlus2a)
13274       Info.CCEDiag(E, diag::note_constexpr_new);
13275     return true;
13276   }
13277 
13278   Optional<DynAlloc *> Alloc = CheckDeleteKind(
13279       Info, E, Pointer, E->isArrayForm() ? DynAlloc::ArrayNew : DynAlloc::New);
13280   if (!Alloc)
13281     return false;
13282   QualType AllocType = Pointer.Base.getDynamicAllocType();
13283 
13284   // For the non-array case, the designator must be empty if the static type
13285   // does not have a virtual destructor.
13286   if (!E->isArrayForm() && Pointer.Designator.Entries.size() != 0 &&
13287       !hasVirtualDestructor(Arg->getType()->getPointeeType())) {
13288     Info.FFDiag(E, diag::note_constexpr_delete_base_nonvirt_dtor)
13289         << Arg->getType()->getPointeeType() << AllocType;
13290     return false;
13291   }
13292 
13293   // For a class type with a virtual destructor, the selected operator delete
13294   // is the one looked up when building the destructor.
13295   if (!E->isArrayForm() && !E->isGlobalDelete()) {
13296     const FunctionDecl *VirtualDelete = getVirtualOperatorDelete(AllocType);
13297     if (VirtualDelete &&
13298         !VirtualDelete->isReplaceableGlobalAllocationFunction()) {
13299       Info.FFDiag(E, diag::note_constexpr_new_non_replaceable)
13300           << isa<CXXMethodDecl>(VirtualDelete) << VirtualDelete;
13301       return false;
13302     }
13303   }
13304 
13305   if (!HandleDestruction(Info, E->getExprLoc(), Pointer.getLValueBase(),
13306                          (*Alloc)->Value, AllocType))
13307     return false;
13308 
13309   if (!Info.HeapAllocs.erase(Pointer.Base.dyn_cast<DynamicAllocLValue>())) {
13310     // The element was already erased. This means the destructor call also
13311     // deleted the object.
13312     // FIXME: This probably results in undefined behavior before we get this
13313     // far, and should be diagnosed elsewhere first.
13314     Info.FFDiag(E, diag::note_constexpr_double_delete);
13315     return false;
13316   }
13317 
13318   return true;
13319 }
13320 
13321 static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
13322   assert(E->isRValue() && E->getType()->isVoidType());
13323   return VoidExprEvaluator(Info).Visit(E);
13324 }
13325 
13326 //===----------------------------------------------------------------------===//
13327 // Top level Expr::EvaluateAsRValue method.
13328 //===----------------------------------------------------------------------===//
13329 
13330 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
13331   // In C, function designators are not lvalues, but we evaluate them as if they
13332   // are.
13333   QualType T = E->getType();
13334   if (E->isGLValue() || T->isFunctionType()) {
13335     LValue LV;
13336     if (!EvaluateLValue(E, LV, Info))
13337       return false;
13338     LV.moveInto(Result);
13339   } else if (T->isVectorType()) {
13340     if (!EvaluateVector(E, Result, Info))
13341       return false;
13342   } else if (T->isIntegralOrEnumerationType()) {
13343     if (!IntExprEvaluator(Info, Result).Visit(E))
13344       return false;
13345   } else if (T->hasPointerRepresentation()) {
13346     LValue LV;
13347     if (!EvaluatePointer(E, LV, Info))
13348       return false;
13349     LV.moveInto(Result);
13350   } else if (T->isRealFloatingType()) {
13351     llvm::APFloat F(0.0);
13352     if (!EvaluateFloat(E, F, Info))
13353       return false;
13354     Result = APValue(F);
13355   } else if (T->isAnyComplexType()) {
13356     ComplexValue C;
13357     if (!EvaluateComplex(E, C, Info))
13358       return false;
13359     C.moveInto(Result);
13360   } else if (T->isFixedPointType()) {
13361     if (!FixedPointExprEvaluator(Info, Result).Visit(E)) return false;
13362   } else if (T->isMemberPointerType()) {
13363     MemberPtr P;
13364     if (!EvaluateMemberPointer(E, P, Info))
13365       return false;
13366     P.moveInto(Result);
13367     return true;
13368   } else if (T->isArrayType()) {
13369     LValue LV;
13370     APValue &Value =
13371         Info.CurrentCall->createTemporary(E, T, false, LV);
13372     if (!EvaluateArray(E, LV, Value, Info))
13373       return false;
13374     Result = Value;
13375   } else if (T->isRecordType()) {
13376     LValue LV;
13377     APValue &Value = Info.CurrentCall->createTemporary(E, T, false, LV);
13378     if (!EvaluateRecord(E, LV, Value, Info))
13379       return false;
13380     Result = Value;
13381   } else if (T->isVoidType()) {
13382     if (!Info.getLangOpts().CPlusPlus11)
13383       Info.CCEDiag(E, diag::note_constexpr_nonliteral)
13384         << E->getType();
13385     if (!EvaluateVoid(E, Info))
13386       return false;
13387   } else if (T->isAtomicType()) {
13388     QualType Unqual = T.getAtomicUnqualifiedType();
13389     if (Unqual->isArrayType() || Unqual->isRecordType()) {
13390       LValue LV;
13391       APValue &Value = Info.CurrentCall->createTemporary(E, Unqual, false, LV);
13392       if (!EvaluateAtomic(E, &LV, Value, Info))
13393         return false;
13394     } else {
13395       if (!EvaluateAtomic(E, nullptr, Result, Info))
13396         return false;
13397     }
13398   } else if (Info.getLangOpts().CPlusPlus11) {
13399     Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();
13400     return false;
13401   } else {
13402     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
13403     return false;
13404   }
13405 
13406   return true;
13407 }
13408 
13409 /// EvaluateInPlace - Evaluate an expression in-place in an APValue. In some
13410 /// cases, the in-place evaluation is essential, since later initializers for
13411 /// an object can indirectly refer to subobjects which were initialized earlier.
13412 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This,
13413                             const Expr *E, bool AllowNonLiteralTypes) {
13414   assert(!E->isValueDependent());
13415 
13416   if (!AllowNonLiteralTypes && !CheckLiteralType(Info, E, &This))
13417     return false;
13418 
13419   if (E->isRValue()) {
13420     // Evaluate arrays and record types in-place, so that later initializers can
13421     // refer to earlier-initialized members of the object.
13422     QualType T = E->getType();
13423     if (T->isArrayType())
13424       return EvaluateArray(E, This, Result, Info);
13425     else if (T->isRecordType())
13426       return EvaluateRecord(E, This, Result, Info);
13427     else if (T->isAtomicType()) {
13428       QualType Unqual = T.getAtomicUnqualifiedType();
13429       if (Unqual->isArrayType() || Unqual->isRecordType())
13430         return EvaluateAtomic(E, &This, Result, Info);
13431     }
13432   }
13433 
13434   // For any other type, in-place evaluation is unimportant.
13435   return Evaluate(Result, Info, E);
13436 }
13437 
13438 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
13439 /// lvalue-to-rvalue cast if it is an lvalue.
13440 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
13441   if (Info.EnableNewConstInterp) {
13442     if (!Info.Ctx.getInterpContext().evaluateAsRValue(Info, E, Result))
13443       return false;
13444   } else {
13445     if (E->getType().isNull())
13446       return false;
13447 
13448     if (!CheckLiteralType(Info, E))
13449       return false;
13450 
13451     if (!::Evaluate(Result, Info, E))
13452       return false;
13453 
13454     if (E->isGLValue()) {
13455       LValue LV;
13456       LV.setFrom(Info.Ctx, Result);
13457       if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
13458         return false;
13459     }
13460   }
13461 
13462   // Check this core constant expression is a constant expression.
13463   return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result) &&
13464          CheckMemoryLeaks(Info);
13465 }
13466 
13467 static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result,
13468                                  const ASTContext &Ctx, bool &IsConst) {
13469   // Fast-path evaluations of integer literals, since we sometimes see files
13470   // containing vast quantities of these.
13471   if (const IntegerLiteral *L = dyn_cast<IntegerLiteral>(Exp)) {
13472     Result.Val = APValue(APSInt(L->getValue(),
13473                                 L->getType()->isUnsignedIntegerType()));
13474     IsConst = true;
13475     return true;
13476   }
13477 
13478   // This case should be rare, but we need to check it before we check on
13479   // the type below.
13480   if (Exp->getType().isNull()) {
13481     IsConst = false;
13482     return true;
13483   }
13484 
13485   // FIXME: Evaluating values of large array and record types can cause
13486   // performance problems. Only do so in C++11 for now.
13487   if (Exp->isRValue() && (Exp->getType()->isArrayType() ||
13488                           Exp->getType()->isRecordType()) &&
13489       !Ctx.getLangOpts().CPlusPlus11) {
13490     IsConst = false;
13491     return true;
13492   }
13493   return false;
13494 }
13495 
13496 static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result,
13497                                       Expr::SideEffectsKind SEK) {
13498   return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) ||
13499          (SEK < Expr::SE_AllowUndefinedBehavior && Result.HasUndefinedBehavior);
13500 }
13501 
13502 static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result,
13503                              const ASTContext &Ctx, EvalInfo &Info) {
13504   bool IsConst;
13505   if (FastEvaluateAsRValue(E, Result, Ctx, IsConst))
13506     return IsConst;
13507 
13508   return EvaluateAsRValue(Info, E, Result.Val);
13509 }
13510 
13511 static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult,
13512                           const ASTContext &Ctx,
13513                           Expr::SideEffectsKind AllowSideEffects,
13514                           EvalInfo &Info) {
13515   if (!E->getType()->isIntegralOrEnumerationType())
13516     return false;
13517 
13518   if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info) ||
13519       !ExprResult.Val.isInt() ||
13520       hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
13521     return false;
13522 
13523   return true;
13524 }
13525 
13526 static bool EvaluateAsFixedPoint(const Expr *E, Expr::EvalResult &ExprResult,
13527                                  const ASTContext &Ctx,
13528                                  Expr::SideEffectsKind AllowSideEffects,
13529                                  EvalInfo &Info) {
13530   if (!E->getType()->isFixedPointType())
13531     return false;
13532 
13533   if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info))
13534     return false;
13535 
13536   if (!ExprResult.Val.isFixedPoint() ||
13537       hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
13538     return false;
13539 
13540   return true;
13541 }
13542 
13543 /// EvaluateAsRValue - Return true if this is a constant which we can fold using
13544 /// any crazy technique (that has nothing to do with language standards) that
13545 /// we want to.  If this function returns true, it returns the folded constant
13546 /// in Result. If this expression is a glvalue, an lvalue-to-rvalue conversion
13547 /// will be applied to the result.
13548 bool Expr::EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx,
13549                             bool InConstantContext) const {
13550   assert(!isValueDependent() &&
13551          "Expression evaluator can't be called on a dependent expression.");
13552   EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
13553   Info.InConstantContext = InConstantContext;
13554   return ::EvaluateAsRValue(this, Result, Ctx, Info);
13555 }
13556 
13557 bool Expr::EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx,
13558                                       bool InConstantContext) const {
13559   assert(!isValueDependent() &&
13560          "Expression evaluator can't be called on a dependent expression.");
13561   EvalResult Scratch;
13562   return EvaluateAsRValue(Scratch, Ctx, InConstantContext) &&
13563          HandleConversionToBool(Scratch.Val, Result);
13564 }
13565 
13566 bool Expr::EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
13567                          SideEffectsKind AllowSideEffects,
13568                          bool InConstantContext) const {
13569   assert(!isValueDependent() &&
13570          "Expression evaluator can't be called on a dependent expression.");
13571   EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
13572   Info.InConstantContext = InConstantContext;
13573   return ::EvaluateAsInt(this, Result, Ctx, AllowSideEffects, Info);
13574 }
13575 
13576 bool Expr::EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx,
13577                                 SideEffectsKind AllowSideEffects,
13578                                 bool InConstantContext) const {
13579   assert(!isValueDependent() &&
13580          "Expression evaluator can't be called on a dependent expression.");
13581   EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
13582   Info.InConstantContext = InConstantContext;
13583   return ::EvaluateAsFixedPoint(this, Result, Ctx, AllowSideEffects, Info);
13584 }
13585 
13586 bool Expr::EvaluateAsFloat(APFloat &Result, const ASTContext &Ctx,
13587                            SideEffectsKind AllowSideEffects,
13588                            bool InConstantContext) const {
13589   assert(!isValueDependent() &&
13590          "Expression evaluator can't be called on a dependent expression.");
13591 
13592   if (!getType()->isRealFloatingType())
13593     return false;
13594 
13595   EvalResult ExprResult;
13596   if (!EvaluateAsRValue(ExprResult, Ctx, InConstantContext) ||
13597       !ExprResult.Val.isFloat() ||
13598       hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
13599     return false;
13600 
13601   Result = ExprResult.Val.getFloat();
13602   return true;
13603 }
13604 
13605 bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx,
13606                             bool InConstantContext) const {
13607   assert(!isValueDependent() &&
13608          "Expression evaluator can't be called on a dependent expression.");
13609 
13610   EvalInfo Info(Ctx, Result, EvalInfo::EM_ConstantFold);
13611   Info.InConstantContext = InConstantContext;
13612   LValue LV;
13613   CheckedTemporaries CheckedTemps;
13614   if (!EvaluateLValue(this, LV, Info) || !Info.discardCleanups() ||
13615       Result.HasSideEffects ||
13616       !CheckLValueConstantExpression(Info, getExprLoc(),
13617                                      Ctx.getLValueReferenceType(getType()), LV,
13618                                      Expr::EvaluateForCodeGen, CheckedTemps))
13619     return false;
13620 
13621   LV.moveInto(Result.Val);
13622   return true;
13623 }
13624 
13625 bool Expr::EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage,
13626                                   const ASTContext &Ctx) const {
13627   assert(!isValueDependent() &&
13628          "Expression evaluator can't be called on a dependent expression.");
13629 
13630   EvalInfo::EvaluationMode EM = EvalInfo::EM_ConstantExpression;
13631   EvalInfo Info(Ctx, Result, EM);
13632   Info.InConstantContext = true;
13633 
13634   if (!::Evaluate(Result.Val, Info, this) || Result.HasSideEffects)
13635     return false;
13636 
13637   if (!Info.discardCleanups())
13638     llvm_unreachable("Unhandled cleanup; missing full expression marker?");
13639 
13640   return CheckConstantExpression(Info, getExprLoc(), getStorageType(Ctx, this),
13641                                  Result.Val, Usage) &&
13642          CheckMemoryLeaks(Info);
13643 }
13644 
13645 bool Expr::EvaluateAsInitializer(APValue &Value, const ASTContext &Ctx,
13646                                  const VarDecl *VD,
13647                             SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
13648   assert(!isValueDependent() &&
13649          "Expression evaluator can't be called on a dependent expression.");
13650 
13651   // FIXME: Evaluating initializers for large array and record types can cause
13652   // performance problems. Only do so in C++11 for now.
13653   if (isRValue() && (getType()->isArrayType() || getType()->isRecordType()) &&
13654       !Ctx.getLangOpts().CPlusPlus11)
13655     return false;
13656 
13657   Expr::EvalStatus EStatus;
13658   EStatus.Diag = &Notes;
13659 
13660   EvalInfo Info(Ctx, EStatus, VD->isConstexpr()
13661                                       ? EvalInfo::EM_ConstantExpression
13662                                       : EvalInfo::EM_ConstantFold);
13663   Info.setEvaluatingDecl(VD, Value);
13664   Info.InConstantContext = true;
13665 
13666   SourceLocation DeclLoc = VD->getLocation();
13667   QualType DeclTy = VD->getType();
13668 
13669   if (Info.EnableNewConstInterp) {
13670     auto &InterpCtx = const_cast<ASTContext &>(Ctx).getInterpContext();
13671     if (!InterpCtx.evaluateAsInitializer(Info, VD, Value))
13672       return false;
13673   } else {
13674     LValue LVal;
13675     LVal.set(VD);
13676 
13677     // C++11 [basic.start.init]p2:
13678     //  Variables with static storage duration or thread storage duration shall
13679     //  be zero-initialized before any other initialization takes place.
13680     // This behavior is not present in C.
13681     if (Ctx.getLangOpts().CPlusPlus && !VD->hasLocalStorage() &&
13682         !DeclTy->isReferenceType()) {
13683       ImplicitValueInitExpr VIE(DeclTy);
13684       if (!EvaluateInPlace(Value, Info, LVal, &VIE,
13685                            /*AllowNonLiteralTypes=*/true))
13686         return false;
13687     }
13688 
13689     if (!EvaluateInPlace(Value, Info, LVal, this,
13690                          /*AllowNonLiteralTypes=*/true) ||
13691         EStatus.HasSideEffects)
13692       return false;
13693 
13694     // At this point, any lifetime-extended temporaries are completely
13695     // initialized.
13696     Info.performLifetimeExtension();
13697 
13698     if (!Info.discardCleanups())
13699       llvm_unreachable("Unhandled cleanup; missing full expression marker?");
13700   }
13701   return CheckConstantExpression(Info, DeclLoc, DeclTy, Value) &&
13702          CheckMemoryLeaks(Info);
13703 }
13704 
13705 bool VarDecl::evaluateDestruction(
13706     SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
13707   assert(getEvaluatedValue() && !getEvaluatedValue()->isAbsent() &&
13708          "cannot evaluate destruction of non-constant-initialized variable");
13709 
13710   Expr::EvalStatus EStatus;
13711   EStatus.Diag = &Notes;
13712 
13713   // Make a copy of the value for the destructor to mutate.
13714   APValue DestroyedValue = *getEvaluatedValue();
13715 
13716   EvalInfo Info(getASTContext(), EStatus, EvalInfo::EM_ConstantExpression);
13717   Info.setEvaluatingDecl(this, DestroyedValue,
13718                          EvalInfo::EvaluatingDeclKind::Dtor);
13719   Info.InConstantContext = true;
13720 
13721   SourceLocation DeclLoc = getLocation();
13722   QualType DeclTy = getType();
13723 
13724   LValue LVal;
13725   LVal.set(this);
13726 
13727   // FIXME: Consider storing whether this variable has constant destruction in
13728   // the EvaluatedStmt so that CodeGen can query it.
13729   if (!HandleDestruction(Info, DeclLoc, LVal.Base, DestroyedValue, DeclTy) ||
13730       EStatus.HasSideEffects)
13731     return false;
13732 
13733   if (!Info.discardCleanups())
13734     llvm_unreachable("Unhandled cleanup; missing full expression marker?");
13735 
13736   ensureEvaluatedStmt()->HasConstantDestruction = true;
13737   return true;
13738 }
13739 
13740 /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
13741 /// constant folded, but discard the result.
13742 bool Expr::isEvaluatable(const ASTContext &Ctx, SideEffectsKind SEK) const {
13743   assert(!isValueDependent() &&
13744          "Expression evaluator can't be called on a dependent expression.");
13745 
13746   EvalResult Result;
13747   return EvaluateAsRValue(Result, Ctx, /* in constant context */ true) &&
13748          !hasUnacceptableSideEffect(Result, SEK);
13749 }
13750 
13751 APSInt Expr::EvaluateKnownConstInt(const ASTContext &Ctx,
13752                     SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
13753   assert(!isValueDependent() &&
13754          "Expression evaluator can't be called on a dependent expression.");
13755 
13756   EvalResult EVResult;
13757   EVResult.Diag = Diag;
13758   EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects);
13759   Info.InConstantContext = true;
13760 
13761   bool Result = ::EvaluateAsRValue(this, EVResult, Ctx, Info);
13762   (void)Result;
13763   assert(Result && "Could not evaluate expression");
13764   assert(EVResult.Val.isInt() && "Expression did not evaluate to integer");
13765 
13766   return EVResult.Val.getInt();
13767 }
13768 
13769 APSInt Expr::EvaluateKnownConstIntCheckOverflow(
13770     const ASTContext &Ctx, SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
13771   assert(!isValueDependent() &&
13772          "Expression evaluator can't be called on a dependent expression.");
13773 
13774   EvalResult EVResult;
13775   EVResult.Diag = Diag;
13776   EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects);
13777   Info.InConstantContext = true;
13778   Info.CheckingForUndefinedBehavior = true;
13779 
13780   bool Result = ::EvaluateAsRValue(Info, this, EVResult.Val);
13781   (void)Result;
13782   assert(Result && "Could not evaluate expression");
13783   assert(EVResult.Val.isInt() && "Expression did not evaluate to integer");
13784 
13785   return EVResult.Val.getInt();
13786 }
13787 
13788 void Expr::EvaluateForOverflow(const ASTContext &Ctx) const {
13789   assert(!isValueDependent() &&
13790          "Expression evaluator can't be called on a dependent expression.");
13791 
13792   bool IsConst;
13793   EvalResult EVResult;
13794   if (!FastEvaluateAsRValue(this, EVResult, Ctx, IsConst)) {
13795     EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects);
13796     Info.CheckingForUndefinedBehavior = true;
13797     (void)::EvaluateAsRValue(Info, this, EVResult.Val);
13798   }
13799 }
13800 
13801 bool Expr::EvalResult::isGlobalLValue() const {
13802   assert(Val.isLValue());
13803   return IsGlobalLValue(Val.getLValueBase());
13804 }
13805 
13806 
13807 /// isIntegerConstantExpr - this recursive routine will test if an expression is
13808 /// an integer constant expression.
13809 
13810 /// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
13811 /// comma, etc
13812 
13813 // CheckICE - This function does the fundamental ICE checking: the returned
13814 // ICEDiag contains an ICEKind indicating whether the expression is an ICE,
13815 // and a (possibly null) SourceLocation indicating the location of the problem.
13816 //
13817 // Note that to reduce code duplication, this helper does no evaluation
13818 // itself; the caller checks whether the expression is evaluatable, and
13819 // in the rare cases where CheckICE actually cares about the evaluated
13820 // value, it calls into Evaluate.
13821 
13822 namespace {
13823 
13824 enum ICEKind {
13825   /// This expression is an ICE.
13826   IK_ICE,
13827   /// This expression is not an ICE, but if it isn't evaluated, it's
13828   /// a legal subexpression for an ICE. This return value is used to handle
13829   /// the comma operator in C99 mode, and non-constant subexpressions.
13830   IK_ICEIfUnevaluated,
13831   /// This expression is not an ICE, and is not a legal subexpression for one.
13832   IK_NotICE
13833 };
13834 
13835 struct ICEDiag {
13836   ICEKind Kind;
13837   SourceLocation Loc;
13838 
13839   ICEDiag(ICEKind IK, SourceLocation l) : Kind(IK), Loc(l) {}
13840 };
13841 
13842 }
13843 
13844 static ICEDiag NoDiag() { return ICEDiag(IK_ICE, SourceLocation()); }
13845 
13846 static ICEDiag Worst(ICEDiag A, ICEDiag B) { return A.Kind >= B.Kind ? A : B; }
13847 
13848 static ICEDiag CheckEvalInICE(const Expr* E, const ASTContext &Ctx) {
13849   Expr::EvalResult EVResult;
13850   Expr::EvalStatus Status;
13851   EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
13852 
13853   Info.InConstantContext = true;
13854   if (!::EvaluateAsRValue(E, EVResult, Ctx, Info) || EVResult.HasSideEffects ||
13855       !EVResult.Val.isInt())
13856     return ICEDiag(IK_NotICE, E->getBeginLoc());
13857 
13858   return NoDiag();
13859 }
13860 
13861 static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
13862   assert(!E->isValueDependent() && "Should not see value dependent exprs!");
13863   if (!E->getType()->isIntegralOrEnumerationType())
13864     return ICEDiag(IK_NotICE, E->getBeginLoc());
13865 
13866   switch (E->getStmtClass()) {
13867 #define ABSTRACT_STMT(Node)
13868 #define STMT(Node, Base) case Expr::Node##Class:
13869 #define EXPR(Node, Base)
13870 #include "clang/AST/StmtNodes.inc"
13871   case Expr::PredefinedExprClass:
13872   case Expr::FloatingLiteralClass:
13873   case Expr::ImaginaryLiteralClass:
13874   case Expr::StringLiteralClass:
13875   case Expr::ArraySubscriptExprClass:
13876   case Expr::OMPArraySectionExprClass:
13877   case Expr::MemberExprClass:
13878   case Expr::CompoundAssignOperatorClass:
13879   case Expr::CompoundLiteralExprClass:
13880   case Expr::ExtVectorElementExprClass:
13881   case Expr::DesignatedInitExprClass:
13882   case Expr::ArrayInitLoopExprClass:
13883   case Expr::ArrayInitIndexExprClass:
13884   case Expr::NoInitExprClass:
13885   case Expr::DesignatedInitUpdateExprClass:
13886   case Expr::ImplicitValueInitExprClass:
13887   case Expr::ParenListExprClass:
13888   case Expr::VAArgExprClass:
13889   case Expr::AddrLabelExprClass:
13890   case Expr::StmtExprClass:
13891   case Expr::CXXMemberCallExprClass:
13892   case Expr::CUDAKernelCallExprClass:
13893   case Expr::CXXDynamicCastExprClass:
13894   case Expr::CXXTypeidExprClass:
13895   case Expr::CXXUuidofExprClass:
13896   case Expr::MSPropertyRefExprClass:
13897   case Expr::MSPropertySubscriptExprClass:
13898   case Expr::CXXNullPtrLiteralExprClass:
13899   case Expr::UserDefinedLiteralClass:
13900   case Expr::CXXThisExprClass:
13901   case Expr::CXXThrowExprClass:
13902   case Expr::CXXNewExprClass:
13903   case Expr::CXXDeleteExprClass:
13904   case Expr::CXXPseudoDestructorExprClass:
13905   case Expr::UnresolvedLookupExprClass:
13906   case Expr::TypoExprClass:
13907   case Expr::DependentScopeDeclRefExprClass:
13908   case Expr::CXXConstructExprClass:
13909   case Expr::CXXInheritedCtorInitExprClass:
13910   case Expr::CXXStdInitializerListExprClass:
13911   case Expr::CXXBindTemporaryExprClass:
13912   case Expr::ExprWithCleanupsClass:
13913   case Expr::CXXTemporaryObjectExprClass:
13914   case Expr::CXXUnresolvedConstructExprClass:
13915   case Expr::CXXDependentScopeMemberExprClass:
13916   case Expr::UnresolvedMemberExprClass:
13917   case Expr::ObjCStringLiteralClass:
13918   case Expr::ObjCBoxedExprClass:
13919   case Expr::ObjCArrayLiteralClass:
13920   case Expr::ObjCDictionaryLiteralClass:
13921   case Expr::ObjCEncodeExprClass:
13922   case Expr::ObjCMessageExprClass:
13923   case Expr::ObjCSelectorExprClass:
13924   case Expr::ObjCProtocolExprClass:
13925   case Expr::ObjCIvarRefExprClass:
13926   case Expr::ObjCPropertyRefExprClass:
13927   case Expr::ObjCSubscriptRefExprClass:
13928   case Expr::ObjCIsaExprClass:
13929   case Expr::ObjCAvailabilityCheckExprClass:
13930   case Expr::ShuffleVectorExprClass:
13931   case Expr::ConvertVectorExprClass:
13932   case Expr::BlockExprClass:
13933   case Expr::NoStmtClass:
13934   case Expr::OpaqueValueExprClass:
13935   case Expr::PackExpansionExprClass:
13936   case Expr::SubstNonTypeTemplateParmPackExprClass:
13937   case Expr::FunctionParmPackExprClass:
13938   case Expr::AsTypeExprClass:
13939   case Expr::ObjCIndirectCopyRestoreExprClass:
13940   case Expr::MaterializeTemporaryExprClass:
13941   case Expr::PseudoObjectExprClass:
13942   case Expr::AtomicExprClass:
13943   case Expr::LambdaExprClass:
13944   case Expr::CXXFoldExprClass:
13945   case Expr::CoawaitExprClass:
13946   case Expr::DependentCoawaitExprClass:
13947   case Expr::CoyieldExprClass:
13948     return ICEDiag(IK_NotICE, E->getBeginLoc());
13949 
13950   case Expr::InitListExprClass: {
13951     // C++03 [dcl.init]p13: If T is a scalar type, then a declaration of the
13952     // form "T x = { a };" is equivalent to "T x = a;".
13953     // Unless we're initializing a reference, T is a scalar as it is known to be
13954     // of integral or enumeration type.
13955     if (E->isRValue())
13956       if (cast<InitListExpr>(E)->getNumInits() == 1)
13957         return CheckICE(cast<InitListExpr>(E)->getInit(0), Ctx);
13958     return ICEDiag(IK_NotICE, E->getBeginLoc());
13959   }
13960 
13961   case Expr::SizeOfPackExprClass:
13962   case Expr::GNUNullExprClass:
13963   case Expr::SourceLocExprClass:
13964     return NoDiag();
13965 
13966   case Expr::SubstNonTypeTemplateParmExprClass:
13967     return
13968       CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), Ctx);
13969 
13970   case Expr::ConstantExprClass:
13971     return CheckICE(cast<ConstantExpr>(E)->getSubExpr(), Ctx);
13972 
13973   case Expr::ParenExprClass:
13974     return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
13975   case Expr::GenericSelectionExprClass:
13976     return CheckICE(cast<GenericSelectionExpr>(E)->getResultExpr(), Ctx);
13977   case Expr::IntegerLiteralClass:
13978   case Expr::FixedPointLiteralClass:
13979   case Expr::CharacterLiteralClass:
13980   case Expr::ObjCBoolLiteralExprClass:
13981   case Expr::CXXBoolLiteralExprClass:
13982   case Expr::CXXScalarValueInitExprClass:
13983   case Expr::TypeTraitExprClass:
13984   case Expr::ConceptSpecializationExprClass:
13985   case Expr::ArrayTypeTraitExprClass:
13986   case Expr::ExpressionTraitExprClass:
13987   case Expr::CXXNoexceptExprClass:
13988     return NoDiag();
13989   case Expr::CallExprClass:
13990   case Expr::CXXOperatorCallExprClass: {
13991     // C99 6.6/3 allows function calls within unevaluated subexpressions of
13992     // constant expressions, but they can never be ICEs because an ICE cannot
13993     // contain an operand of (pointer to) function type.
13994     const CallExpr *CE = cast<CallExpr>(E);
13995     if (CE->getBuiltinCallee())
13996       return CheckEvalInICE(E, Ctx);
13997     return ICEDiag(IK_NotICE, E->getBeginLoc());
13998   }
13999   case Expr::CXXRewrittenBinaryOperatorClass:
14000     return CheckICE(cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm(),
14001                     Ctx);
14002   case Expr::DeclRefExprClass: {
14003     if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
14004       return NoDiag();
14005     const ValueDecl *D = cast<DeclRefExpr>(E)->getDecl();
14006     if (Ctx.getLangOpts().CPlusPlus &&
14007         D && IsConstNonVolatile(D->getType())) {
14008       // Parameter variables are never constants.  Without this check,
14009       // getAnyInitializer() can find a default argument, which leads
14010       // to chaos.
14011       if (isa<ParmVarDecl>(D))
14012         return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
14013 
14014       // C++ 7.1.5.1p2
14015       //   A variable of non-volatile const-qualified integral or enumeration
14016       //   type initialized by an ICE can be used in ICEs.
14017       if (const VarDecl *Dcl = dyn_cast<VarDecl>(D)) {
14018         if (!Dcl->getType()->isIntegralOrEnumerationType())
14019           return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
14020 
14021         const VarDecl *VD;
14022         // Look for a declaration of this variable that has an initializer, and
14023         // check whether it is an ICE.
14024         if (Dcl->getAnyInitializer(VD) && VD->checkInitIsICE())
14025           return NoDiag();
14026         else
14027           return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
14028       }
14029     }
14030     return ICEDiag(IK_NotICE, E->getBeginLoc());
14031   }
14032   case Expr::UnaryOperatorClass: {
14033     const UnaryOperator *Exp = cast<UnaryOperator>(E);
14034     switch (Exp->getOpcode()) {
14035     case UO_PostInc:
14036     case UO_PostDec:
14037     case UO_PreInc:
14038     case UO_PreDec:
14039     case UO_AddrOf:
14040     case UO_Deref:
14041     case UO_Coawait:
14042       // C99 6.6/3 allows increment and decrement within unevaluated
14043       // subexpressions of constant expressions, but they can never be ICEs
14044       // because an ICE cannot contain an lvalue operand.
14045       return ICEDiag(IK_NotICE, E->getBeginLoc());
14046     case UO_Extension:
14047     case UO_LNot:
14048     case UO_Plus:
14049     case UO_Minus:
14050     case UO_Not:
14051     case UO_Real:
14052     case UO_Imag:
14053       return CheckICE(Exp->getSubExpr(), Ctx);
14054     }
14055     llvm_unreachable("invalid unary operator class");
14056   }
14057   case Expr::OffsetOfExprClass: {
14058     // Note that per C99, offsetof must be an ICE. And AFAIK, using
14059     // EvaluateAsRValue matches the proposed gcc behavior for cases like
14060     // "offsetof(struct s{int x[4];}, x[1.0])".  This doesn't affect
14061     // compliance: we should warn earlier for offsetof expressions with
14062     // array subscripts that aren't ICEs, and if the array subscripts
14063     // are ICEs, the value of the offsetof must be an integer constant.
14064     return CheckEvalInICE(E, Ctx);
14065   }
14066   case Expr::UnaryExprOrTypeTraitExprClass: {
14067     const UnaryExprOrTypeTraitExpr *Exp = cast<UnaryExprOrTypeTraitExpr>(E);
14068     if ((Exp->getKind() ==  UETT_SizeOf) &&
14069         Exp->getTypeOfArgument()->isVariableArrayType())
14070       return ICEDiag(IK_NotICE, E->getBeginLoc());
14071     return NoDiag();
14072   }
14073   case Expr::BinaryOperatorClass: {
14074     const BinaryOperator *Exp = cast<BinaryOperator>(E);
14075     switch (Exp->getOpcode()) {
14076     case BO_PtrMemD:
14077     case BO_PtrMemI:
14078     case BO_Assign:
14079     case BO_MulAssign:
14080     case BO_DivAssign:
14081     case BO_RemAssign:
14082     case BO_AddAssign:
14083     case BO_SubAssign:
14084     case BO_ShlAssign:
14085     case BO_ShrAssign:
14086     case BO_AndAssign:
14087     case BO_XorAssign:
14088     case BO_OrAssign:
14089       // C99 6.6/3 allows assignments within unevaluated subexpressions of
14090       // constant expressions, but they can never be ICEs because an ICE cannot
14091       // contain an lvalue operand.
14092       return ICEDiag(IK_NotICE, E->getBeginLoc());
14093 
14094     case BO_Mul:
14095     case BO_Div:
14096     case BO_Rem:
14097     case BO_Add:
14098     case BO_Sub:
14099     case BO_Shl:
14100     case BO_Shr:
14101     case BO_LT:
14102     case BO_GT:
14103     case BO_LE:
14104     case BO_GE:
14105     case BO_EQ:
14106     case BO_NE:
14107     case BO_And:
14108     case BO_Xor:
14109     case BO_Or:
14110     case BO_Comma:
14111     case BO_Cmp: {
14112       ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
14113       ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
14114       if (Exp->getOpcode() == BO_Div ||
14115           Exp->getOpcode() == BO_Rem) {
14116         // EvaluateAsRValue gives an error for undefined Div/Rem, so make sure
14117         // we don't evaluate one.
14118         if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) {
14119           llvm::APSInt REval = Exp->getRHS()->EvaluateKnownConstInt(Ctx);
14120           if (REval == 0)
14121             return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
14122           if (REval.isSigned() && REval.isAllOnesValue()) {
14123             llvm::APSInt LEval = Exp->getLHS()->EvaluateKnownConstInt(Ctx);
14124             if (LEval.isMinSignedValue())
14125               return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
14126           }
14127         }
14128       }
14129       if (Exp->getOpcode() == BO_Comma) {
14130         if (Ctx.getLangOpts().C99) {
14131           // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
14132           // if it isn't evaluated.
14133           if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE)
14134             return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
14135         } else {
14136           // In both C89 and C++, commas in ICEs are illegal.
14137           return ICEDiag(IK_NotICE, E->getBeginLoc());
14138         }
14139       }
14140       return Worst(LHSResult, RHSResult);
14141     }
14142     case BO_LAnd:
14143     case BO_LOr: {
14144       ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
14145       ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
14146       if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICEIfUnevaluated) {
14147         // Rare case where the RHS has a comma "side-effect"; we need
14148         // to actually check the condition to see whether the side
14149         // with the comma is evaluated.
14150         if ((Exp->getOpcode() == BO_LAnd) !=
14151             (Exp->getLHS()->EvaluateKnownConstInt(Ctx) == 0))
14152           return RHSResult;
14153         return NoDiag();
14154       }
14155 
14156       return Worst(LHSResult, RHSResult);
14157     }
14158     }
14159     llvm_unreachable("invalid binary operator kind");
14160   }
14161   case Expr::ImplicitCastExprClass:
14162   case Expr::CStyleCastExprClass:
14163   case Expr::CXXFunctionalCastExprClass:
14164   case Expr::CXXStaticCastExprClass:
14165   case Expr::CXXReinterpretCastExprClass:
14166   case Expr::CXXConstCastExprClass:
14167   case Expr::ObjCBridgedCastExprClass: {
14168     const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
14169     if (isa<ExplicitCastExpr>(E)) {
14170       if (const FloatingLiteral *FL
14171             = dyn_cast<FloatingLiteral>(SubExpr->IgnoreParenImpCasts())) {
14172         unsigned DestWidth = Ctx.getIntWidth(E->getType());
14173         bool DestSigned = E->getType()->isSignedIntegerOrEnumerationType();
14174         APSInt IgnoredVal(DestWidth, !DestSigned);
14175         bool Ignored;
14176         // If the value does not fit in the destination type, the behavior is
14177         // undefined, so we are not required to treat it as a constant
14178         // expression.
14179         if (FL->getValue().convertToInteger(IgnoredVal,
14180                                             llvm::APFloat::rmTowardZero,
14181                                             &Ignored) & APFloat::opInvalidOp)
14182           return ICEDiag(IK_NotICE, E->getBeginLoc());
14183         return NoDiag();
14184       }
14185     }
14186     switch (cast<CastExpr>(E)->getCastKind()) {
14187     case CK_LValueToRValue:
14188     case CK_AtomicToNonAtomic:
14189     case CK_NonAtomicToAtomic:
14190     case CK_NoOp:
14191     case CK_IntegralToBoolean:
14192     case CK_IntegralCast:
14193       return CheckICE(SubExpr, Ctx);
14194     default:
14195       return ICEDiag(IK_NotICE, E->getBeginLoc());
14196     }
14197   }
14198   case Expr::BinaryConditionalOperatorClass: {
14199     const BinaryConditionalOperator *Exp = cast<BinaryConditionalOperator>(E);
14200     ICEDiag CommonResult = CheckICE(Exp->getCommon(), Ctx);
14201     if (CommonResult.Kind == IK_NotICE) return CommonResult;
14202     ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
14203     if (FalseResult.Kind == IK_NotICE) return FalseResult;
14204     if (CommonResult.Kind == IK_ICEIfUnevaluated) return CommonResult;
14205     if (FalseResult.Kind == IK_ICEIfUnevaluated &&
14206         Exp->getCommon()->EvaluateKnownConstInt(Ctx) != 0) return NoDiag();
14207     return FalseResult;
14208   }
14209   case Expr::ConditionalOperatorClass: {
14210     const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
14211     // If the condition (ignoring parens) is a __builtin_constant_p call,
14212     // then only the true side is actually considered in an integer constant
14213     // expression, and it is fully evaluated.  This is an important GNU
14214     // extension.  See GCC PR38377 for discussion.
14215     if (const CallExpr *CallCE
14216         = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
14217       if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
14218         return CheckEvalInICE(E, Ctx);
14219     ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
14220     if (CondResult.Kind == IK_NotICE)
14221       return CondResult;
14222 
14223     ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
14224     ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
14225 
14226     if (TrueResult.Kind == IK_NotICE)
14227       return TrueResult;
14228     if (FalseResult.Kind == IK_NotICE)
14229       return FalseResult;
14230     if (CondResult.Kind == IK_ICEIfUnevaluated)
14231       return CondResult;
14232     if (TrueResult.Kind == IK_ICE && FalseResult.Kind == IK_ICE)
14233       return NoDiag();
14234     // Rare case where the diagnostics depend on which side is evaluated
14235     // Note that if we get here, CondResult is 0, and at least one of
14236     // TrueResult and FalseResult is non-zero.
14237     if (Exp->getCond()->EvaluateKnownConstInt(Ctx) == 0)
14238       return FalseResult;
14239     return TrueResult;
14240   }
14241   case Expr::CXXDefaultArgExprClass:
14242     return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
14243   case Expr::CXXDefaultInitExprClass:
14244     return CheckICE(cast<CXXDefaultInitExpr>(E)->getExpr(), Ctx);
14245   case Expr::ChooseExprClass: {
14246     return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(), Ctx);
14247   }
14248   case Expr::BuiltinBitCastExprClass: {
14249     if (!checkBitCastConstexprEligibility(nullptr, Ctx, cast<CastExpr>(E)))
14250       return ICEDiag(IK_NotICE, E->getBeginLoc());
14251     return CheckICE(cast<CastExpr>(E)->getSubExpr(), Ctx);
14252   }
14253   }
14254 
14255   llvm_unreachable("Invalid StmtClass!");
14256 }
14257 
14258 /// Evaluate an expression as a C++11 integral constant expression.
14259 static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx,
14260                                                     const Expr *E,
14261                                                     llvm::APSInt *Value,
14262                                                     SourceLocation *Loc) {
14263   if (!E->getType()->isIntegralOrUnscopedEnumerationType()) {
14264     if (Loc) *Loc = E->getExprLoc();
14265     return false;
14266   }
14267 
14268   APValue Result;
14269   if (!E->isCXX11ConstantExpr(Ctx, &Result, Loc))
14270     return false;
14271 
14272   if (!Result.isInt()) {
14273     if (Loc) *Loc = E->getExprLoc();
14274     return false;
14275   }
14276 
14277   if (Value) *Value = Result.getInt();
14278   return true;
14279 }
14280 
14281 bool Expr::isIntegerConstantExpr(const ASTContext &Ctx,
14282                                  SourceLocation *Loc) const {
14283   assert(!isValueDependent() &&
14284          "Expression evaluator can't be called on a dependent expression.");
14285 
14286   if (Ctx.getLangOpts().CPlusPlus11)
14287     return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, nullptr, Loc);
14288 
14289   ICEDiag D = CheckICE(this, Ctx);
14290   if (D.Kind != IK_ICE) {
14291     if (Loc) *Loc = D.Loc;
14292     return false;
14293   }
14294   return true;
14295 }
14296 
14297 bool Expr::isIntegerConstantExpr(llvm::APSInt &Value, const ASTContext &Ctx,
14298                                  SourceLocation *Loc, bool isEvaluated) const {
14299   assert(!isValueDependent() &&
14300          "Expression evaluator can't be called on a dependent expression.");
14301 
14302   if (Ctx.getLangOpts().CPlusPlus11)
14303     return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc);
14304 
14305   if (!isIntegerConstantExpr(Ctx, Loc))
14306     return false;
14307 
14308   // The only possible side-effects here are due to UB discovered in the
14309   // evaluation (for instance, INT_MAX + 1). In such a case, we are still
14310   // required to treat the expression as an ICE, so we produce the folded
14311   // value.
14312   EvalResult ExprResult;
14313   Expr::EvalStatus Status;
14314   EvalInfo Info(Ctx, Status, EvalInfo::EM_IgnoreSideEffects);
14315   Info.InConstantContext = true;
14316 
14317   if (!::EvaluateAsInt(this, ExprResult, Ctx, SE_AllowSideEffects, Info))
14318     llvm_unreachable("ICE cannot be evaluated!");
14319 
14320   Value = ExprResult.Val.getInt();
14321   return true;
14322 }
14323 
14324 bool Expr::isCXX98IntegralConstantExpr(const ASTContext &Ctx) const {
14325   assert(!isValueDependent() &&
14326          "Expression evaluator can't be called on a dependent expression.");
14327 
14328   return CheckICE(this, Ctx).Kind == IK_ICE;
14329 }
14330 
14331 bool Expr::isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result,
14332                                SourceLocation *Loc) const {
14333   assert(!isValueDependent() &&
14334          "Expression evaluator can't be called on a dependent expression.");
14335 
14336   // We support this checking in C++98 mode in order to diagnose compatibility
14337   // issues.
14338   assert(Ctx.getLangOpts().CPlusPlus);
14339 
14340   // Build evaluation settings.
14341   Expr::EvalStatus Status;
14342   SmallVector<PartialDiagnosticAt, 8> Diags;
14343   Status.Diag = &Diags;
14344   EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
14345 
14346   APValue Scratch;
14347   bool IsConstExpr =
14348       ::EvaluateAsRValue(Info, this, Result ? *Result : Scratch) &&
14349       // FIXME: We don't produce a diagnostic for this, but the callers that
14350       // call us on arbitrary full-expressions should generally not care.
14351       Info.discardCleanups() && !Status.HasSideEffects;
14352 
14353   if (!Diags.empty()) {
14354     IsConstExpr = false;
14355     if (Loc) *Loc = Diags[0].first;
14356   } else if (!IsConstExpr) {
14357     // FIXME: This shouldn't happen.
14358     if (Loc) *Loc = getExprLoc();
14359   }
14360 
14361   return IsConstExpr;
14362 }
14363 
14364 bool Expr::EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,
14365                                     const FunctionDecl *Callee,
14366                                     ArrayRef<const Expr*> Args,
14367                                     const Expr *This) const {
14368   assert(!isValueDependent() &&
14369          "Expression evaluator can't be called on a dependent expression.");
14370 
14371   Expr::EvalStatus Status;
14372   EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpressionUnevaluated);
14373   Info.InConstantContext = true;
14374 
14375   LValue ThisVal;
14376   const LValue *ThisPtr = nullptr;
14377   if (This) {
14378 #ifndef NDEBUG
14379     auto *MD = dyn_cast<CXXMethodDecl>(Callee);
14380     assert(MD && "Don't provide `this` for non-methods.");
14381     assert(!MD->isStatic() && "Don't provide `this` for static methods.");
14382 #endif
14383     if (!This->isValueDependent() &&
14384         EvaluateObjectArgument(Info, This, ThisVal) &&
14385         !Info.EvalStatus.HasSideEffects)
14386       ThisPtr = &ThisVal;
14387 
14388     // Ignore any side-effects from a failed evaluation. This is safe because
14389     // they can't interfere with any other argument evaluation.
14390     Info.EvalStatus.HasSideEffects = false;
14391   }
14392 
14393   ArgVector ArgValues(Args.size());
14394   for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end();
14395        I != E; ++I) {
14396     if ((*I)->isValueDependent() ||
14397         !Evaluate(ArgValues[I - Args.begin()], Info, *I) ||
14398         Info.EvalStatus.HasSideEffects)
14399       // If evaluation fails, throw away the argument entirely.
14400       ArgValues[I - Args.begin()] = APValue();
14401 
14402     // Ignore any side-effects from a failed evaluation. This is safe because
14403     // they can't interfere with any other argument evaluation.
14404     Info.EvalStatus.HasSideEffects = false;
14405   }
14406 
14407   // Parameter cleanups happen in the caller and are not part of this
14408   // evaluation.
14409   Info.discardCleanups();
14410   Info.EvalStatus.HasSideEffects = false;
14411 
14412   // Build fake call to Callee.
14413   CallStackFrame Frame(Info, Callee->getLocation(), Callee, ThisPtr,
14414                        ArgValues.data());
14415   // FIXME: Missing ExprWithCleanups in enable_if conditions?
14416   FullExpressionRAII Scope(Info);
14417   return Evaluate(Value, Info, this) && Scope.destroy() &&
14418          !Info.EvalStatus.HasSideEffects;
14419 }
14420 
14421 bool Expr::isPotentialConstantExpr(const FunctionDecl *FD,
14422                                    SmallVectorImpl<
14423                                      PartialDiagnosticAt> &Diags) {
14424   // FIXME: It would be useful to check constexpr function templates, but at the
14425   // moment the constant expression evaluator cannot cope with the non-rigorous
14426   // ASTs which we build for dependent expressions.
14427   if (FD->isDependentContext())
14428     return true;
14429 
14430   Expr::EvalStatus Status;
14431   Status.Diag = &Diags;
14432 
14433   EvalInfo Info(FD->getASTContext(), Status, EvalInfo::EM_ConstantExpression);
14434   Info.InConstantContext = true;
14435   Info.CheckingPotentialConstantExpression = true;
14436 
14437   // The constexpr VM attempts to compile all methods to bytecode here.
14438   if (Info.EnableNewConstInterp) {
14439     Info.Ctx.getInterpContext().isPotentialConstantExpr(Info, FD);
14440     return Diags.empty();
14441   }
14442 
14443   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
14444   const CXXRecordDecl *RD = MD ? MD->getParent()->getCanonicalDecl() : nullptr;
14445 
14446   // Fabricate an arbitrary expression on the stack and pretend that it
14447   // is a temporary being used as the 'this' pointer.
14448   LValue This;
14449   ImplicitValueInitExpr VIE(RD ? Info.Ctx.getRecordType(RD) : Info.Ctx.IntTy);
14450   This.set({&VIE, Info.CurrentCall->Index});
14451 
14452   ArrayRef<const Expr*> Args;
14453 
14454   APValue Scratch;
14455   if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
14456     // Evaluate the call as a constant initializer, to allow the construction
14457     // of objects of non-literal types.
14458     Info.setEvaluatingDecl(This.getLValueBase(), Scratch);
14459     HandleConstructorCall(&VIE, This, Args, CD, Info, Scratch);
14460   } else {
14461     SourceLocation Loc = FD->getLocation();
14462     HandleFunctionCall(Loc, FD, (MD && MD->isInstance()) ? &This : nullptr,
14463                        Args, FD->getBody(), Info, Scratch, nullptr);
14464   }
14465 
14466   return Diags.empty();
14467 }
14468 
14469 bool Expr::isPotentialConstantExprUnevaluated(Expr *E,
14470                                               const FunctionDecl *FD,
14471                                               SmallVectorImpl<
14472                                                 PartialDiagnosticAt> &Diags) {
14473   assert(!E->isValueDependent() &&
14474          "Expression evaluator can't be called on a dependent expression.");
14475 
14476   Expr::EvalStatus Status;
14477   Status.Diag = &Diags;
14478 
14479   EvalInfo Info(FD->getASTContext(), Status,
14480                 EvalInfo::EM_ConstantExpressionUnevaluated);
14481   Info.InConstantContext = true;
14482   Info.CheckingPotentialConstantExpression = true;
14483 
14484   // Fabricate a call stack frame to give the arguments a plausible cover story.
14485   ArrayRef<const Expr*> Args;
14486   ArgVector ArgValues(0);
14487   bool Success = EvaluateArgs(Args, ArgValues, Info, FD);
14488   (void)Success;
14489   assert(Success &&
14490          "Failed to set up arguments for potential constant evaluation");
14491   CallStackFrame Frame(Info, SourceLocation(), FD, nullptr, ArgValues.data());
14492 
14493   APValue ResultScratch;
14494   Evaluate(ResultScratch, Info, E);
14495   return Diags.empty();
14496 }
14497 
14498 bool Expr::tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
14499                                  unsigned Type) const {
14500   if (!getType()->isPointerType())
14501     return false;
14502 
14503   Expr::EvalStatus Status;
14504   EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
14505   return tryEvaluateBuiltinObjectSize(this, Type, Info, Result);
14506 }
14507