clang  8.0.0
ExprConstant.cpp
Go to the documentation of this file.
1 //===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Expr constant evaluator.
11 //
12 // Constant expression evaluation produces four main results:
13 //
14 // * A success/failure flag indicating whether constant folding was successful.
15 // This is the 'bool' return value used by most of the code in this file. A
16 // 'false' return value indicates that constant folding has failed, and any
17 // appropriate diagnostic has already been produced.
18 //
19 // * An evaluated result, valid only if constant folding has not failed.
20 //
21 // * A flag indicating if evaluation encountered (unevaluated) side-effects.
22 // These arise in cases such as (sideEffect(), 0) and (sideEffect() || 1),
23 // where it is possible to determine the evaluated result regardless.
24 //
25 // * A set of notes indicating why the evaluation was not a constant expression
26 // (under the C++11 / C++1y rules only, at the moment), or, if folding failed
27 // too, why the expression could not be folded.
28 //
29 // If we are checking for a potential constant expression, failure to constant
30 // fold a potential constant sub-expression will be indicated by a 'false'
31 // return value (the expression could not be folded) and no diagnostic (the
32 // expression is not necessarily non-constant).
33 //
34 //===----------------------------------------------------------------------===//
35 
36 #include "clang/AST/APValue.h"
37 #include "clang/AST/ASTContext.h"
39 #include "clang/AST/ASTLambda.h"
40 #include "clang/AST/CharUnits.h"
41 #include "clang/AST/Expr.h"
42 #include "clang/AST/OSLog.h"
43 #include "clang/AST/RecordLayout.h"
44 #include "clang/AST/StmtVisitor.h"
45 #include "clang/AST/TypeLoc.h"
46 #include "clang/Basic/Builtins.h"
47 #include "clang/Basic/TargetInfo.h"
48 #include "llvm/Support/SaveAndRestore.h"
49 #include "llvm/Support/raw_ostream.h"
50 #include <cstring>
51 #include <functional>
52 
53 #define DEBUG_TYPE "exprconstant"
54 
55 using namespace clang;
56 using llvm::APSInt;
57 using llvm::APFloat;
58 
59 static bool IsGlobalLValue(APValue::LValueBase B);
60 
61 namespace {
62  struct LValue;
63  struct CallStackFrame;
64  struct EvalInfo;
65 
66  static QualType getType(APValue::LValueBase B) {
67  if (!B) return QualType();
68  if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
69  // FIXME: It's unclear where we're supposed to take the type from, and
70  // this actually matters for arrays of unknown bound. Eg:
71  //
72  // extern int arr[]; void f() { extern int arr[3]; };
73  // constexpr int *p = &arr[1]; // valid?
74  //
75  // For now, we take the array bound from the most recent declaration.
76  for (auto *Redecl = cast<ValueDecl>(D->getMostRecentDecl()); Redecl;
77  Redecl = cast_or_null<ValueDecl>(Redecl->getPreviousDecl())) {
78  QualType T = Redecl->getType();
79  if (!T->isIncompleteArrayType())
80  return T;
81  }
82  return D->getType();
83  }
84 
85  const Expr *Base = B.get<const Expr*>();
86 
87  // For a materialized temporary, the type of the temporary we materialized
88  // may not be the type of the expression.
89  if (const MaterializeTemporaryExpr *MTE =
90  dyn_cast<MaterializeTemporaryExpr>(Base)) {
93  const Expr *Temp = MTE->GetTemporaryExpr();
94  const Expr *Inner = Temp->skipRValueSubobjectAdjustments(CommaLHSs,
95  Adjustments);
96  // Keep any cv-qualifiers from the reference if we generated a temporary
97  // for it directly. Otherwise use the type after adjustment.
98  if (!Adjustments.empty())
99  return Inner->getType();
100  }
101 
102  return Base->getType();
103  }
104 
105  /// Get an LValue path entry, which is known to not be an array index, as a
106  /// field or base class.
107  static
110  Value.setFromOpaqueValue(E.BaseOrMember);
111  return Value;
112  }
113 
114  /// Get an LValue path entry, which is known to not be an array index, as a
115  /// field declaration.
116  static const FieldDecl *getAsField(APValue::LValuePathEntry E) {
117  return dyn_cast<FieldDecl>(getAsBaseOrMember(E).getPointer());
118  }
119  /// Get an LValue path entry, which is known to not be an array index, as a
120  /// base class declaration.
121  static const CXXRecordDecl *getAsBaseClass(APValue::LValuePathEntry E) {
122  return dyn_cast<CXXRecordDecl>(getAsBaseOrMember(E).getPointer());
123  }
124  /// Determine whether this LValue path entry for a base class names a virtual
125  /// base class.
126  static bool isVirtualBaseClass(APValue::LValuePathEntry E) {
127  return getAsBaseOrMember(E).getInt();
128  }
129 
130  /// Given a CallExpr, try to get the alloc_size attribute. May return null.
131  static const AllocSizeAttr *getAllocSizeAttr(const CallExpr *CE) {
132  const FunctionDecl *Callee = CE->getDirectCallee();
133  return Callee ? Callee->getAttr<AllocSizeAttr>() : nullptr;
134  }
135 
136  /// Attempts to unwrap a CallExpr (with an alloc_size attribute) from an Expr.
137  /// This will look through a single cast.
138  ///
139  /// Returns null if we couldn't unwrap a function with alloc_size.
140  static const CallExpr *tryUnwrapAllocSizeCall(const Expr *E) {
141  if (!E->getType()->isPointerType())
142  return nullptr;
143 
144  E = E->IgnoreParens();
145  // If we're doing a variable assignment from e.g. malloc(N), there will
146  // probably be a cast of some kind. In exotic cases, we might also see a
147  // top-level ExprWithCleanups. Ignore them either way.
148  if (const auto *FE = dyn_cast<FullExpr>(E))
149  E = FE->getSubExpr()->IgnoreParens();
150 
151  if (const auto *Cast = dyn_cast<CastExpr>(E))
152  E = Cast->getSubExpr()->IgnoreParens();
153 
154  if (const auto *CE = dyn_cast<CallExpr>(E))
155  return getAllocSizeAttr(CE) ? CE : nullptr;
156  return nullptr;
157  }
158 
159  /// Determines whether or not the given Base contains a call to a function
160  /// with the alloc_size attribute.
161  static bool isBaseAnAllocSizeCall(APValue::LValueBase Base) {
162  const auto *E = Base.dyn_cast<const Expr *>();
163  return E && E->getType()->isPointerType() && tryUnwrapAllocSizeCall(E);
164  }
165 
166  /// The bound to claim that an array of unknown bound has.
167  /// The value in MostDerivedArraySize is undefined in this case. So, set it
168  /// to an arbitrary value that's likely to loudly break things if it's used.
169  static const uint64_t AssumedSizeForUnsizedArray =
171 
172  /// Determines if an LValue with the given LValueBase will have an unsized
173  /// array in its designator.
174  /// Find the path length and type of the most-derived subobject in the given
175  /// path, and find the size of the containing array, if any.
176  static unsigned
177  findMostDerivedSubobject(ASTContext &Ctx, APValue::LValueBase Base,
179  uint64_t &ArraySize, QualType &Type, bool &IsArray,
180  bool &FirstEntryIsUnsizedArray) {
181  // This only accepts LValueBases from APValues, and APValues don't support
182  // arrays that lack size info.
183  assert(!isBaseAnAllocSizeCall(Base) &&
184  "Unsized arrays shouldn't appear here");
185  unsigned MostDerivedLength = 0;
186  Type = getType(Base);
187 
188  for (unsigned I = 0, N = Path.size(); I != N; ++I) {
189  if (Type->isArrayType()) {
190  const ArrayType *AT = Ctx.getAsArrayType(Type);
191  Type = AT->getElementType();
192  MostDerivedLength = I + 1;
193  IsArray = true;
194 
195  if (auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
196  ArraySize = CAT->getSize().getZExtValue();
197  } else {
198  assert(I == 0 && "unexpected unsized array designator");
199  FirstEntryIsUnsizedArray = true;
200  ArraySize = AssumedSizeForUnsizedArray;
201  }
202  } else if (Type->isAnyComplexType()) {
203  const ComplexType *CT = Type->castAs<ComplexType>();
204  Type = CT->getElementType();
205  ArraySize = 2;
206  MostDerivedLength = I + 1;
207  IsArray = true;
208  } else if (const FieldDecl *FD = getAsField(Path[I])) {
209  Type = FD->getType();
210  ArraySize = 0;
211  MostDerivedLength = I + 1;
212  IsArray = false;
213  } else {
214  // Path[I] describes a base class.
215  ArraySize = 0;
216  IsArray = false;
217  }
218  }
219  return MostDerivedLength;
220  }
221 
222  // The order of this enum is important for diagnostics.
224  CSK_Base, CSK_Derived, CSK_Field, CSK_ArrayToPointer, CSK_ArrayIndex,
225  CSK_This, CSK_Real, CSK_Imag
226  };
227 
228  /// A path from a glvalue to a subobject of that glvalue.
229  struct SubobjectDesignator {
230  /// True if the subobject was named in a manner not supported by C++11. Such
231  /// lvalues can still be folded, but they are not core constant expressions
232  /// and we cannot perform lvalue-to-rvalue conversions on them.
233  unsigned Invalid : 1;
234 
235  /// Is this a pointer one past the end of an object?
236  unsigned IsOnePastTheEnd : 1;
237 
238  /// Indicator of whether the first entry is an unsized array.
239  unsigned FirstEntryIsAnUnsizedArray : 1;
240 
241  /// Indicator of whether the most-derived object is an array element.
242  unsigned MostDerivedIsArrayElement : 1;
243 
244  /// The length of the path to the most-derived object of which this is a
245  /// subobject.
246  unsigned MostDerivedPathLength : 28;
247 
248  /// The size of the array of which the most-derived object is an element.
249  /// This will always be 0 if the most-derived object is not an array
250  /// element. 0 is not an indicator of whether or not the most-derived object
251  /// is an array, however, because 0-length arrays are allowed.
252  ///
253  /// If the current array is an unsized array, the value of this is
254  /// undefined.
255  uint64_t MostDerivedArraySize;
256 
257  /// The type of the most derived object referred to by this address.
258  QualType MostDerivedType;
259 
260  typedef APValue::LValuePathEntry PathEntry;
261 
262  /// The entries on the path from the glvalue to the designated subobject.
264 
265  SubobjectDesignator() : Invalid(true) {}
266 
267  explicit SubobjectDesignator(QualType T)
268  : Invalid(false), IsOnePastTheEnd(false),
269  FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
270  MostDerivedPathLength(0), MostDerivedArraySize(0),
271  MostDerivedType(T) {}
272 
273  SubobjectDesignator(ASTContext &Ctx, const APValue &V)
274  : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false),
275  FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
276  MostDerivedPathLength(0), MostDerivedArraySize(0) {
277  assert(V.isLValue() && "Non-LValue used to make an LValue designator?");
278  if (!Invalid) {
279  IsOnePastTheEnd = V.isLValueOnePastTheEnd();
280  ArrayRef<PathEntry> VEntries = V.getLValuePath();
281  Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());
282  if (V.getLValueBase()) {
283  bool IsArray = false;
284  bool FirstIsUnsizedArray = false;
285  MostDerivedPathLength = findMostDerivedSubobject(
286  Ctx, V.getLValueBase(), V.getLValuePath(), MostDerivedArraySize,
287  MostDerivedType, IsArray, FirstIsUnsizedArray);
288  MostDerivedIsArrayElement = IsArray;
289  FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
290  }
291  }
292  }
293 
294  void setInvalid() {
295  Invalid = true;
296  Entries.clear();
297  }
298 
299  /// Determine whether the most derived subobject is an array without a
300  /// known bound.
301  bool isMostDerivedAnUnsizedArray() const {
302  assert(!Invalid && "Calling this makes no sense on invalid designators");
303  return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;
304  }
305 
306  /// Determine what the most derived array's size is. Results in an assertion
307  /// failure if the most derived array lacks a size.
308  uint64_t getMostDerivedArraySize() const {
309  assert(!isMostDerivedAnUnsizedArray() && "Unsized array has no size");
310  return MostDerivedArraySize;
311  }
312 
313  /// Determine whether this is a one-past-the-end pointer.
314  bool isOnePastTheEnd() const {
315  assert(!Invalid);
316  if (IsOnePastTheEnd)
317  return true;
318  if (!isMostDerivedAnUnsizedArray() && MostDerivedIsArrayElement &&
319  Entries[MostDerivedPathLength - 1].ArrayIndex == MostDerivedArraySize)
320  return true;
321  return false;
322  }
323 
324  /// Get the range of valid index adjustments in the form
325  /// {maximum value that can be subtracted from this pointer,
326  /// maximum value that can be added to this pointer}
327  std::pair<uint64_t, uint64_t> validIndexAdjustments() {
328  if (Invalid || isMostDerivedAnUnsizedArray())
329  return {0, 0};
330 
331  // [expr.add]p4: For the purposes of these operators, a pointer to a
332  // nonarray object behaves the same as a pointer to the first element of
333  // an array of length one with the type of the object as its element type.
334  bool IsArray = MostDerivedPathLength == Entries.size() &&
335  MostDerivedIsArrayElement;
336  uint64_t ArrayIndex =
337  IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd;
338  uint64_t ArraySize =
339  IsArray ? getMostDerivedArraySize() : (uint64_t)1;
340  return {ArrayIndex, ArraySize - ArrayIndex};
341  }
342 
343  /// Check that this refers to a valid subobject.
344  bool isValidSubobject() const {
345  if (Invalid)
346  return false;
347  return !isOnePastTheEnd();
348  }
349  /// Check that this refers to a valid subobject, and if not, produce a
350  /// relevant diagnostic and set the designator as invalid.
351  bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK);
352 
353  /// Get the type of the designated object.
354  QualType getType(ASTContext &Ctx) const {
355  assert(!Invalid && "invalid designator has no subobject type");
356  return MostDerivedPathLength == Entries.size()
357  ? MostDerivedType
358  : Ctx.getRecordType(getAsBaseClass(Entries.back()));
359  }
360 
361  /// Update this designator to refer to the first element within this array.
362  void addArrayUnchecked(const ConstantArrayType *CAT) {
363  PathEntry Entry;
364  Entry.ArrayIndex = 0;
365  Entries.push_back(Entry);
366 
367  // This is a most-derived object.
368  MostDerivedType = CAT->getElementType();
369  MostDerivedIsArrayElement = true;
370  MostDerivedArraySize = CAT->getSize().getZExtValue();
371  MostDerivedPathLength = Entries.size();
372  }
373  /// Update this designator to refer to the first element within the array of
374  /// elements of type T. This is an array of unknown size.
375  void addUnsizedArrayUnchecked(QualType ElemTy) {
376  PathEntry Entry;
377  Entry.ArrayIndex = 0;
378  Entries.push_back(Entry);
379 
380  MostDerivedType = ElemTy;
381  MostDerivedIsArrayElement = true;
382  // The value in MostDerivedArraySize is undefined in this case. So, set it
383  // to an arbitrary value that's likely to loudly break things if it's
384  // used.
385  MostDerivedArraySize = AssumedSizeForUnsizedArray;
386  MostDerivedPathLength = Entries.size();
387  }
388  /// Update this designator to refer to the given base or member of this
389  /// object.
390  void addDeclUnchecked(const Decl *D, bool Virtual = false) {
391  PathEntry Entry;
392  APValue::BaseOrMemberType Value(D, Virtual);
393  Entry.BaseOrMember = Value.getOpaqueValue();
394  Entries.push_back(Entry);
395 
396  // If this isn't a base class, it's a new most-derived object.
397  if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
398  MostDerivedType = FD->getType();
399  MostDerivedIsArrayElement = false;
400  MostDerivedArraySize = 0;
401  MostDerivedPathLength = Entries.size();
402  }
403  }
404  /// Update this designator to refer to the given complex component.
405  void addComplexUnchecked(QualType EltTy, bool Imag) {
406  PathEntry Entry;
407  Entry.ArrayIndex = Imag;
408  Entries.push_back(Entry);
409 
410  // This is technically a most-derived object, though in practice this
411  // is unlikely to matter.
412  MostDerivedType = EltTy;
413  MostDerivedIsArrayElement = true;
414  MostDerivedArraySize = 2;
415  MostDerivedPathLength = Entries.size();
416  }
417  void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, const Expr *E);
418  void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
419  const APSInt &N);
420  /// Add N to the address of this subobject.
421  void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
422  if (Invalid || !N) return;
423  uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
424  if (isMostDerivedAnUnsizedArray()) {
425  diagnoseUnsizedArrayPointerArithmetic(Info, E);
426  // Can't verify -- trust that the user is doing the right thing (or if
427  // not, trust that the caller will catch the bad behavior).
428  // FIXME: Should we reject if this overflows, at least?
429  Entries.back().ArrayIndex += TruncatedN;
430  return;
431  }
432 
433  // [expr.add]p4: For the purposes of these operators, a pointer to a
434  // nonarray object behaves the same as a pointer to the first element of
435  // an array of length one with the type of the object as its element type.
436  bool IsArray = MostDerivedPathLength == Entries.size() &&
437  MostDerivedIsArrayElement;
438  uint64_t ArrayIndex =
439  IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd;
440  uint64_t ArraySize =
441  IsArray ? getMostDerivedArraySize() : (uint64_t)1;
442 
443  if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
444  // Calculate the actual index in a wide enough type, so we can include
445  // it in the note.
446  N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
447  (llvm::APInt&)N += ArrayIndex;
448  assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index");
449  diagnosePointerArithmetic(Info, E, N);
450  setInvalid();
451  return;
452  }
453 
454  ArrayIndex += TruncatedN;
455  assert(ArrayIndex <= ArraySize &&
456  "bounds check succeeded for out-of-bounds index");
457 
458  if (IsArray)
459  Entries.back().ArrayIndex = ArrayIndex;
460  else
461  IsOnePastTheEnd = (ArrayIndex != 0);
462  }
463  };
464 
465  /// A stack frame in the constexpr call stack.
466  struct CallStackFrame {
467  EvalInfo &Info;
468 
469  /// Parent - The caller of this stack frame.
470  CallStackFrame *Caller;
471 
472  /// Callee - The function which was called.
473  const FunctionDecl *Callee;
474 
475  /// This - The binding for the this pointer in this call, if any.
476  const LValue *This;
477 
478  /// Arguments - Parameter bindings for this function call, indexed by
479  /// parameters' function scope indices.
480  APValue *Arguments;
481 
482  // Note that we intentionally use std::map here so that references to
483  // values are stable.
484  typedef std::pair<const void *, unsigned> MapKeyTy;
485  typedef std::map<MapKeyTy, APValue> MapTy;
486  /// Temporaries - Temporary lvalues materialized within this stack frame.
487  MapTy Temporaries;
488 
489  /// CallLoc - The location of the call expression for this call.
490  SourceLocation CallLoc;
491 
492  /// Index - The call index of this call.
493  unsigned Index;
494 
495  /// The stack of integers for tracking version numbers for temporaries.
496  SmallVector<unsigned, 2> TempVersionStack = {1};
497  unsigned CurTempVersion = TempVersionStack.back();
498 
499  unsigned getTempVersion() const { return TempVersionStack.back(); }
500 
501  void pushTempVersion() {
502  TempVersionStack.push_back(++CurTempVersion);
503  }
504 
505  void popTempVersion() {
506  TempVersionStack.pop_back();
507  }
508 
509  // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact
510  // on the overall stack usage of deeply-recursing constexpr evaluations.
511  // (We should cache this map rather than recomputing it repeatedly.)
512  // But let's try this and see how it goes; we can look into caching the map
513  // as a later change.
514 
515  /// LambdaCaptureFields - Mapping from captured variables/this to
516  /// corresponding data members in the closure class.
517  llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
518  FieldDecl *LambdaThisCaptureField;
519 
520  CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
521  const FunctionDecl *Callee, const LValue *This,
522  APValue *Arguments);
523  ~CallStackFrame();
524 
525  // Return the temporary for Key whose version number is Version.
526  APValue *getTemporary(const void *Key, unsigned Version) {
527  MapKeyTy KV(Key, Version);
528  auto LB = Temporaries.lower_bound(KV);
529  if (LB != Temporaries.end() && LB->first == KV)
530  return &LB->second;
531  // Pair (Key,Version) wasn't found in the map. Check that no elements
532  // in the map have 'Key' as their key.
533  assert((LB == Temporaries.end() || LB->first.first != Key) &&
534  (LB == Temporaries.begin() || std::prev(LB)->first.first != Key) &&
535  "Element with key 'Key' found in map");
536  return nullptr;
537  }
538 
539  // Return the current temporary for Key in the map.
540  APValue *getCurrentTemporary(const void *Key) {
541  auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
542  if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
543  return &std::prev(UB)->second;
544  return nullptr;
545  }
546 
547  // Return the version number of the current temporary for Key.
548  unsigned getCurrentTemporaryVersion(const void *Key) const {
549  auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
550  if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
551  return std::prev(UB)->first.second;
552  return 0;
553  }
554 
555  APValue &createTemporary(const void *Key, bool IsLifetimeExtended);
556  };
557 
558  /// Temporarily override 'this'.
559  class ThisOverrideRAII {
560  public:
561  ThisOverrideRAII(CallStackFrame &Frame, const LValue *NewThis, bool Enable)
562  : Frame(Frame), OldThis(Frame.This) {
563  if (Enable)
564  Frame.This = NewThis;
565  }
566  ~ThisOverrideRAII() {
567  Frame.This = OldThis;
568  }
569  private:
570  CallStackFrame &Frame;
571  const LValue *OldThis;
572  };
573 
574  /// A partial diagnostic which we might know in advance that we are not going
575  /// to emit.
576  class OptionalDiagnostic {
578 
579  public:
580  explicit OptionalDiagnostic(PartialDiagnostic *Diag = nullptr)
581  : Diag(Diag) {}
582 
583  template<typename T>
584  OptionalDiagnostic &operator<<(const T &v) {
585  if (Diag)
586  *Diag << v;
587  return *this;
588  }
589 
590  OptionalDiagnostic &operator<<(const APSInt &I) {
591  if (Diag) {
592  SmallVector<char, 32> Buffer;
593  I.toString(Buffer);
594  *Diag << StringRef(Buffer.data(), Buffer.size());
595  }
596  return *this;
597  }
598 
599  OptionalDiagnostic &operator<<(const APFloat &F) {
600  if (Diag) {
601  // FIXME: Force the precision of the source value down so we don't
602  // print digits which are usually useless (we don't really care here if
603  // we truncate a digit by accident in edge cases). Ideally,
604  // APFloat::toString would automatically print the shortest
605  // representation which rounds to the correct value, but it's a bit
606  // tricky to implement.
607  unsigned precision =
608  llvm::APFloat::semanticsPrecision(F.getSemantics());
609  precision = (precision * 59 + 195) / 196;
610  SmallVector<char, 32> Buffer;
611  F.toString(Buffer, precision);
612  *Diag << StringRef(Buffer.data(), Buffer.size());
613  }
614  return *this;
615  }
616  };
617 
618  /// A cleanup, and a flag indicating whether it is lifetime-extended.
619  class Cleanup {
620  llvm::PointerIntPair<APValue*, 1, bool> Value;
621 
622  public:
623  Cleanup(APValue *Val, bool IsLifetimeExtended)
624  : Value(Val, IsLifetimeExtended) {}
625 
626  bool isLifetimeExtended() const { return Value.getInt(); }
627  void endLifetime() {
628  *Value.getPointer() = APValue();
629  }
630  };
631 
632  /// EvalInfo - This is a private struct used by the evaluator to capture
633  /// information about a subexpression as it is folded. It retains information
634  /// about the AST context, but also maintains information about the folded
635  /// expression.
636  ///
637  /// If an expression could be evaluated, it is still possible it is not a C
638  /// "integer constant expression" or constant expression. If not, this struct
639  /// captures information about how and why not.
640  ///
641  /// One bit of information passed *into* the request for constant folding
642  /// indicates whether the subexpression is "evaluated" or not according to C
643  /// rules. For example, the RHS of (0 && foo()) is not evaluated. We can
644  /// evaluate the expression regardless of what the RHS is, but C only allows
645  /// certain things in certain situations.
646  struct EvalInfo {
647  ASTContext &Ctx;
648 
649  /// EvalStatus - Contains information about the evaluation.
650  Expr::EvalStatus &EvalStatus;
651 
652  /// CurrentCall - The top of the constexpr call stack.
653  CallStackFrame *CurrentCall;
654 
655  /// CallStackDepth - The number of calls in the call stack right now.
656  unsigned CallStackDepth;
657 
658  /// NextCallIndex - The next call index to assign.
659  unsigned NextCallIndex;
660 
661  /// StepsLeft - The remaining number of evaluation steps we're permitted
662  /// to perform. This is essentially a limit for the number of statements
663  /// we will evaluate.
664  unsigned StepsLeft;
665 
666  /// BottomFrame - The frame in which evaluation started. This must be
667  /// initialized after CurrentCall and CallStackDepth.
668  CallStackFrame BottomFrame;
669 
670  /// A stack of values whose lifetimes end at the end of some surrounding
671  /// evaluation frame.
672  llvm::SmallVector<Cleanup, 16> CleanupStack;
673 
674  /// EvaluatingDecl - This is the declaration whose initializer is being
675  /// evaluated, if any.
676  APValue::LValueBase EvaluatingDecl;
677 
678  /// EvaluatingDeclValue - This is the value being constructed for the
679  /// declaration whose initializer is being evaluated, if any.
680  APValue *EvaluatingDeclValue;
681 
682  /// EvaluatingObject - Pair of the AST node that an lvalue represents and
683  /// the call index that that lvalue was allocated in.
684  typedef std::pair<APValue::LValueBase, std::pair<unsigned, unsigned>>
685  EvaluatingObject;
686 
687  /// EvaluatingConstructors - Set of objects that are currently being
688  /// constructed.
689  llvm::DenseSet<EvaluatingObject> EvaluatingConstructors;
690 
691  struct EvaluatingConstructorRAII {
692  EvalInfo &EI;
693  EvaluatingObject Object;
694  bool DidInsert;
695  EvaluatingConstructorRAII(EvalInfo &EI, EvaluatingObject Object)
696  : EI(EI), Object(Object) {
697  DidInsert = EI.EvaluatingConstructors.insert(Object).second;
698  }
699  ~EvaluatingConstructorRAII() {
700  if (DidInsert) EI.EvaluatingConstructors.erase(Object);
701  }
702  };
703 
704  bool isEvaluatingConstructor(APValue::LValueBase Decl, unsigned CallIndex,
705  unsigned Version) {
706  return EvaluatingConstructors.count(
707  EvaluatingObject(Decl, {CallIndex, Version}));
708  }
709 
710  /// The current array initialization index, if we're performing array
711  /// initialization.
712  uint64_t ArrayInitIndex = -1;
713 
714  /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further
715  /// notes attached to it will also be stored, otherwise they will not be.
716  bool HasActiveDiagnostic;
717 
718  /// Have we emitted a diagnostic explaining why we couldn't constant
719  /// fold (not just why it's not strictly a constant expression)?
720  bool HasFoldFailureDiagnostic;
721 
722  /// Whether or not we're currently speculatively evaluating.
723  bool IsSpeculativelyEvaluating;
724 
725  /// Whether or not we're in a context where the front end requires a
726  /// constant value.
727  bool InConstantContext;
728 
729  enum EvaluationMode {
730  /// Evaluate as a constant expression. Stop if we find that the expression
731  /// is not a constant expression.
732  EM_ConstantExpression,
733 
734  /// Evaluate as a potential constant expression. Keep going if we hit a
735  /// construct that we can't evaluate yet (because we don't yet know the
736  /// value of something) but stop if we hit something that could never be
737  /// a constant expression.
738  EM_PotentialConstantExpression,
739 
740  /// Fold the expression to a constant. Stop if we hit a side-effect that
741  /// we can't model.
742  EM_ConstantFold,
743 
744  /// Evaluate the expression looking for integer overflow and similar
745  /// issues. Don't worry about side-effects, and try to visit all
746  /// subexpressions.
747  EM_EvaluateForOverflow,
748 
749  /// Evaluate in any way we know how. Don't worry about side-effects that
750  /// can't be modeled.
751  EM_IgnoreSideEffects,
752 
753  /// Evaluate as a constant expression. Stop if we find that the expression
754  /// is not a constant expression. Some expressions can be retried in the
755  /// optimizer if we don't constant fold them here, but in an unevaluated
756  /// context we try to fold them immediately since the optimizer never
757  /// gets a chance to look at it.
758  EM_ConstantExpressionUnevaluated,
759 
760  /// Evaluate as a potential constant expression. Keep going if we hit a
761  /// construct that we can't evaluate yet (because we don't yet know the
762  /// value of something) but stop if we hit something that could never be
763  /// a constant expression. Some expressions can be retried in the
764  /// optimizer if we don't constant fold them here, but in an unevaluated
765  /// context we try to fold them immediately since the optimizer never
766  /// gets a chance to look at it.
767  EM_PotentialConstantExpressionUnevaluated,
768  } EvalMode;
769 
770  /// Are we checking whether the expression is a potential constant
771  /// expression?
772  bool checkingPotentialConstantExpression() const {
773  return EvalMode == EM_PotentialConstantExpression ||
774  EvalMode == EM_PotentialConstantExpressionUnevaluated;
775  }
776 
777  /// Are we checking an expression for overflow?
778  // FIXME: We should check for any kind of undefined or suspicious behavior
779  // in such constructs, not just overflow.
780  bool checkingForOverflow() { return EvalMode == EM_EvaluateForOverflow; }
781 
782  EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
783  : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
784  CallStackDepth(0), NextCallIndex(1),
785  StepsLeft(getLangOpts().ConstexprStepLimit),
786  BottomFrame(*this, SourceLocation(), nullptr, nullptr, nullptr),
787  EvaluatingDecl((const ValueDecl *)nullptr),
788  EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
789  HasFoldFailureDiagnostic(false), IsSpeculativelyEvaluating(false),
790  InConstantContext(false), EvalMode(Mode) {}
791 
792  void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value) {
793  EvaluatingDecl = Base;
794  EvaluatingDeclValue = &Value;
795  EvaluatingConstructors.insert({Base, {0, 0}});
796  }
797 
798  const LangOptions &getLangOpts() const { return Ctx.getLangOpts(); }
799 
800  bool CheckCallLimit(SourceLocation Loc) {
801  // Don't perform any constexpr calls (other than the call we're checking)
802  // when checking a potential constant expression.
803  if (checkingPotentialConstantExpression() && CallStackDepth > 1)
804  return false;
805  if (NextCallIndex == 0) {
806  // NextCallIndex has wrapped around.
807  FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);
808  return false;
809  }
810  if (CallStackDepth <= getLangOpts().ConstexprCallDepth)
811  return true;
812  FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded)
813  << getLangOpts().ConstexprCallDepth;
814  return false;
815  }
816 
817  CallStackFrame *getCallFrame(unsigned CallIndex) {
818  assert(CallIndex && "no call index in getCallFrame");
819  // We will eventually hit BottomFrame, which has Index 1, so Frame can't
820  // be null in this loop.
821  CallStackFrame *Frame = CurrentCall;
822  while (Frame->Index > CallIndex)
823  Frame = Frame->Caller;
824  return (Frame->Index == CallIndex) ? Frame : nullptr;
825  }
826 
827  bool nextStep(const Stmt *S) {
828  if (!StepsLeft) {
829  FFDiag(S->getBeginLoc(), diag::note_constexpr_step_limit_exceeded);
830  return false;
831  }
832  --StepsLeft;
833  return true;
834  }
835 
836  private:
837  /// Add a diagnostic to the diagnostics list.
838  PartialDiagnostic &addDiag(SourceLocation Loc, diag::kind DiagId) {
839  PartialDiagnostic PD(DiagId, Ctx.getDiagAllocator());
840  EvalStatus.Diag->push_back(std::make_pair(Loc, PD));
841  return EvalStatus.Diag->back().second;
842  }
843 
844  /// Add notes containing a call stack to the current point of evaluation.
845  void addCallStack(unsigned Limit);
846 
847  private:
848  OptionalDiagnostic Diag(SourceLocation Loc, diag::kind DiagId,
849  unsigned ExtraNotes, bool IsCCEDiag) {
850 
851  if (EvalStatus.Diag) {
852  // If we have a prior diagnostic, it will be noting that the expression
853  // isn't a constant expression. This diagnostic is more important,
854  // unless we require this evaluation to produce a constant expression.
855  //
856  // FIXME: We might want to show both diagnostics to the user in
857  // EM_ConstantFold mode.
858  if (!EvalStatus.Diag->empty()) {
859  switch (EvalMode) {
860  case EM_ConstantFold:
861  case EM_IgnoreSideEffects:
862  case EM_EvaluateForOverflow:
863  if (!HasFoldFailureDiagnostic)
864  break;
865  // We've already failed to fold something. Keep that diagnostic.
866  LLVM_FALLTHROUGH;
867  case EM_ConstantExpression:
868  case EM_PotentialConstantExpression:
869  case EM_ConstantExpressionUnevaluated:
870  case EM_PotentialConstantExpressionUnevaluated:
871  HasActiveDiagnostic = false;
872  return OptionalDiagnostic();
873  }
874  }
875 
876  unsigned CallStackNotes = CallStackDepth - 1;
877  unsigned Limit = Ctx.getDiagnostics().getConstexprBacktraceLimit();
878  if (Limit)
879  CallStackNotes = std::min(CallStackNotes, Limit + 1);
880  if (checkingPotentialConstantExpression())
881  CallStackNotes = 0;
882 
883  HasActiveDiagnostic = true;
884  HasFoldFailureDiagnostic = !IsCCEDiag;
885  EvalStatus.Diag->clear();
886  EvalStatus.Diag->reserve(1 + ExtraNotes + CallStackNotes);
887  addDiag(Loc, DiagId);
888  if (!checkingPotentialConstantExpression())
889  addCallStack(Limit);
890  return OptionalDiagnostic(&(*EvalStatus.Diag)[0].second);
891  }
892  HasActiveDiagnostic = false;
893  return OptionalDiagnostic();
894  }
895  public:
896  // Diagnose that the evaluation could not be folded (FF => FoldFailure)
897  OptionalDiagnostic
898  FFDiag(SourceLocation Loc,
899  diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
900  unsigned ExtraNotes = 0) {
901  return Diag(Loc, DiagId, ExtraNotes, false);
902  }
903 
904  OptionalDiagnostic FFDiag(const Expr *E, diag::kind DiagId
905  = diag::note_invalid_subexpr_in_const_expr,
906  unsigned ExtraNotes = 0) {
907  if (EvalStatus.Diag)
908  return Diag(E->getExprLoc(), DiagId, ExtraNotes, /*IsCCEDiag*/false);
909  HasActiveDiagnostic = false;
910  return OptionalDiagnostic();
911  }
912 
913  /// Diagnose that the evaluation does not produce a C++11 core constant
914  /// expression.
915  ///
916  /// FIXME: Stop evaluating if we're in EM_ConstantExpression or
917  /// EM_PotentialConstantExpression mode and we produce one of these.
918  OptionalDiagnostic CCEDiag(SourceLocation Loc, diag::kind DiagId
919  = diag::note_invalid_subexpr_in_const_expr,
920  unsigned ExtraNotes = 0) {
921  // Don't override a previous diagnostic. Don't bother collecting
922  // diagnostics if we're evaluating for overflow.
923  if (!EvalStatus.Diag || !EvalStatus.Diag->empty()) {
924  HasActiveDiagnostic = false;
925  return OptionalDiagnostic();
926  }
927  return Diag(Loc, DiagId, ExtraNotes, true);
928  }
929  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind DiagId
930  = diag::note_invalid_subexpr_in_const_expr,
931  unsigned ExtraNotes = 0) {
932  return CCEDiag(E->getExprLoc(), DiagId, ExtraNotes);
933  }
934  /// Add a note to a prior diagnostic.
935  OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId) {
936  if (!HasActiveDiagnostic)
937  return OptionalDiagnostic();
938  return OptionalDiagnostic(&addDiag(Loc, DiagId));
939  }
940 
941  /// Add a stack of notes to a prior diagnostic.
942  void addNotes(ArrayRef<PartialDiagnosticAt> Diags) {
943  if (HasActiveDiagnostic) {
944  EvalStatus.Diag->insert(EvalStatus.Diag->end(),
945  Diags.begin(), Diags.end());
946  }
947  }
948 
949  /// Should we continue evaluation after encountering a side-effect that we
950  /// couldn't model?
951  bool keepEvaluatingAfterSideEffect() {
952  switch (EvalMode) {
953  case EM_PotentialConstantExpression:
954  case EM_PotentialConstantExpressionUnevaluated:
955  case EM_EvaluateForOverflow:
956  case EM_IgnoreSideEffects:
957  return true;
958 
959  case EM_ConstantExpression:
960  case EM_ConstantExpressionUnevaluated:
961  case EM_ConstantFold:
962  return false;
963  }
964  llvm_unreachable("Missed EvalMode case");
965  }
966 
967  /// Note that we have had a side-effect, and determine whether we should
968  /// keep evaluating.
969  bool noteSideEffect() {
970  EvalStatus.HasSideEffects = true;
971  return keepEvaluatingAfterSideEffect();
972  }
973 
974  /// Should we continue evaluation after encountering undefined behavior?
975  bool keepEvaluatingAfterUndefinedBehavior() {
976  switch (EvalMode) {
977  case EM_EvaluateForOverflow:
978  case EM_IgnoreSideEffects:
979  case EM_ConstantFold:
980  return true;
981 
982  case EM_PotentialConstantExpression:
983  case EM_PotentialConstantExpressionUnevaluated:
984  case EM_ConstantExpression:
985  case EM_ConstantExpressionUnevaluated:
986  return false;
987  }
988  llvm_unreachable("Missed EvalMode case");
989  }
990 
991  /// Note that we hit something that was technically undefined behavior, but
992  /// that we can evaluate past it (such as signed overflow or floating-point
993  /// division by zero.)
994  bool noteUndefinedBehavior() {
995  EvalStatus.HasUndefinedBehavior = true;
996  return keepEvaluatingAfterUndefinedBehavior();
997  }
998 
999  /// Should we continue evaluation as much as possible after encountering a
1000  /// construct which can't be reduced to a value?
1001  bool keepEvaluatingAfterFailure() {
1002  if (!StepsLeft)
1003  return false;
1004 
1005  switch (EvalMode) {
1006  case EM_PotentialConstantExpression:
1007  case EM_PotentialConstantExpressionUnevaluated:
1008  case EM_EvaluateForOverflow:
1009  return true;
1010 
1011  case EM_ConstantExpression:
1012  case EM_ConstantExpressionUnevaluated:
1013  case EM_ConstantFold:
1014  case EM_IgnoreSideEffects:
1015  return false;
1016  }
1017  llvm_unreachable("Missed EvalMode case");
1018  }
1019 
1020  /// Notes that we failed to evaluate an expression that other expressions
1021  /// directly depend on, and determine if we should keep evaluating. This
1022  /// should only be called if we actually intend to keep evaluating.
1023  ///
1024  /// Call noteSideEffect() instead if we may be able to ignore the value that
1025  /// we failed to evaluate, e.g. if we failed to evaluate Foo() in:
1026  ///
1027  /// (Foo(), 1) // use noteSideEffect
1028  /// (Foo() || true) // use noteSideEffect
1029  /// Foo() + 1 // use noteFailure
1030  LLVM_NODISCARD bool noteFailure() {
1031  // Failure when evaluating some expression often means there is some
1032  // subexpression whose evaluation was skipped. Therefore, (because we
1033  // don't track whether we skipped an expression when unwinding after an
1034  // evaluation failure) every evaluation failure that bubbles up from a
1035  // subexpression implies that a side-effect has potentially happened. We
1036  // skip setting the HasSideEffects flag to true until we decide to
1037  // continue evaluating after that point, which happens here.
1038  bool KeepGoing = keepEvaluatingAfterFailure();
1039  EvalStatus.HasSideEffects |= KeepGoing;
1040  return KeepGoing;
1041  }
1042 
1043  class ArrayInitLoopIndex {
1044  EvalInfo &Info;
1045  uint64_t OuterIndex;
1046 
1047  public:
1048  ArrayInitLoopIndex(EvalInfo &Info)
1049  : Info(Info), OuterIndex(Info.ArrayInitIndex) {
1050  Info.ArrayInitIndex = 0;
1051  }
1052  ~ArrayInitLoopIndex() { Info.ArrayInitIndex = OuterIndex; }
1053 
1054  operator uint64_t&() { return Info.ArrayInitIndex; }
1055  };
1056  };
1057 
1058  /// Object used to treat all foldable expressions as constant expressions.
1059  struct FoldConstant {
1060  EvalInfo &Info;
1061  bool Enabled;
1062  bool HadNoPriorDiags;
1063  EvalInfo::EvaluationMode OldMode;
1064 
1065  explicit FoldConstant(EvalInfo &Info, bool Enabled)
1066  : Info(Info),
1067  Enabled(Enabled),
1068  HadNoPriorDiags(Info.EvalStatus.Diag &&
1069  Info.EvalStatus.Diag->empty() &&
1070  !Info.EvalStatus.HasSideEffects),
1071  OldMode(Info.EvalMode) {
1072  if (Enabled &&
1073  (Info.EvalMode == EvalInfo::EM_ConstantExpression ||
1074  Info.EvalMode == EvalInfo::EM_ConstantExpressionUnevaluated))
1075  Info.EvalMode = EvalInfo::EM_ConstantFold;
1076  }
1077  void keepDiagnostics() { Enabled = false; }
1078  ~FoldConstant() {
1079  if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
1080  !Info.EvalStatus.HasSideEffects)
1081  Info.EvalStatus.Diag->clear();
1082  Info.EvalMode = OldMode;
1083  }
1084  };
1085 
1086  /// RAII object used to set the current evaluation mode to ignore
1087  /// side-effects.
1088  struct IgnoreSideEffectsRAII {
1089  EvalInfo &Info;
1090  EvalInfo::EvaluationMode OldMode;
1091  explicit IgnoreSideEffectsRAII(EvalInfo &Info)
1092  : Info(Info), OldMode(Info.EvalMode) {
1093  if (!Info.checkingPotentialConstantExpression())
1094  Info.EvalMode = EvalInfo::EM_IgnoreSideEffects;
1095  }
1096 
1097  ~IgnoreSideEffectsRAII() { Info.EvalMode = OldMode; }
1098  };
1099 
1100  /// RAII object used to optionally suppress diagnostics and side-effects from
1101  /// a speculative evaluation.
1102  class SpeculativeEvaluationRAII {
1103  EvalInfo *Info = nullptr;
1104  Expr::EvalStatus OldStatus;
1105  bool OldIsSpeculativelyEvaluating;
1106 
1107  void moveFromAndCancel(SpeculativeEvaluationRAII &&Other) {
1108  Info = Other.Info;
1109  OldStatus = Other.OldStatus;
1110  OldIsSpeculativelyEvaluating = Other.OldIsSpeculativelyEvaluating;
1111  Other.Info = nullptr;
1112  }
1113 
1114  void maybeRestoreState() {
1115  if (!Info)
1116  return;
1117 
1118  Info->EvalStatus = OldStatus;
1119  Info->IsSpeculativelyEvaluating = OldIsSpeculativelyEvaluating;
1120  }
1121 
1122  public:
1123  SpeculativeEvaluationRAII() = default;
1124 
1125  SpeculativeEvaluationRAII(
1126  EvalInfo &Info, SmallVectorImpl<PartialDiagnosticAt> *NewDiag = nullptr)
1127  : Info(&Info), OldStatus(Info.EvalStatus),
1128  OldIsSpeculativelyEvaluating(Info.IsSpeculativelyEvaluating) {
1129  Info.EvalStatus.Diag = NewDiag;
1130  Info.IsSpeculativelyEvaluating = true;
1131  }
1132 
1133  SpeculativeEvaluationRAII(const SpeculativeEvaluationRAII &Other) = delete;
1134  SpeculativeEvaluationRAII(SpeculativeEvaluationRAII &&Other) {
1135  moveFromAndCancel(std::move(Other));
1136  }
1137 
1138  SpeculativeEvaluationRAII &operator=(SpeculativeEvaluationRAII &&Other) {
1139  maybeRestoreState();
1140  moveFromAndCancel(std::move(Other));
1141  return *this;
1142  }
1143 
1144  ~SpeculativeEvaluationRAII() { maybeRestoreState(); }
1145  };
1146 
1147  /// RAII object wrapping a full-expression or block scope, and handling
1148  /// the ending of the lifetime of temporaries created within it.
1149  template<bool IsFullExpression>
1150  class ScopeRAII {
1151  EvalInfo &Info;
1152  unsigned OldStackSize;
1153  public:
1154  ScopeRAII(EvalInfo &Info)
1155  : Info(Info), OldStackSize(Info.CleanupStack.size()) {
1156  // Push a new temporary version. This is needed to distinguish between
1157  // temporaries created in different iterations of a loop.
1158  Info.CurrentCall->pushTempVersion();
1159  }
1160  ~ScopeRAII() {
1161  // Body moved to a static method to encourage the compiler to inline away
1162  // instances of this class.
1163  cleanup(Info, OldStackSize);
1164  Info.CurrentCall->popTempVersion();
1165  }
1166  private:
1167  static void cleanup(EvalInfo &Info, unsigned OldStackSize) {
1168  unsigned NewEnd = OldStackSize;
1169  for (unsigned I = OldStackSize, N = Info.CleanupStack.size();
1170  I != N; ++I) {
1171  if (IsFullExpression && Info.CleanupStack[I].isLifetimeExtended()) {
1172  // Full-expression cleanup of a lifetime-extended temporary: nothing
1173  // to do, just move this cleanup to the right place in the stack.
1174  std::swap(Info.CleanupStack[I], Info.CleanupStack[NewEnd]);
1175  ++NewEnd;
1176  } else {
1177  // End the lifetime of the object.
1178  Info.CleanupStack[I].endLifetime();
1179  }
1180  }
1181  Info.CleanupStack.erase(Info.CleanupStack.begin() + NewEnd,
1182  Info.CleanupStack.end());
1183  }
1184  };
1185  typedef ScopeRAII<false> BlockScopeRAII;
1186  typedef ScopeRAII<true> FullExpressionRAII;
1187 }
1188 
1189 bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
1190  CheckSubobjectKind CSK) {
1191  if (Invalid)
1192  return false;
1193  if (isOnePastTheEnd()) {
1194  Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
1195  << CSK;
1196  setInvalid();
1197  return false;
1198  }
1199  // Note, we do not diagnose if isMostDerivedAnUnsizedArray(), because there
1200  // must actually be at least one array element; even a VLA cannot have a
1201  // bound of zero. And if our index is nonzero, we already had a CCEDiag.
1202  return true;
1203 }
1204 
1205 void SubobjectDesignator::diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info,
1206  const Expr *E) {
1207  Info.CCEDiag(E, diag::note_constexpr_unsized_array_indexed);
1208  // Do not set the designator as invalid: we can represent this situation,
1209  // and correct handling of __builtin_object_size requires us to do so.
1210 }
1211 
1212 void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
1213  const Expr *E,
1214  const APSInt &N) {
1215  // If we're complaining, we must be able to statically determine the size of
1216  // the most derived array.
1217  if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)
1218  Info.CCEDiag(E, diag::note_constexpr_array_index)
1219  << N << /*array*/ 0
1220  << static_cast<unsigned>(getMostDerivedArraySize());
1221  else
1222  Info.CCEDiag(E, diag::note_constexpr_array_index)
1223  << N << /*non-array*/ 1;
1224  setInvalid();
1225 }
1226 
1227 CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
1228  const FunctionDecl *Callee, const LValue *This,
1229  APValue *Arguments)
1230  : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This),
1231  Arguments(Arguments), CallLoc(CallLoc), Index(Info.NextCallIndex++) {
1232  Info.CurrentCall = this;
1233  ++Info.CallStackDepth;
1234 }
1235 
1236 CallStackFrame::~CallStackFrame() {
1237  assert(Info.CurrentCall == this && "calls retired out of order");
1238  --Info.CallStackDepth;
1239  Info.CurrentCall = Caller;
1240 }
1241 
1242 APValue &CallStackFrame::createTemporary(const void *Key,
1243  bool IsLifetimeExtended) {
1244  unsigned Version = Info.CurrentCall->getTempVersion();
1245  APValue &Result = Temporaries[MapKeyTy(Key, Version)];
1246  assert(Result.isUninit() && "temporary created multiple times");
1247  Info.CleanupStack.push_back(Cleanup(&Result, IsLifetimeExtended));
1248  return Result;
1249 }
1250 
1251 static void describeCall(CallStackFrame *Frame, raw_ostream &Out);
1252 
1253 void EvalInfo::addCallStack(unsigned Limit) {
1254  // Determine which calls to skip, if any.
1255  unsigned ActiveCalls = CallStackDepth - 1;
1256  unsigned SkipStart = ActiveCalls, SkipEnd = SkipStart;
1257  if (Limit && Limit < ActiveCalls) {
1258  SkipStart = Limit / 2 + Limit % 2;
1259  SkipEnd = ActiveCalls - Limit / 2;
1260  }
1261 
1262  // Walk the call stack and add the diagnostics.
1263  unsigned CallIdx = 0;
1264  for (CallStackFrame *Frame = CurrentCall; Frame != &BottomFrame;
1265  Frame = Frame->Caller, ++CallIdx) {
1266  // Skip this call?
1267  if (CallIdx >= SkipStart && CallIdx < SkipEnd) {
1268  if (CallIdx == SkipStart) {
1269  // Note that we're skipping calls.
1270  addDiag(Frame->CallLoc, diag::note_constexpr_calls_suppressed)
1271  << unsigned(ActiveCalls - Limit);
1272  }
1273  continue;
1274  }
1275 
1276  // Use a different note for an inheriting constructor, because from the
1277  // user's perspective it's not really a function at all.
1278  if (auto *CD = dyn_cast_or_null<CXXConstructorDecl>(Frame->Callee)) {
1279  if (CD->isInheritingConstructor()) {
1280  addDiag(Frame->CallLoc, diag::note_constexpr_inherited_ctor_call_here)
1281  << CD->getParent();
1282  continue;
1283  }
1284  }
1285 
1286  SmallVector<char, 128> Buffer;
1287  llvm::raw_svector_ostream Out(Buffer);
1288  describeCall(Frame, Out);
1289  addDiag(Frame->CallLoc, diag::note_constexpr_call_here) << Out.str();
1290  }
1291 }
1292 
1293 /// Kinds of access we can perform on an object, for diagnostics.
1299 };
1300 
1301 namespace {
1302  struct ComplexValue {
1303  private:
1304  bool IsInt;
1305 
1306  public:
1307  APSInt IntReal, IntImag;
1308  APFloat FloatReal, FloatImag;
1309 
1310  ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
1311 
1312  void makeComplexFloat() { IsInt = false; }
1313  bool isComplexFloat() const { return !IsInt; }
1314  APFloat &getComplexFloatReal() { return FloatReal; }
1315  APFloat &getComplexFloatImag() { return FloatImag; }
1316 
1317  void makeComplexInt() { IsInt = true; }
1318  bool isComplexInt() const { return IsInt; }
1319  APSInt &getComplexIntReal() { return IntReal; }
1320  APSInt &getComplexIntImag() { return IntImag; }
1321 
1322  void moveInto(APValue &v) const {
1323  if (isComplexFloat())
1324  v = APValue(FloatReal, FloatImag);
1325  else
1326  v = APValue(IntReal, IntImag);
1327  }
1328  void setFrom(const APValue &v) {
1329  assert(v.isComplexFloat() || v.isComplexInt());
1330  if (v.isComplexFloat()) {
1331  makeComplexFloat();
1332  FloatReal = v.getComplexFloatReal();
1333  FloatImag = v.getComplexFloatImag();
1334  } else {
1335  makeComplexInt();
1336  IntReal = v.getComplexIntReal();
1337  IntImag = v.getComplexIntImag();
1338  }
1339  }
1340  };
1341 
1342  struct LValue {
1343  APValue::LValueBase Base;
1344  CharUnits Offset;
1345  SubobjectDesignator Designator;
1346  bool IsNullPtr : 1;
1347  bool InvalidBase : 1;
1348 
1349  const APValue::LValueBase getLValueBase() const { return Base; }
1350  CharUnits &getLValueOffset() { return Offset; }
1351  const CharUnits &getLValueOffset() const { return Offset; }
1352  SubobjectDesignator &getLValueDesignator() { return Designator; }
1353  const SubobjectDesignator &getLValueDesignator() const { return Designator;}
1354  bool isNullPointer() const { return IsNullPtr;}
1355 
1356  unsigned getLValueCallIndex() const { return Base.getCallIndex(); }
1357  unsigned getLValueVersion() const { return Base.getVersion(); }
1358 
1359  void moveInto(APValue &V) const {
1360  if (Designator.Invalid)
1361  V = APValue(Base, Offset, APValue::NoLValuePath(), IsNullPtr);
1362  else {
1363  assert(!InvalidBase && "APValues can't handle invalid LValue bases");
1364  V = APValue(Base, Offset, Designator.Entries,
1365  Designator.IsOnePastTheEnd, IsNullPtr);
1366  }
1367  }
1368  void setFrom(ASTContext &Ctx, const APValue &V) {
1369  assert(V.isLValue() && "Setting LValue from a non-LValue?");
1370  Base = V.getLValueBase();
1371  Offset = V.getLValueOffset();
1372  InvalidBase = false;
1373  Designator = SubobjectDesignator(Ctx, V);
1374  IsNullPtr = V.isNullPointer();
1375  }
1376 
1377  void set(APValue::LValueBase B, bool BInvalid = false) {
1378 #ifndef NDEBUG
1379  // We only allow a few types of invalid bases. Enforce that here.
1380  if (BInvalid) {
1381  const auto *E = B.get<const Expr *>();
1382  assert((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&
1383  "Unexpected type of invalid base");
1384  }
1385 #endif
1386 
1387  Base = B;
1388  Offset = CharUnits::fromQuantity(0);
1389  InvalidBase = BInvalid;
1390  Designator = SubobjectDesignator(getType(B));
1391  IsNullPtr = false;
1392  }
1393 
1394  void setNull(QualType PointerTy, uint64_t TargetVal) {
1395  Base = (Expr *)nullptr;
1396  Offset = CharUnits::fromQuantity(TargetVal);
1397  InvalidBase = false;
1398  Designator = SubobjectDesignator(PointerTy->getPointeeType());
1399  IsNullPtr = true;
1400  }
1401 
1402  void setInvalid(APValue::LValueBase B, unsigned I = 0) {
1403  set(B, true);
1404  }
1405 
1406  private:
1407  // Check that this LValue is not based on a null pointer. If it is, produce
1408  // a diagnostic and mark the designator as invalid.
1409  template <typename GenDiagType>
1410  bool checkNullPointerDiagnosingWith(const GenDiagType &GenDiag) {
1411  if (Designator.Invalid)
1412  return false;
1413  if (IsNullPtr) {
1414  GenDiag();
1415  Designator.setInvalid();
1416  return false;
1417  }
1418  return true;
1419  }
1420 
1421  public:
1422  bool checkNullPointer(EvalInfo &Info, const Expr *E,
1423  CheckSubobjectKind CSK) {
1424  return checkNullPointerDiagnosingWith([&Info, E, CSK] {
1425  Info.CCEDiag(E, diag::note_constexpr_null_subobject) << CSK;
1426  });
1427  }
1428 
1429  bool checkNullPointerForFoldAccess(EvalInfo &Info, const Expr *E,
1430  AccessKinds AK) {
1431  return checkNullPointerDiagnosingWith([&Info, E, AK] {
1432  Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
1433  });
1434  }
1435 
1436  // Check this LValue refers to an object. If not, set the designator to be
1437  // invalid and emit a diagnostic.
1438  bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {
1439  return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
1440  Designator.checkSubobject(Info, E, CSK);
1441  }
1442 
1443  void addDecl(EvalInfo &Info, const Expr *E,
1444  const Decl *D, bool Virtual = false) {
1445  if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
1446  Designator.addDeclUnchecked(D, Virtual);
1447  }
1448  void addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) {
1449  if (!Designator.Entries.empty()) {
1450  Info.CCEDiag(E, diag::note_constexpr_unsupported_unsized_array);
1451  Designator.setInvalid();
1452  return;
1453  }
1454  if (checkSubobject(Info, E, CSK_ArrayToPointer)) {
1455  assert(getType(Base)->isPointerType() || getType(Base)->isArrayType());
1456  Designator.FirstEntryIsAnUnsizedArray = true;
1457  Designator.addUnsizedArrayUnchecked(ElemTy);
1458  }
1459  }
1460  void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
1461  if (checkSubobject(Info, E, CSK_ArrayToPointer))
1462  Designator.addArrayUnchecked(CAT);
1463  }
1464  void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
1465  if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
1466  Designator.addComplexUnchecked(EltTy, Imag);
1467  }
1468  void clearIsNullPointer() {
1469  IsNullPtr = false;
1470  }
1471  void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
1472  const APSInt &Index, CharUnits ElementSize) {
1473  // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB,
1474  // but we're not required to diagnose it and it's valid in C++.)
1475  if (!Index)
1476  return;
1477 
1478  // Compute the new offset in the appropriate width, wrapping at 64 bits.
1479  // FIXME: When compiling for a 32-bit target, we should use 32-bit
1480  // offsets.
1481  uint64_t Offset64 = Offset.getQuantity();
1482  uint64_t ElemSize64 = ElementSize.getQuantity();
1483  uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
1484  Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64);
1485 
1486  if (checkNullPointer(Info, E, CSK_ArrayIndex))
1487  Designator.adjustIndex(Info, E, Index);
1488  clearIsNullPointer();
1489  }
1490  void adjustOffset(CharUnits N) {
1491  Offset += N;
1492  if (N.getQuantity())
1493  clearIsNullPointer();
1494  }
1495  };
1496 
1497  struct MemberPtr {
1498  MemberPtr() {}
1499  explicit MemberPtr(const ValueDecl *Decl) :
1500  DeclAndIsDerivedMember(Decl, false), Path() {}
1501 
1502  /// The member or (direct or indirect) field referred to by this member
1503  /// pointer, or 0 if this is a null member pointer.
1504  const ValueDecl *getDecl() const {
1505  return DeclAndIsDerivedMember.getPointer();
1506  }
1507  /// Is this actually a member of some type derived from the relevant class?
1508  bool isDerivedMember() const {
1509  return DeclAndIsDerivedMember.getInt();
1510  }
1511  /// Get the class which the declaration actually lives in.
1512  const CXXRecordDecl *getContainingRecord() const {
1513  return cast<CXXRecordDecl>(
1514  DeclAndIsDerivedMember.getPointer()->getDeclContext());
1515  }
1516 
1517  void moveInto(APValue &V) const {
1518  V = APValue(getDecl(), isDerivedMember(), Path);
1519  }
1520  void setFrom(const APValue &V) {
1521  assert(V.isMemberPointer());
1522  DeclAndIsDerivedMember.setPointer(V.getMemberPointerDecl());
1523  DeclAndIsDerivedMember.setInt(V.isMemberPointerToDerivedMember());
1524  Path.clear();
1526  Path.insert(Path.end(), P.begin(), P.end());
1527  }
1528 
1529  /// DeclAndIsDerivedMember - The member declaration, and a flag indicating
1530  /// whether the member is a member of some class derived from the class type
1531  /// of the member pointer.
1532  llvm::PointerIntPair<const ValueDecl*, 1, bool> DeclAndIsDerivedMember;
1533  /// Path - The path of base/derived classes from the member declaration's
1534  /// class (exclusive) to the class type of the member pointer (inclusive).
1536 
1537  /// Perform a cast towards the class of the Decl (either up or down the
1538  /// hierarchy).
1539  bool castBack(const CXXRecordDecl *Class) {
1540  assert(!Path.empty());
1541  const CXXRecordDecl *Expected;
1542  if (Path.size() >= 2)
1543  Expected = Path[Path.size() - 2];
1544  else
1545  Expected = getContainingRecord();
1546  if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) {
1547  // C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*),
1548  // if B does not contain the original member and is not a base or
1549  // derived class of the class containing the original member, the result
1550  // of the cast is undefined.
1551  // C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to
1552  // (D::*). We consider that to be a language defect.
1553  return false;
1554  }
1555  Path.pop_back();
1556  return true;
1557  }
1558  /// Perform a base-to-derived member pointer cast.
1559  bool castToDerived(const CXXRecordDecl *Derived) {
1560  if (!getDecl())
1561  return true;
1562  if (!isDerivedMember()) {
1563  Path.push_back(Derived);
1564  return true;
1565  }
1566  if (!castBack(Derived))
1567  return false;
1568  if (Path.empty())
1569  DeclAndIsDerivedMember.setInt(false);
1570  return true;
1571  }
1572  /// Perform a derived-to-base member pointer cast.
1573  bool castToBase(const CXXRecordDecl *Base) {
1574  if (!getDecl())
1575  return true;
1576  if (Path.empty())
1577  DeclAndIsDerivedMember.setInt(true);
1578  if (isDerivedMember()) {
1579  Path.push_back(Base);
1580  return true;
1581  }
1582  return castBack(Base);
1583  }
1584  };
1585 
1586  /// Compare two member pointers, which are assumed to be of the same type.
1587  static bool operator==(const MemberPtr &LHS, const MemberPtr &RHS) {
1588  if (!LHS.getDecl() || !RHS.getDecl())
1589  return !LHS.getDecl() && !RHS.getDecl();
1590  if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl())
1591  return false;
1592  return LHS.Path == RHS.Path;
1593  }
1594 }
1595 
1596 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E);
1597 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info,
1598  const LValue &This, const Expr *E,
1599  bool AllowNonLiteralTypes = false);
1600 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
1601  bool InvalidBaseOK = false);
1602 static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info,
1603  bool InvalidBaseOK = false);
1604 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
1605  EvalInfo &Info);
1606 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info);
1607 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
1608 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
1609  EvalInfo &Info);
1610 static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
1611 static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info);
1612 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
1613  EvalInfo &Info);
1614 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result);
1615 
1616 //===----------------------------------------------------------------------===//
1617 // Misc utilities
1618 //===----------------------------------------------------------------------===//
1619 
1620 /// A helper function to create a temporary and set an LValue.
1621 template <class KeyTy>
1622 static APValue &createTemporary(const KeyTy *Key, bool IsLifetimeExtended,
1623  LValue &LV, CallStackFrame &Frame) {
1624  LV.set({Key, Frame.Info.CurrentCall->Index,
1625  Frame.Info.CurrentCall->getTempVersion()});
1626  return Frame.createTemporary(Key, IsLifetimeExtended);
1627 }
1628 
1629 /// Negate an APSInt in place, converting it to a signed form if necessary, and
1630 /// preserving its value (by extending by up to one bit as needed).
1631 static void negateAsSigned(APSInt &Int) {
1632  if (Int.isUnsigned() || Int.isMinSignedValue()) {
1633  Int = Int.extend(Int.getBitWidth() + 1);
1634  Int.setIsSigned(true);
1635  }
1636  Int = -Int;
1637 }
1638 
1639 /// Produce a string describing the given constexpr call.
1640 static void describeCall(CallStackFrame *Frame, raw_ostream &Out) {
1641  unsigned ArgIndex = 0;
1642  bool IsMemberCall = isa<CXXMethodDecl>(Frame->Callee) &&
1643  !isa<CXXConstructorDecl>(Frame->Callee) &&
1644  cast<CXXMethodDecl>(Frame->Callee)->isInstance();
1645 
1646  if (!IsMemberCall)
1647  Out << *Frame->Callee << '(';
1648 
1649  if (Frame->This && IsMemberCall) {
1650  APValue Val;
1651  Frame->This->moveInto(Val);
1652  Val.printPretty(Out, Frame->Info.Ctx,
1653  Frame->This->Designator.MostDerivedType);
1654  // FIXME: Add parens around Val if needed.
1655  Out << "->" << *Frame->Callee << '(';
1656  IsMemberCall = false;
1657  }
1658 
1659  for (FunctionDecl::param_const_iterator I = Frame->Callee->param_begin(),
1660  E = Frame->Callee->param_end(); I != E; ++I, ++ArgIndex) {
1661  if (ArgIndex > (unsigned)IsMemberCall)
1662  Out << ", ";
1663 
1664  const ParmVarDecl *Param = *I;
1665  const APValue &Arg = Frame->Arguments[ArgIndex];
1666  Arg.printPretty(Out, Frame->Info.Ctx, Param->getType());
1667 
1668  if (ArgIndex == 0 && IsMemberCall)
1669  Out << "->" << *Frame->Callee << '(';
1670  }
1671 
1672  Out << ')';
1673 }
1674 
1675 /// Evaluate an expression to see if it had side-effects, and discard its
1676 /// result.
1677 /// \return \c true if the caller should keep evaluating.
1678 static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
1679  APValue Scratch;
1680  if (!Evaluate(Scratch, Info, E))
1681  // We don't need the value, but we might have skipped a side effect here.
1682  return Info.noteSideEffect();
1683  return true;
1684 }
1685 
1686 /// Should this call expression be treated as a string literal?
1687 static bool IsStringLiteralCall(const CallExpr *E) {
1688  unsigned Builtin = E->getBuiltinCallee();
1689  return (Builtin == Builtin::BI__builtin___CFStringMakeConstantString ||
1690  Builtin == Builtin::BI__builtin___NSStringMakeConstantString);
1691 }
1692 
1694  // C++11 [expr.const]p3 An address constant expression is a prvalue core
1695  // constant expression of pointer type that evaluates to...
1696 
1697  // ... a null pointer value, or a prvalue core constant expression of type
1698  // std::nullptr_t.
1699  if (!B) return true;
1700 
1701  if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
1702  // ... the address of an object with static storage duration,
1703  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1704  return VD->hasGlobalStorage();
1705  // ... the address of a function,
1706  return isa<FunctionDecl>(D);
1707  }
1708 
1709  const Expr *E = B.get<const Expr*>();
1710  switch (E->getStmtClass()) {
1711  default:
1712  return false;
1713  case Expr::CompoundLiteralExprClass: {
1714  const CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
1715  return CLE->isFileScope() && CLE->isLValue();
1716  }
1717  case Expr::MaterializeTemporaryExprClass:
1718  // A materialized temporary might have been lifetime-extended to static
1719  // storage duration.
1720  return cast<MaterializeTemporaryExpr>(E)->getStorageDuration() == SD_Static;
1721  // A string literal has static storage duration.
1722  case Expr::StringLiteralClass:
1723  case Expr::PredefinedExprClass:
1724  case Expr::ObjCStringLiteralClass:
1725  case Expr::ObjCEncodeExprClass:
1726  case Expr::CXXTypeidExprClass:
1727  case Expr::CXXUuidofExprClass:
1728  return true;
1729  case Expr::CallExprClass:
1730  return IsStringLiteralCall(cast<CallExpr>(E));
1731  // For GCC compatibility, &&label has static storage duration.
1732  case Expr::AddrLabelExprClass:
1733  return true;
1734  // A Block literal expression may be used as the initialization value for
1735  // Block variables at global or local static scope.
1736  case Expr::BlockExprClass:
1737  return !cast<BlockExpr>(E)->getBlockDecl()->hasCaptures();
1738  case Expr::ImplicitValueInitExprClass:
1739  // FIXME:
1740  // We can never form an lvalue with an implicit value initialization as its
1741  // base through expression evaluation, so these only appear in one case: the
1742  // implicit variable declaration we invent when checking whether a constexpr
1743  // constructor can produce a constant expression. We must assume that such
1744  // an expression might be a global lvalue.
1745  return true;
1746  }
1747 }
1748 
1749 static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) {
1750  return LVal.Base.dyn_cast<const ValueDecl*>();
1751 }
1752 
1753 static bool IsLiteralLValue(const LValue &Value) {
1754  if (Value.getLValueCallIndex())
1755  return false;
1756  const Expr *E = Value.Base.dyn_cast<const Expr*>();
1757  return E && !isa<MaterializeTemporaryExpr>(E);
1758 }
1759 
1760 static bool IsWeakLValue(const LValue &Value) {
1761  const ValueDecl *Decl = GetLValueBaseDecl(Value);
1762  return Decl && Decl->isWeak();
1763 }
1764 
1765 static bool isZeroSized(const LValue &Value) {
1766  const ValueDecl *Decl = GetLValueBaseDecl(Value);
1767  if (Decl && isa<VarDecl>(Decl)) {
1768  QualType Ty = Decl->getType();
1769  if (Ty->isArrayType())
1770  return Ty->isIncompleteType() ||
1771  Decl->getASTContext().getTypeSize(Ty) == 0;
1772  }
1773  return false;
1774 }
1775 
1776 static bool HasSameBase(const LValue &A, const LValue &B) {
1777  if (!A.getLValueBase())
1778  return !B.getLValueBase();
1779  if (!B.getLValueBase())
1780  return false;
1781 
1782  if (A.getLValueBase().getOpaqueValue() !=
1783  B.getLValueBase().getOpaqueValue()) {
1784  const Decl *ADecl = GetLValueBaseDecl(A);
1785  if (!ADecl)
1786  return false;
1787  const Decl *BDecl = GetLValueBaseDecl(B);
1788  if (!BDecl || ADecl->getCanonicalDecl() != BDecl->getCanonicalDecl())
1789  return false;
1790  }
1791 
1792  return IsGlobalLValue(A.getLValueBase()) ||
1793  (A.getLValueCallIndex() == B.getLValueCallIndex() &&
1794  A.getLValueVersion() == B.getLValueVersion());
1795 }
1796 
1797 static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) {
1798  assert(Base && "no location for a null lvalue");
1799  const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1800  if (VD)
1801  Info.Note(VD->getLocation(), diag::note_declared_at);
1802  else
1803  Info.Note(Base.get<const Expr*>()->getExprLoc(),
1804  diag::note_constexpr_temporary_here);
1805 }
1806 
1807 /// Check that this reference or pointer core constant expression is a valid
1808 /// value for an address or reference constant expression. Return true if we
1809 /// can fold this expression, whether or not it's a constant expression.
1810 static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
1811  QualType Type, const LValue &LVal,
1812  Expr::ConstExprUsage Usage) {
1813  bool IsReferenceType = Type->isReferenceType();
1814 
1815  APValue::LValueBase Base = LVal.getLValueBase();
1816  const SubobjectDesignator &Designator = LVal.getLValueDesignator();
1817 
1818  // Check that the object is a global. Note that the fake 'this' object we
1819  // manufacture when checking potential constant expressions is conservatively
1820  // assumed to be global here.
1821  if (!IsGlobalLValue(Base)) {
1822  if (Info.getLangOpts().CPlusPlus11) {
1823  const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1824  Info.FFDiag(Loc, diag::note_constexpr_non_global, 1)
1825  << IsReferenceType << !Designator.Entries.empty()
1826  << !!VD << VD;
1827  NoteLValueLocation(Info, Base);
1828  } else {
1829  Info.FFDiag(Loc);
1830  }
1831  // Don't allow references to temporaries to escape.
1832  return false;
1833  }
1834  assert((Info.checkingPotentialConstantExpression() ||
1835  LVal.getLValueCallIndex() == 0) &&
1836  "have call index for global lvalue");
1837 
1838  if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
1839  if (const VarDecl *Var = dyn_cast<const VarDecl>(VD)) {
1840  // Check if this is a thread-local variable.
1841  if (Var->getTLSKind())
1842  return false;
1843 
1844  // A dllimport variable never acts like a constant.
1845  if (Usage == Expr::EvaluateForCodeGen && Var->hasAttr<DLLImportAttr>())
1846  return false;
1847  }
1848  if (const auto *FD = dyn_cast<const FunctionDecl>(VD)) {
1849  // __declspec(dllimport) must be handled very carefully:
1850  // We must never initialize an expression with the thunk in C++.
1851  // Doing otherwise would allow the same id-expression to yield
1852  // different addresses for the same function in different translation
1853  // units. However, this means that we must dynamically initialize the
1854  // expression with the contents of the import address table at runtime.
1855  //
1856  // The C language has no notion of ODR; furthermore, it has no notion of
1857  // dynamic initialization. This means that we are permitted to
1858  // perform initialization with the address of the thunk.
1859  if (Info.getLangOpts().CPlusPlus && Usage == Expr::EvaluateForCodeGen &&
1860  FD->hasAttr<DLLImportAttr>())
1861  return false;
1862  }
1863  }
1864 
1865  // Allow address constant expressions to be past-the-end pointers. This is
1866  // an extension: the standard requires them to point to an object.
1867  if (!IsReferenceType)
1868  return true;
1869 
1870  // A reference constant expression must refer to an object.
1871  if (!Base) {
1872  // FIXME: diagnostic
1873  Info.CCEDiag(Loc);
1874  return true;
1875  }
1876 
1877  // Does this refer one past the end of some object?
1878  if (!Designator.Invalid && Designator.isOnePastTheEnd()) {
1879  const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1880  Info.FFDiag(Loc, diag::note_constexpr_past_end, 1)
1881  << !Designator.Entries.empty() << !!VD << VD;
1882  NoteLValueLocation(Info, Base);
1883  }
1884 
1885  return true;
1886 }
1887 
1888 /// Member pointers are constant expressions unless they point to a
1889 /// non-virtual dllimport member function.
1890 static bool CheckMemberPointerConstantExpression(EvalInfo &Info,
1891  SourceLocation Loc,
1892  QualType Type,
1893  const APValue &Value,
1894  Expr::ConstExprUsage Usage) {
1895  const ValueDecl *Member = Value.getMemberPointerDecl();
1896  const auto *FD = dyn_cast_or_null<CXXMethodDecl>(Member);
1897  if (!FD)
1898  return true;
1899  return Usage == Expr::EvaluateForMangling || FD->isVirtual() ||
1900  !FD->hasAttr<DLLImportAttr>();
1901 }
1902 
1903 /// Check that this core constant expression is of literal type, and if not,
1904 /// produce an appropriate diagnostic.
1905 static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
1906  const LValue *This = nullptr) {
1907  if (!E->isRValue() || E->getType()->isLiteralType(Info.Ctx))
1908  return true;
1909 
1910  // C++1y: A constant initializer for an object o [...] may also invoke
1911  // constexpr constructors for o and its subobjects even if those objects
1912  // are of non-literal class types.
1913  //
1914  // C++11 missed this detail for aggregates, so classes like this:
1915  // struct foo_t { union { int i; volatile int j; } u; };
1916  // are not (obviously) initializable like so:
1917  // __attribute__((__require_constant_initialization__))
1918  // static const foo_t x = {{0}};
1919  // because "i" is a subobject with non-literal initialization (due to the
1920  // volatile member of the union). See:
1921  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1677
1922  // Therefore, we use the C++1y behavior.
1923  if (This && Info.EvaluatingDecl == This->getLValueBase())
1924  return true;
1925 
1926  // Prvalue constant expressions must be of literal types.
1927  if (Info.getLangOpts().CPlusPlus11)
1928  Info.FFDiag(E, diag::note_constexpr_nonliteral)
1929  << E->getType();
1930  else
1931  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
1932  return false;
1933 }
1934 
1935 /// Check that this core constant expression value is a valid value for a
1936 /// constant expression. If not, report an appropriate diagnostic. Does not
1937 /// check that the expression is of literal type.
1938 static bool
1939 CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc, QualType Type,
1940  const APValue &Value,
1942  if (Value.isUninit()) {
1943  Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized)
1944  << true << Type;
1945  return false;
1946  }
1947 
1948  // We allow _Atomic(T) to be initialized from anything that T can be
1949  // initialized from.
1950  if (const AtomicType *AT = Type->getAs<AtomicType>())
1951  Type = AT->getValueType();
1952 
1953  // Core issue 1454: For a literal constant expression of array or class type,
1954  // each subobject of its value shall have been initialized by a constant
1955  // expression.
1956  if (Value.isArray()) {
1957  QualType EltTy = Type->castAsArrayTypeUnsafe()->getElementType();
1958  for (unsigned I = 0, N = Value.getArrayInitializedElts(); I != N; ++I) {
1959  if (!CheckConstantExpression(Info, DiagLoc, EltTy,
1960  Value.getArrayInitializedElt(I), Usage))
1961  return false;
1962  }
1963  if (!Value.hasArrayFiller())
1964  return true;
1965  return CheckConstantExpression(Info, DiagLoc, EltTy, Value.getArrayFiller(),
1966  Usage);
1967  }
1968  if (Value.isUnion() && Value.getUnionField()) {
1969  return CheckConstantExpression(Info, DiagLoc,
1970  Value.getUnionField()->getType(),
1971  Value.getUnionValue(), Usage);
1972  }
1973  if (Value.isStruct()) {
1974  RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
1975  if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
1976  unsigned BaseIndex = 0;
1977  for (const CXXBaseSpecifier &BS : CD->bases()) {
1978  if (!CheckConstantExpression(Info, DiagLoc, BS.getType(),
1979  Value.getStructBase(BaseIndex), Usage))
1980  return false;
1981  ++BaseIndex;
1982  }
1983  }
1984  for (const auto *I : RD->fields()) {
1985  if (I->isUnnamedBitfield())
1986  continue;
1987 
1988  if (!CheckConstantExpression(Info, DiagLoc, I->getType(),
1989  Value.getStructField(I->getFieldIndex()),
1990  Usage))
1991  return false;
1992  }
1993  }
1994 
1995  if (Value.isLValue()) {
1996  LValue LVal;
1997  LVal.setFrom(Info.Ctx, Value);
1998  return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal, Usage);
1999  }
2000 
2001  if (Value.isMemberPointer())
2002  return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value, Usage);
2003 
2004  // Everything else is fine.
2005  return true;
2006 }
2007 
2008 static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) {
2009  // A null base expression indicates a null pointer. These are always
2010  // evaluatable, and they are false unless the offset is zero.
2011  if (!Value.getLValueBase()) {
2012  Result = !Value.getLValueOffset().isZero();
2013  return true;
2014  }
2015 
2016  // We have a non-null base. These are generally known to be true, but if it's
2017  // a weak declaration it can be null at runtime.
2018  Result = true;
2019  const ValueDecl *Decl = Value.getLValueBase().dyn_cast<const ValueDecl*>();
2020  return !Decl || !Decl->isWeak();
2021 }
2022 
2023 static bool HandleConversionToBool(const APValue &Val, bool &Result) {
2024  switch (Val.getKind()) {
2026  return false;
2027  case APValue::Int:
2028  Result = Val.getInt().getBoolValue();
2029  return true;
2030  case APValue::Float:
2031  Result = !Val.getFloat().isZero();
2032  return true;
2033  case APValue::ComplexInt:
2034  Result = Val.getComplexIntReal().getBoolValue() ||
2035  Val.getComplexIntImag().getBoolValue();
2036  return true;
2037  case APValue::ComplexFloat:
2038  Result = !Val.getComplexFloatReal().isZero() ||
2039  !Val.getComplexFloatImag().isZero();
2040  return true;
2041  case APValue::LValue:
2042  return EvalPointerValueAsBool(Val, Result);
2044  Result = Val.getMemberPointerDecl();
2045  return true;
2046  case APValue::Vector:
2047  case APValue::Array:
2048  case APValue::Struct:
2049  case APValue::Union:
2051  return false;
2052  }
2053 
2054  llvm_unreachable("unknown APValue kind");
2055 }
2056 
2057 static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
2058  EvalInfo &Info) {
2059  assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition");
2060  APValue Val;
2061  if (!Evaluate(Val, Info, E))
2062  return false;
2063  return HandleConversionToBool(Val, Result);
2064 }
2065 
2066 template<typename T>
2067 static bool HandleOverflow(EvalInfo &Info, const Expr *E,
2068  const T &SrcValue, QualType DestType) {
2069  Info.CCEDiag(E, diag::note_constexpr_overflow)
2070  << SrcValue << DestType;
2071  return Info.noteUndefinedBehavior();
2072 }
2073 
2074 static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
2075  QualType SrcType, const APFloat &Value,
2076  QualType DestType, APSInt &Result) {
2077  unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
2078  // Determine whether we are converting to unsigned or signed.
2079  bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
2080 
2081  Result = APSInt(DestWidth, !DestSigned);
2082  bool ignored;
2083  if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
2084  & APFloat::opInvalidOp)
2085  return HandleOverflow(Info, E, Value, DestType);
2086  return true;
2087 }
2088 
2089 static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E,
2090  QualType SrcType, QualType DestType,
2091  APFloat &Result) {
2092  APFloat Value = Result;
2093  bool ignored;
2094  if (Result.convert(Info.Ctx.getFloatTypeSemantics(DestType),
2095  APFloat::rmNearestTiesToEven, &ignored)
2096  & APFloat::opOverflow)
2097  return HandleOverflow(Info, E, Value, DestType);
2098  return true;
2099 }
2100 
2101 static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E,
2102  QualType DestType, QualType SrcType,
2103  const APSInt &Value) {
2104  unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
2105  // Figure out if this is a truncate, extend or noop cast.
2106  // If the input is signed, do a sign extend, noop, or truncate.
2107  APSInt Result = Value.extOrTrunc(DestWidth);
2108  Result.setIsUnsigned(DestType->isUnsignedIntegerOrEnumerationType());
2109  if (DestType->isBooleanType())
2110  Result = Value.getBoolValue();
2111  return Result;
2112 }
2113 
2114 static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E,
2115  QualType SrcType, const APSInt &Value,
2116  QualType DestType, APFloat &Result) {
2117  Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
2118  if (Result.convertFromAPInt(Value, Value.isSigned(),
2119  APFloat::rmNearestTiesToEven)
2120  & APFloat::opOverflow)
2121  return HandleOverflow(Info, E, Value, DestType);
2122  return true;
2123 }
2124 
2125 static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E,
2126  APValue &Value, const FieldDecl *FD) {
2127  assert(FD->isBitField() && "truncateBitfieldValue on non-bitfield");
2128 
2129  if (!Value.isInt()) {
2130  // Trying to store a pointer-cast-to-integer into a bitfield.
2131  // FIXME: In this case, we should provide the diagnostic for casting
2132  // a pointer to an integer.
2133  assert(Value.isLValue() && "integral value neither int nor lvalue?");
2134  Info.FFDiag(E);
2135  return false;
2136  }
2137 
2138  APSInt &Int = Value.getInt();
2139  unsigned OldBitWidth = Int.getBitWidth();
2140  unsigned NewBitWidth = FD->getBitWidthValue(Info.Ctx);
2141  if (NewBitWidth < OldBitWidth)
2142  Int = Int.trunc(NewBitWidth).extend(OldBitWidth);
2143  return true;
2144 }
2145 
2146 static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E,
2147  llvm::APInt &Res) {
2148  APValue SVal;
2149  if (!Evaluate(SVal, Info, E))
2150  return false;
2151  if (SVal.isInt()) {
2152  Res = SVal.getInt();
2153  return true;
2154  }
2155  if (SVal.isFloat()) {
2156  Res = SVal.getFloat().bitcastToAPInt();
2157  return true;
2158  }
2159  if (SVal.isVector()) {
2160  QualType VecTy = E->getType();
2161  unsigned VecSize = Info.Ctx.getTypeSize(VecTy);
2162  QualType EltTy = VecTy->castAs<VectorType>()->getElementType();
2163  unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
2164  bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
2165  Res = llvm::APInt::getNullValue(VecSize);
2166  for (unsigned i = 0; i < SVal.getVectorLength(); i++) {
2167  APValue &Elt = SVal.getVectorElt(i);
2168  llvm::APInt EltAsInt;
2169  if (Elt.isInt()) {
2170  EltAsInt = Elt.getInt();
2171  } else if (Elt.isFloat()) {
2172  EltAsInt = Elt.getFloat().bitcastToAPInt();
2173  } else {
2174  // Don't try to handle vectors of anything other than int or float
2175  // (not sure if it's possible to hit this case).
2176  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2177  return false;
2178  }
2179  unsigned BaseEltSize = EltAsInt.getBitWidth();
2180  if (BigEndian)
2181  Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i*EltSize+BaseEltSize);
2182  else
2183  Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i*EltSize);
2184  }
2185  return true;
2186  }
2187  // Give up if the input isn't an int, float, or vector. For example, we
2188  // reject "(v4i16)(intptr_t)&a".
2189  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2190  return false;
2191 }
2192 
2193 /// Perform the given integer operation, which is known to need at most BitWidth
2194 /// bits, and check for overflow in the original type (if that type was not an
2195 /// unsigned type).
2196 template<typename Operation>
2197 static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E,
2198  const APSInt &LHS, const APSInt &RHS,
2199  unsigned BitWidth, Operation Op,
2200  APSInt &Result) {
2201  if (LHS.isUnsigned()) {
2202  Result = Op(LHS, RHS);
2203  return true;
2204  }
2205 
2206  APSInt Value(Op(LHS.extend(BitWidth), RHS.extend(BitWidth)), false);
2207  Result = Value.trunc(LHS.getBitWidth());
2208  if (Result.extend(BitWidth) != Value) {
2209  if (Info.checkingForOverflow())
2210  Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
2211  diag::warn_integer_constant_overflow)
2212  << Result.toString(10) << E->getType();
2213  else
2214  return HandleOverflow(Info, E, Value, E->getType());
2215  }
2216  return true;
2217 }
2218 
2219 /// Perform the given binary integer operation.
2220 static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS,
2221  BinaryOperatorKind Opcode, APSInt RHS,
2222  APSInt &Result) {
2223  switch (Opcode) {
2224  default:
2225  Info.FFDiag(E);
2226  return false;
2227  case BO_Mul:
2228  return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() * 2,
2229  std::multiplies<APSInt>(), Result);
2230  case BO_Add:
2231  return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2232  std::plus<APSInt>(), Result);
2233  case BO_Sub:
2234  return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2235  std::minus<APSInt>(), Result);
2236  case BO_And: Result = LHS & RHS; return true;
2237  case BO_Xor: Result = LHS ^ RHS; return true;
2238  case BO_Or: Result = LHS | RHS; return true;
2239  case BO_Div:
2240  case BO_Rem:
2241  if (RHS == 0) {
2242  Info.FFDiag(E, diag::note_expr_divide_by_zero);
2243  return false;
2244  }
2245  Result = (Opcode == BO_Rem ? LHS % RHS : LHS / RHS);
2246  // Check for overflow case: INT_MIN / -1 or INT_MIN % -1. APSInt supports
2247  // this operation and gives the two's complement result.
2248  if (RHS.isNegative() && RHS.isAllOnesValue() &&
2249  LHS.isSigned() && LHS.isMinSignedValue())
2250  return HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1),
2251  E->getType());
2252  return true;
2253  case BO_Shl: {
2254  if (Info.getLangOpts().OpenCL)
2255  // OpenCL 6.3j: shift values are effectively % word size of LHS.
2256  RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2257  static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2258  RHS.isUnsigned());
2259  else if (RHS.isSigned() && RHS.isNegative()) {
2260  // During constant-folding, a negative shift is an opposite shift. Such
2261  // a shift is not a constant expression.
2262  Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2263  RHS = -RHS;
2264  goto shift_right;
2265  }
2266  shift_left:
2267  // C++11 [expr.shift]p1: Shift width must be less than the bit width of
2268  // the shifted type.
2269  unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2270  if (SA != RHS) {
2271  Info.CCEDiag(E, diag::note_constexpr_large_shift)
2272  << RHS << E->getType() << LHS.getBitWidth();
2273  } else if (LHS.isSigned()) {
2274  // C++11 [expr.shift]p2: A signed left shift must have a non-negative
2275  // operand, and must not overflow the corresponding unsigned type.
2276  if (LHS.isNegative())
2277  Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
2278  else if (LHS.countLeadingZeros() < SA)
2279  Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
2280  }
2281  Result = LHS << SA;
2282  return true;
2283  }
2284  case BO_Shr: {
2285  if (Info.getLangOpts().OpenCL)
2286  // OpenCL 6.3j: shift values are effectively % word size of LHS.
2287  RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2288  static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2289  RHS.isUnsigned());
2290  else if (RHS.isSigned() && RHS.isNegative()) {
2291  // During constant-folding, a negative shift is an opposite shift. Such a
2292  // shift is not a constant expression.
2293  Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2294  RHS = -RHS;
2295  goto shift_left;
2296  }
2297  shift_right:
2298  // C++11 [expr.shift]p1: Shift width must be less than the bit width of the
2299  // shifted type.
2300  unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2301  if (SA != RHS)
2302  Info.CCEDiag(E, diag::note_constexpr_large_shift)
2303  << RHS << E->getType() << LHS.getBitWidth();
2304  Result = LHS >> SA;
2305  return true;
2306  }
2307 
2308  case BO_LT: Result = LHS < RHS; return true;
2309  case BO_GT: Result = LHS > RHS; return true;
2310  case BO_LE: Result = LHS <= RHS; return true;
2311  case BO_GE: Result = LHS >= RHS; return true;
2312  case BO_EQ: Result = LHS == RHS; return true;
2313  case BO_NE: Result = LHS != RHS; return true;
2314  case BO_Cmp:
2315  llvm_unreachable("BO_Cmp should be handled elsewhere");
2316  }
2317 }
2318 
2319 /// Perform the given binary floating-point operation, in-place, on LHS.
2320 static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E,
2321  APFloat &LHS, BinaryOperatorKind Opcode,
2322  const APFloat &RHS) {
2323  switch (Opcode) {
2324  default:
2325  Info.FFDiag(E);
2326  return false;
2327  case BO_Mul:
2328  LHS.multiply(RHS, APFloat::rmNearestTiesToEven);
2329  break;
2330  case BO_Add:
2331  LHS.add(RHS, APFloat::rmNearestTiesToEven);
2332  break;
2333  case BO_Sub:
2334  LHS.subtract(RHS, APFloat::rmNearestTiesToEven);
2335  break;
2336  case BO_Div:
2337  LHS.divide(RHS, APFloat::rmNearestTiesToEven);
2338  break;
2339  }
2340 
2341  if (LHS.isInfinity() || LHS.isNaN()) {
2342  Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();
2343  return Info.noteUndefinedBehavior();
2344  }
2345  return true;
2346 }
2347 
2348 /// Cast an lvalue referring to a base subobject to a derived class, by
2349 /// truncating the lvalue's path to the given length.
2350 static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
2351  const RecordDecl *TruncatedType,
2352  unsigned TruncatedElements) {
2353  SubobjectDesignator &D = Result.Designator;
2354 
2355  // Check we actually point to a derived class object.
2356  if (TruncatedElements == D.Entries.size())
2357  return true;
2358  assert(TruncatedElements >= D.MostDerivedPathLength &&
2359  "not casting to a derived class");
2360  if (!Result.checkSubobject(Info, E, CSK_Derived))
2361  return false;
2362 
2363  // Truncate the path to the subobject, and remove any derived-to-base offsets.
2364  const RecordDecl *RD = TruncatedType;
2365  for (unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) {
2366  if (RD->isInvalidDecl()) return false;
2367  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
2368  const CXXRecordDecl *Base = getAsBaseClass(D.Entries[I]);
2369  if (isVirtualBaseClass(D.Entries[I]))
2370  Result.Offset -= Layout.getVBaseClassOffset(Base);
2371  else
2372  Result.Offset -= Layout.getBaseClassOffset(Base);
2373  RD = Base;
2374  }
2375  D.Entries.resize(TruncatedElements);
2376  return true;
2377 }
2378 
2379 static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2380  const CXXRecordDecl *Derived,
2381  const CXXRecordDecl *Base,
2382  const ASTRecordLayout *RL = nullptr) {
2383  if (!RL) {
2384  if (Derived->isInvalidDecl()) return false;
2385  RL = &Info.Ctx.getASTRecordLayout(Derived);
2386  }
2387 
2388  Obj.getLValueOffset() += RL->getBaseClassOffset(Base);
2389  Obj.addDecl(Info, E, Base, /*Virtual*/ false);
2390  return true;
2391 }
2392 
2393 static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2394  const CXXRecordDecl *DerivedDecl,
2395  const CXXBaseSpecifier *Base) {
2396  const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl();
2397 
2398  if (!Base->isVirtual())
2399  return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl);
2400 
2401  SubobjectDesignator &D = Obj.Designator;
2402  if (D.Invalid)
2403  return false;
2404 
2405  // Extract most-derived object and corresponding type.
2406  DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl();
2407  if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength))
2408  return false;
2409 
2410  // Find the virtual base class.
2411  if (DerivedDecl->isInvalidDecl()) return false;
2412  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
2413  Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl);
2414  Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
2415  return true;
2416 }
2417 
2418 static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E,
2419  QualType Type, LValue &Result) {
2420  for (CastExpr::path_const_iterator PathI = E->path_begin(),
2421  PathE = E->path_end();
2422  PathI != PathE; ++PathI) {
2423  if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(),
2424  *PathI))
2425  return false;
2426  Type = (*PathI)->getType();
2427  }
2428  return true;
2429 }
2430 
2431 /// Update LVal to refer to the given field, which must be a member of the type
2432 /// currently described by LVal.
2433 static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal,
2434  const FieldDecl *FD,
2435  const ASTRecordLayout *RL = nullptr) {
2436  if (!RL) {
2437  if (FD->getParent()->isInvalidDecl()) return false;
2438  RL = &Info.Ctx.getASTRecordLayout(FD->getParent());
2439  }
2440 
2441  unsigned I = FD->getFieldIndex();
2442  LVal.adjustOffset(Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I)));
2443  LVal.addDecl(Info, E, FD);
2444  return true;
2445 }
2446 
2447 /// Update LVal to refer to the given indirect field.
2448 static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E,
2449  LValue &LVal,
2450  const IndirectFieldDecl *IFD) {
2451  for (const auto *C : IFD->chain())
2452  if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(C)))
2453  return false;
2454  return true;
2455 }
2456 
2457 /// Get the size of the given type in char units.
2458 static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc,
2459  QualType Type, CharUnits &Size) {
2460  // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc
2461  // extension.
2462  if (Type->isVoidType() || Type->isFunctionType()) {
2463  Size = CharUnits::One();
2464  return true;
2465  }
2466 
2467  if (Type->isDependentType()) {
2468  Info.FFDiag(Loc);
2469  return false;
2470  }
2471 
2472  if (!Type->isConstantSizeType()) {
2473  // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
2474  // FIXME: Better diagnostic.
2475  Info.FFDiag(Loc);
2476  return false;
2477  }
2478 
2479  Size = Info.Ctx.getTypeSizeInChars(Type);
2480  return true;
2481 }
2482 
2483 /// Update a pointer value to model pointer arithmetic.
2484 /// \param Info - Information about the ongoing evaluation.
2485 /// \param E - The expression being evaluated, for diagnostic purposes.
2486 /// \param LVal - The pointer value to be updated.
2487 /// \param EltTy - The pointee type represented by LVal.
2488 /// \param Adjustment - The adjustment, in objects of type EltTy, to add.
2489 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2490  LValue &LVal, QualType EltTy,
2491  APSInt Adjustment) {
2492  CharUnits SizeOfPointee;
2493  if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfPointee))
2494  return false;
2495 
2496  LVal.adjustOffsetAndIndex(Info, E, Adjustment, SizeOfPointee);
2497  return true;
2498 }
2499 
2500 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2501  LValue &LVal, QualType EltTy,
2502  int64_t Adjustment) {
2503  return HandleLValueArrayAdjustment(Info, E, LVal, EltTy,
2504  APSInt::get(Adjustment));
2505 }
2506 
2507 /// Update an lvalue to refer to a component of a complex number.
2508 /// \param Info - Information about the ongoing evaluation.
2509 /// \param LVal - The lvalue to be updated.
2510 /// \param EltTy - The complex number's component type.
2511 /// \param Imag - False for the real component, true for the imaginary.
2512 static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E,
2513  LValue &LVal, QualType EltTy,
2514  bool Imag) {
2515  if (Imag) {
2516  CharUnits SizeOfComponent;
2517  if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent))
2518  return false;
2519  LVal.Offset += SizeOfComponent;
2520  }
2521  LVal.addComplex(Info, E, EltTy, Imag);
2522  return true;
2523 }
2524 
2525 static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
2526  QualType Type, const LValue &LVal,
2527  APValue &RVal);
2528 
2529 /// Try to evaluate the initializer for a variable declaration.
2530 ///
2531 /// \param Info Information about the ongoing evaluation.
2532 /// \param E An expression to be used when printing diagnostics.
2533 /// \param VD The variable whose initializer should be obtained.
2534 /// \param Frame The frame in which the variable was created. Must be null
2535 /// if this variable is not local to the evaluation.
2536 /// \param Result Filled in with a pointer to the value of the variable.
2537 static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
2538  const VarDecl *VD, CallStackFrame *Frame,
2539  APValue *&Result, const LValue *LVal) {
2540 
2541  // If this is a parameter to an active constexpr function call, perform
2542  // argument substitution.
2543  if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) {
2544  // Assume arguments of a potential constant expression are unknown
2545  // constant expressions.
2546  if (Info.checkingPotentialConstantExpression())
2547  return false;
2548  if (!Frame || !Frame->Arguments) {
2549  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2550  return false;
2551  }
2552  Result = &Frame->Arguments[PVD->getFunctionScopeIndex()];
2553  return true;
2554  }
2555 
2556  // If this is a local variable, dig out its value.
2557  if (Frame) {
2558  Result = LVal ? Frame->getTemporary(VD, LVal->getLValueVersion())
2559  : Frame->getCurrentTemporary(VD);
2560  if (!Result) {
2561  // Assume variables referenced within a lambda's call operator that were
2562  // not declared within the call operator are captures and during checking
2563  // of a potential constant expression, assume they are unknown constant
2564  // expressions.
2565  assert(isLambdaCallOperator(Frame->Callee) &&
2566  (VD->getDeclContext() != Frame->Callee || VD->isInitCapture()) &&
2567  "missing value for local variable");
2568  if (Info.checkingPotentialConstantExpression())
2569  return false;
2570  // FIXME: implement capture evaluation during constant expr evaluation.
2571  Info.FFDiag(E->getBeginLoc(),
2572  diag::note_unimplemented_constexpr_lambda_feature_ast)
2573  << "captures not currently allowed";
2574  return false;
2575  }
2576  return true;
2577  }
2578 
2579  // Dig out the initializer, and use the declaration which it's attached to.
2580  const Expr *Init = VD->getAnyInitializer(VD);
2581  if (!Init || Init->isValueDependent()) {
2582  // If we're checking a potential constant expression, the variable could be
2583  // initialized later.
2584  if (!Info.checkingPotentialConstantExpression())
2585  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2586  return false;
2587  }
2588 
2589  // If we're currently evaluating the initializer of this declaration, use that
2590  // in-flight value.
2591  if (Info.EvaluatingDecl.dyn_cast<const ValueDecl*>() == VD) {
2592  Result = Info.EvaluatingDeclValue;
2593  return true;
2594  }
2595 
2596  // Never evaluate the initializer of a weak variable. We can't be sure that
2597  // this is the definition which will be used.
2598  if (VD->isWeak()) {
2599  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2600  return false;
2601  }
2602 
2603  // Check that we can fold the initializer. In C++, we will have already done
2604  // this in the cases where it matters for conformance.
2606  if (!VD->evaluateValue(Notes)) {
2607  Info.FFDiag(E, diag::note_constexpr_var_init_non_constant,
2608  Notes.size() + 1) << VD;
2609  Info.Note(VD->getLocation(), diag::note_declared_at);
2610  Info.addNotes(Notes);
2611  return false;
2612  } else if (!VD->checkInitIsICE()) {
2613  Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant,
2614  Notes.size() + 1) << VD;
2615  Info.Note(VD->getLocation(), diag::note_declared_at);
2616  Info.addNotes(Notes);
2617  }
2618 
2619  Result = VD->getEvaluatedValue();
2620  return true;
2621 }
2622 
2624  Qualifiers Quals = T.getQualifiers();
2625  return Quals.hasConst() && !Quals.hasVolatile();
2626 }
2627 
2628 /// Get the base index of the given base class within an APValue representing
2629 /// the given derived class.
2630 static unsigned getBaseIndex(const CXXRecordDecl *Derived,
2631  const CXXRecordDecl *Base) {
2632  Base = Base->getCanonicalDecl();
2633  unsigned Index = 0;
2635  E = Derived->bases_end(); I != E; ++I, ++Index) {
2636  if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == Base)
2637  return Index;
2638  }
2639 
2640  llvm_unreachable("base class missing from derived class's bases list");
2641 }
2642 
2643 /// Extract the value of a character from a string literal.
2644 static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
2645  uint64_t Index) {
2646  // FIXME: Support MakeStringConstant
2647  if (const auto *ObjCEnc = dyn_cast<ObjCEncodeExpr>(Lit)) {
2648  std::string Str;
2649  Info.Ctx.getObjCEncodingForType(ObjCEnc->getEncodedType(), Str);
2650  assert(Index <= Str.size() && "Index too large");
2651  return APSInt::getUnsigned(Str.c_str()[Index]);
2652  }
2653 
2654  if (auto PE = dyn_cast<PredefinedExpr>(Lit))
2655  Lit = PE->getFunctionName();
2656  const StringLiteral *S = cast<StringLiteral>(Lit);
2657  const ConstantArrayType *CAT =
2658  Info.Ctx.getAsConstantArrayType(S->getType());
2659  assert(CAT && "string literal isn't an array");
2660  QualType CharType = CAT->getElementType();
2661  assert(CharType->isIntegerType() && "unexpected character type");
2662 
2663  APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2664  CharType->isUnsignedIntegerType());
2665  if (Index < S->getLength())
2666  Value = S->getCodeUnit(Index);
2667  return Value;
2668 }
2669 
2670 // Expand a string literal into an array of characters.
2671 static void expandStringLiteral(EvalInfo &Info, const Expr *Lit,
2672  APValue &Result) {
2673  const StringLiteral *S = cast<StringLiteral>(Lit);
2674  const ConstantArrayType *CAT =
2675  Info.Ctx.getAsConstantArrayType(S->getType());
2676  assert(CAT && "string literal isn't an array");
2677  QualType CharType = CAT->getElementType();
2678  assert(CharType->isIntegerType() && "unexpected character type");
2679 
2680  unsigned Elts = CAT->getSize().getZExtValue();
2681  Result = APValue(APValue::UninitArray(),
2682  std::min(S->getLength(), Elts), Elts);
2683  APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2684  CharType->isUnsignedIntegerType());
2685  if (Result.hasArrayFiller())
2686  Result.getArrayFiller() = APValue(Value);
2687  for (unsigned I = 0, N = Result.getArrayInitializedElts(); I != N; ++I) {
2688  Value = S->getCodeUnit(I);
2689  Result.getArrayInitializedElt(I) = APValue(Value);
2690  }
2691 }
2692 
2693 // Expand an array so that it has more than Index filled elements.
2694 static void expandArray(APValue &Array, unsigned Index) {
2695  unsigned Size = Array.getArraySize();
2696  assert(Index < Size);
2697 
2698  // Always at least double the number of elements for which we store a value.
2699  unsigned OldElts = Array.getArrayInitializedElts();
2700  unsigned NewElts = std::max(Index+1, OldElts * 2);
2701  NewElts = std::min(Size, std::max(NewElts, 8u));
2702 
2703  // Copy the data across.
2704  APValue NewValue(APValue::UninitArray(), NewElts, Size);
2705  for (unsigned I = 0; I != OldElts; ++I)
2706  NewValue.getArrayInitializedElt(I).swap(Array.getArrayInitializedElt(I));
2707  for (unsigned I = OldElts; I != NewElts; ++I)
2708  NewValue.getArrayInitializedElt(I) = Array.getArrayFiller();
2709  if (NewValue.hasArrayFiller())
2710  NewValue.getArrayFiller() = Array.getArrayFiller();
2711  Array.swap(NewValue);
2712 }
2713 
2714 /// Determine whether a type would actually be read by an lvalue-to-rvalue
2715 /// conversion. If it's of class type, we may assume that the copy operation
2716 /// is trivial. Note that this is never true for a union type with fields
2717 /// (because the copy always "reads" the active member) and always true for
2718 /// a non-class type.
2721  if (!RD || (RD->isUnion() && !RD->field_empty()))
2722  return true;
2723  if (RD->isEmpty())
2724  return false;
2725 
2726  for (auto *Field : RD->fields())
2727  if (isReadByLvalueToRvalueConversion(Field->getType()))
2728  return true;
2729 
2730  for (auto &BaseSpec : RD->bases())
2731  if (isReadByLvalueToRvalueConversion(BaseSpec.getType()))
2732  return true;
2733 
2734  return false;
2735 }
2736 
2737 /// Diagnose an attempt to read from any unreadable field within the specified
2738 /// type, which might be a class type.
2739 static bool diagnoseUnreadableFields(EvalInfo &Info, const Expr *E,
2740  QualType T) {
2742  if (!RD)
2743  return false;
2744 
2745  if (!RD->hasMutableFields())
2746  return false;
2747 
2748  for (auto *Field : RD->fields()) {
2749  // If we're actually going to read this field in some way, then it can't
2750  // be mutable. If we're in a union, then assigning to a mutable field
2751  // (even an empty one) can change the active member, so that's not OK.
2752  // FIXME: Add core issue number for the union case.
2753  if (Field->isMutable() &&
2754  (RD->isUnion() || isReadByLvalueToRvalueConversion(Field->getType()))) {
2755  Info.FFDiag(E, diag::note_constexpr_ltor_mutable, 1) << Field;
2756  Info.Note(Field->getLocation(), diag::note_declared_at);
2757  return true;
2758  }
2759 
2760  if (diagnoseUnreadableFields(Info, E, Field->getType()))
2761  return true;
2762  }
2763 
2764  for (auto &BaseSpec : RD->bases())
2765  if (diagnoseUnreadableFields(Info, E, BaseSpec.getType()))
2766  return true;
2767 
2768  // All mutable fields were empty, and thus not actually read.
2769  return false;
2770 }
2771 
2772 namespace {
2773 /// A handle to a complete object (an object that is not a subobject of
2774 /// another object).
2775 struct CompleteObject {
2776  /// The value of the complete object.
2777  APValue *Value;
2778  /// The type of the complete object.
2779  QualType Type;
2780  bool LifetimeStartedInEvaluation;
2781 
2782  CompleteObject() : Value(nullptr) {}
2783  CompleteObject(APValue *Value, QualType Type,
2784  bool LifetimeStartedInEvaluation)
2785  : Value(Value), Type(Type),
2786  LifetimeStartedInEvaluation(LifetimeStartedInEvaluation) {
2787  assert(Value && "missing value for complete object");
2788  }
2789 
2790  explicit operator bool() const { return Value; }
2791 };
2792 } // end anonymous namespace
2793 
2794 /// Find the designated sub-object of an rvalue.
2795 template<typename SubobjectHandler>
2796 typename SubobjectHandler::result_type
2797 findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj,
2798  const SubobjectDesignator &Sub, SubobjectHandler &handler) {
2799  if (Sub.Invalid)
2800  // A diagnostic will have already been produced.
2801  return handler.failed();
2802  if (Sub.isOnePastTheEnd() || Sub.isMostDerivedAnUnsizedArray()) {
2803  if (Info.getLangOpts().CPlusPlus11)
2804  Info.FFDiag(E, Sub.isOnePastTheEnd()
2805  ? diag::note_constexpr_access_past_end
2806  : diag::note_constexpr_access_unsized_array)
2807  << handler.AccessKind;
2808  else
2809  Info.FFDiag(E);
2810  return handler.failed();
2811  }
2812 
2813  APValue *O = Obj.Value;
2814  QualType ObjType = Obj.Type;
2815  const FieldDecl *LastField = nullptr;
2816  const bool MayReadMutableMembers =
2817  Obj.LifetimeStartedInEvaluation && Info.getLangOpts().CPlusPlus14;
2818 
2819  // Walk the designator's path to find the subobject.
2820  for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {
2821  if (O->isUninit()) {
2822  if (!Info.checkingPotentialConstantExpression())
2823  Info.FFDiag(E, diag::note_constexpr_access_uninit) << handler.AccessKind;
2824  return handler.failed();
2825  }
2826 
2827  if (I == N) {
2828  // If we are reading an object of class type, there may still be more
2829  // things we need to check: if there are any mutable subobjects, we
2830  // cannot perform this read. (This only happens when performing a trivial
2831  // copy or assignment.)
2832  if (ObjType->isRecordType() && handler.AccessKind == AK_Read &&
2833  !MayReadMutableMembers && diagnoseUnreadableFields(Info, E, ObjType))
2834  return handler.failed();
2835 
2836  if (!handler.found(*O, ObjType))
2837  return false;
2838 
2839  // If we modified a bit-field, truncate it to the right width.
2840  if (handler.AccessKind != AK_Read &&
2841  LastField && LastField->isBitField() &&
2842  !truncateBitfieldValue(Info, E, *O, LastField))
2843  return false;
2844 
2845  return true;
2846  }
2847 
2848  LastField = nullptr;
2849  if (ObjType->isArrayType()) {
2850  // Next subobject is an array element.
2851  const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType);
2852  assert(CAT && "vla in literal type?");
2853  uint64_t Index = Sub.Entries[I].ArrayIndex;
2854  if (CAT->getSize().ule(Index)) {
2855  // Note, it should not be possible to form a pointer with a valid
2856  // designator which points more than one past the end of the array.
2857  if (Info.getLangOpts().CPlusPlus11)
2858  Info.FFDiag(E, diag::note_constexpr_access_past_end)
2859  << handler.AccessKind;
2860  else
2861  Info.FFDiag(E);
2862  return handler.failed();
2863  }
2864 
2865  ObjType = CAT->getElementType();
2866 
2867  // An array object is represented as either an Array APValue or as an
2868  // LValue which refers to a string literal.
2869  if (O->isLValue()) {
2870  assert(I == N - 1 && "extracting subobject of character?");
2871  assert(!O->hasLValuePath() || O->getLValuePath().empty());
2872  if (handler.AccessKind != AK_Read)
2873  expandStringLiteral(Info, O->getLValueBase().get<const Expr *>(),
2874  *O);
2875  else
2876  return handler.foundString(*O, ObjType, Index);
2877  }
2878 
2879  if (O->getArrayInitializedElts() > Index)
2880  O = &O->getArrayInitializedElt(Index);
2881  else if (handler.AccessKind != AK_Read) {
2882  expandArray(*O, Index);
2883  O = &O->getArrayInitializedElt(Index);
2884  } else
2885  O = &O->getArrayFiller();
2886  } else if (ObjType->isAnyComplexType()) {
2887  // Next subobject is a complex number.
2888  uint64_t Index = Sub.Entries[I].ArrayIndex;
2889  if (Index > 1) {
2890  if (Info.getLangOpts().CPlusPlus11)
2891  Info.FFDiag(E, diag::note_constexpr_access_past_end)
2892  << handler.AccessKind;
2893  else
2894  Info.FFDiag(E);
2895  return handler.failed();
2896  }
2897 
2898  bool WasConstQualified = ObjType.isConstQualified();
2899  ObjType = ObjType->castAs<ComplexType>()->getElementType();
2900  if (WasConstQualified)
2901  ObjType.addConst();
2902 
2903  assert(I == N - 1 && "extracting subobject of scalar?");
2904  if (O->isComplexInt()) {
2905  return handler.found(Index ? O->getComplexIntImag()
2906  : O->getComplexIntReal(), ObjType);
2907  } else {
2908  assert(O->isComplexFloat());
2909  return handler.found(Index ? O->getComplexFloatImag()
2910  : O->getComplexFloatReal(), ObjType);
2911  }
2912  } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
2913  // In C++14 onwards, it is permitted to read a mutable member whose
2914  // lifetime began within the evaluation.
2915  // FIXME: Should we also allow this in C++11?
2916  if (Field->isMutable() && handler.AccessKind == AK_Read &&
2917  !MayReadMutableMembers) {
2918  Info.FFDiag(E, diag::note_constexpr_ltor_mutable, 1)
2919  << Field;
2920  Info.Note(Field->getLocation(), diag::note_declared_at);
2921  return handler.failed();
2922  }
2923 
2924  // Next subobject is a class, struct or union field.
2925  RecordDecl *RD = ObjType->castAs<RecordType>()->getDecl();
2926  if (RD->isUnion()) {
2927  const FieldDecl *UnionField = O->getUnionField();
2928  if (!UnionField ||
2929  UnionField->getCanonicalDecl() != Field->getCanonicalDecl()) {
2930  Info.FFDiag(E, diag::note_constexpr_access_inactive_union_member)
2931  << handler.AccessKind << Field << !UnionField << UnionField;
2932  return handler.failed();
2933  }
2934  O = &O->getUnionValue();
2935  } else
2936  O = &O->getStructField(Field->getFieldIndex());
2937 
2938  bool WasConstQualified = ObjType.isConstQualified();
2939  ObjType = Field->getType();
2940  if (WasConstQualified && !Field->isMutable())
2941  ObjType.addConst();
2942 
2943  if (ObjType.isVolatileQualified()) {
2944  if (Info.getLangOpts().CPlusPlus) {
2945  // FIXME: Include a description of the path to the volatile subobject.
2946  Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
2947  << handler.AccessKind << 2 << Field;
2948  Info.Note(Field->getLocation(), diag::note_declared_at);
2949  } else {
2950  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2951  }
2952  return handler.failed();
2953  }
2954 
2955  LastField = Field;
2956  } else {
2957  // Next subobject is a base class.
2958  const CXXRecordDecl *Derived = ObjType->getAsCXXRecordDecl();
2959  const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]);
2960  O = &O->getStructBase(getBaseIndex(Derived, Base));
2961 
2962  bool WasConstQualified = ObjType.isConstQualified();
2963  ObjType = Info.Ctx.getRecordType(Base);
2964  if (WasConstQualified)
2965  ObjType.addConst();
2966  }
2967  }
2968 }
2969 
2970 namespace {
2971 struct ExtractSubobjectHandler {
2972  EvalInfo &Info;
2973  APValue &Result;
2974 
2975  static const AccessKinds AccessKind = AK_Read;
2976 
2977  typedef bool result_type;
2978  bool failed() { return false; }
2979  bool found(APValue &Subobj, QualType SubobjType) {
2980  Result = Subobj;
2981  return true;
2982  }
2983  bool found(APSInt &Value, QualType SubobjType) {
2984  Result = APValue(Value);
2985  return true;
2986  }
2987  bool found(APFloat &Value, QualType SubobjType) {
2988  Result = APValue(Value);
2989  return true;
2990  }
2991  bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
2993  Info, Subobj.getLValueBase().get<const Expr *>(), Character));
2994  return true;
2995  }
2996 };
2997 } // end anonymous namespace
2998 
3000 
3001 /// Extract the designated sub-object of an rvalue.
3002 static bool extractSubobject(EvalInfo &Info, const Expr *E,
3003  const CompleteObject &Obj,
3004  const SubobjectDesignator &Sub,
3005  APValue &Result) {
3006  ExtractSubobjectHandler Handler = { Info, Result };
3007  return findSubobject(Info, E, Obj, Sub, Handler);
3008 }
3009 
3010 namespace {
3011 struct ModifySubobjectHandler {
3012  EvalInfo &Info;
3013  APValue &NewVal;
3014  const Expr *E;
3015 
3016  typedef bool result_type;
3017  static const AccessKinds AccessKind = AK_Assign;
3018 
3019  bool checkConst(QualType QT) {
3020  // Assigning to a const object has undefined behavior.
3021  if (QT.isConstQualified()) {
3022  Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3023  return false;
3024  }
3025  return true;
3026  }
3027 
3028  bool failed() { return false; }
3029  bool found(APValue &Subobj, QualType SubobjType) {
3030  if (!checkConst(SubobjType))
3031  return false;
3032  // We've been given ownership of NewVal, so just swap it in.
3033  Subobj.swap(NewVal);
3034  return true;
3035  }
3036  bool found(APSInt &Value, QualType SubobjType) {
3037  if (!checkConst(SubobjType))
3038  return false;
3039  if (!NewVal.isInt()) {
3040  // Maybe trying to write a cast pointer value into a complex?
3041  Info.FFDiag(E);
3042  return false;
3043  }
3044  Value = NewVal.getInt();
3045  return true;
3046  }
3047  bool found(APFloat &Value, QualType SubobjType) {
3048  if (!checkConst(SubobjType))
3049  return false;
3050  Value = NewVal.getFloat();
3051  return true;
3052  }
3053  bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
3054  llvm_unreachable("shouldn't encounter string elements with ExpandArrays");
3055  }
3056 };
3057 } // end anonymous namespace
3058 
3060 
3061 /// Update the designated sub-object of an rvalue to the given value.
3062 static bool modifySubobject(EvalInfo &Info, const Expr *E,
3063  const CompleteObject &Obj,
3064  const SubobjectDesignator &Sub,
3065  APValue &NewVal) {
3066  ModifySubobjectHandler Handler = { Info, NewVal, E };
3067  return findSubobject(Info, E, Obj, Sub, Handler);
3068 }
3069 
3070 /// Find the position where two subobject designators diverge, or equivalently
3071 /// the length of the common initial subsequence.
3072 static unsigned FindDesignatorMismatch(QualType ObjType,
3073  const SubobjectDesignator &A,
3074  const SubobjectDesignator &B,
3075  bool &WasArrayIndex) {
3076  unsigned I = 0, N = std::min(A.Entries.size(), B.Entries.size());
3077  for (/**/; I != N; ++I) {
3078  if (!ObjType.isNull() &&
3079  (ObjType->isArrayType() || ObjType->isAnyComplexType())) {
3080  // Next subobject is an array element.
3081  if (A.Entries[I].ArrayIndex != B.Entries[I].ArrayIndex) {
3082  WasArrayIndex = true;
3083  return I;
3084  }
3085  if (ObjType->isAnyComplexType())
3086  ObjType = ObjType->castAs<ComplexType>()->getElementType();
3087  else
3088  ObjType = ObjType->castAsArrayTypeUnsafe()->getElementType();
3089  } else {
3090  if (A.Entries[I].BaseOrMember != B.Entries[I].BaseOrMember) {
3091  WasArrayIndex = false;
3092  return I;
3093  }
3094  if (const FieldDecl *FD = getAsField(A.Entries[I]))
3095  // Next subobject is a field.
3096  ObjType = FD->getType();
3097  else
3098  // Next subobject is a base class.
3099  ObjType = QualType();
3100  }
3101  }
3102  WasArrayIndex = false;
3103  return I;
3104 }
3105 
3106 /// Determine whether the given subobject designators refer to elements of the
3107 /// same array object.
3108 static bool AreElementsOfSameArray(QualType ObjType,
3109  const SubobjectDesignator &A,
3110  const SubobjectDesignator &B) {
3111  if (A.Entries.size() != B.Entries.size())
3112  return false;
3113 
3114  bool IsArray = A.MostDerivedIsArrayElement;
3115  if (IsArray && A.MostDerivedPathLength != A.Entries.size())
3116  // A is a subobject of the array element.
3117  return false;
3118 
3119  // If A (and B) designates an array element, the last entry will be the array
3120  // index. That doesn't have to match. Otherwise, we're in the 'implicit array
3121  // of length 1' case, and the entire path must match.
3122  bool WasArrayIndex;
3123  unsigned CommonLength = FindDesignatorMismatch(ObjType, A, B, WasArrayIndex);
3124  return CommonLength >= A.Entries.size() - IsArray;
3125 }
3126 
3127 /// Find the complete object to which an LValue refers.
3128 static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
3129  AccessKinds AK, const LValue &LVal,
3130  QualType LValType) {
3131  if (!LVal.Base) {
3132  Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
3133  return CompleteObject();
3134  }
3135 
3136  CallStackFrame *Frame = nullptr;
3137  if (LVal.getLValueCallIndex()) {
3138  Frame = Info.getCallFrame(LVal.getLValueCallIndex());
3139  if (!Frame) {
3140  Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1)
3141  << AK << LVal.Base.is<const ValueDecl*>();
3142  NoteLValueLocation(Info, LVal.Base);
3143  return CompleteObject();
3144  }
3145  }
3146 
3147  // C++11 DR1311: An lvalue-to-rvalue conversion on a volatile-qualified type
3148  // is not a constant expression (even if the object is non-volatile). We also
3149  // apply this rule to C++98, in order to conform to the expected 'volatile'
3150  // semantics.
3151  if (LValType.isVolatileQualified()) {
3152  if (Info.getLangOpts().CPlusPlus)
3153  Info.FFDiag(E, diag::note_constexpr_access_volatile_type)
3154  << AK << LValType;
3155  else
3156  Info.FFDiag(E);
3157  return CompleteObject();
3158  }
3159 
3160  // Compute value storage location and type of base object.
3161  APValue *BaseVal = nullptr;
3162  QualType BaseType = getType(LVal.Base);
3163  bool LifetimeStartedInEvaluation = Frame;
3164 
3165  if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl*>()) {
3166  // In C++98, const, non-volatile integers initialized with ICEs are ICEs.
3167  // In C++11, constexpr, non-volatile variables initialized with constant
3168  // expressions are constant expressions too. Inside constexpr functions,
3169  // parameters are constant expressions even if they're non-const.
3170  // In C++1y, objects local to a constant expression (those with a Frame) are
3171  // both readable and writable inside constant expressions.
3172  // In C, such things can also be folded, although they are not ICEs.
3173  const VarDecl *VD = dyn_cast<VarDecl>(D);
3174  if (VD) {
3175  if (const VarDecl *VDef = VD->getDefinition(Info.Ctx))
3176  VD = VDef;
3177  }
3178  if (!VD || VD->isInvalidDecl()) {
3179  Info.FFDiag(E);
3180  return CompleteObject();
3181  }
3182 
3183  // Accesses of volatile-qualified objects are not allowed.
3184  if (BaseType.isVolatileQualified()) {
3185  if (Info.getLangOpts().CPlusPlus) {
3186  Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
3187  << AK << 1 << VD;
3188  Info.Note(VD->getLocation(), diag::note_declared_at);
3189  } else {
3190  Info.FFDiag(E);
3191  }
3192  return CompleteObject();
3193  }
3194 
3195  // Unless we're looking at a local variable or argument in a constexpr call,
3196  // the variable we're reading must be const.
3197  if (!Frame) {
3198  if (Info.getLangOpts().CPlusPlus14 &&
3199  VD == Info.EvaluatingDecl.dyn_cast<const ValueDecl *>()) {
3200  // OK, we can read and modify an object if we're in the process of
3201  // evaluating its initializer, because its lifetime began in this
3202  // evaluation.
3203  } else if (AK != AK_Read) {
3204  // All the remaining cases only permit reading.
3205  Info.FFDiag(E, diag::note_constexpr_modify_global);
3206  return CompleteObject();
3207  } else if (VD->isConstexpr()) {
3208  // OK, we can read this variable.
3209  } else if (BaseType->isIntegralOrEnumerationType()) {
3210  // In OpenCL if a variable is in constant address space it is a const value.
3211  if (!(BaseType.isConstQualified() ||
3212  (Info.getLangOpts().OpenCL &&
3213  BaseType.getAddressSpace() == LangAS::opencl_constant))) {
3214  if (Info.getLangOpts().CPlusPlus) {
3215  Info.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;
3216  Info.Note(VD->getLocation(), diag::note_declared_at);
3217  } else {
3218  Info.FFDiag(E);
3219  }
3220  return CompleteObject();
3221  }
3222  } else if (BaseType->isFloatingType() && BaseType.isConstQualified()) {
3223  // We support folding of const floating-point types, in order to make
3224  // static const data members of such types (supported as an extension)
3225  // more useful.
3226  if (Info.getLangOpts().CPlusPlus11) {
3227  Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
3228  Info.Note(VD->getLocation(), diag::note_declared_at);
3229  } else {
3230  Info.CCEDiag(E);
3231  }
3232  } else if (BaseType.isConstQualified() && VD->hasDefinition(Info.Ctx)) {
3233  Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr) << VD;
3234  // Keep evaluating to see what we can do.
3235  } else {
3236  // FIXME: Allow folding of values of any literal type in all languages.
3237  if (Info.checkingPotentialConstantExpression() &&
3238  VD->getType().isConstQualified() && !VD->hasDefinition(Info.Ctx)) {
3239  // The definition of this variable could be constexpr. We can't
3240  // access it right now, but may be able to in future.
3241  } else if (Info.getLangOpts().CPlusPlus11) {
3242  Info.FFDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
3243  Info.Note(VD->getLocation(), diag::note_declared_at);
3244  } else {
3245  Info.FFDiag(E);
3246  }
3247  return CompleteObject();
3248  }
3249  }
3250 
3251  if (!evaluateVarDeclInit(Info, E, VD, Frame, BaseVal, &LVal))
3252  return CompleteObject();
3253  } else {
3254  const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3255 
3256  if (!Frame) {
3257  if (const MaterializeTemporaryExpr *MTE =
3258  dyn_cast<MaterializeTemporaryExpr>(Base)) {
3259  assert(MTE->getStorageDuration() == SD_Static &&
3260  "should have a frame for a non-global materialized temporary");
3261 
3262  // Per C++1y [expr.const]p2:
3263  // an lvalue-to-rvalue conversion [is not allowed unless it applies to]
3264  // - a [...] glvalue of integral or enumeration type that refers to
3265  // a non-volatile const object [...]
3266  // [...]
3267  // - a [...] glvalue of literal type that refers to a non-volatile
3268  // object whose lifetime began within the evaluation of e.
3269  //
3270  // C++11 misses the 'began within the evaluation of e' check and
3271  // instead allows all temporaries, including things like:
3272  // int &&r = 1;
3273  // int x = ++r;
3274  // constexpr int k = r;
3275  // Therefore we use the C++14 rules in C++11 too.
3276  const ValueDecl *VD = Info.EvaluatingDecl.dyn_cast<const ValueDecl*>();
3277  const ValueDecl *ED = MTE->getExtendingDecl();
3278  if (!(BaseType.isConstQualified() &&
3279  BaseType->isIntegralOrEnumerationType()) &&
3280  !(VD && VD->getCanonicalDecl() == ED->getCanonicalDecl())) {
3281  Info.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
3282  Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here);
3283  return CompleteObject();
3284  }
3285 
3286  BaseVal = Info.Ctx.getMaterializedTemporaryValue(MTE, false);
3287  assert(BaseVal && "got reference to unevaluated temporary");
3288  LifetimeStartedInEvaluation = true;
3289  } else {
3290  Info.FFDiag(E);
3291  return CompleteObject();
3292  }
3293  } else {
3294  BaseVal = Frame->getTemporary(Base, LVal.Base.getVersion());
3295  assert(BaseVal && "missing value for temporary");
3296  }
3297 
3298  // Volatile temporary objects cannot be accessed in constant expressions.
3299  if (BaseType.isVolatileQualified()) {
3300  if (Info.getLangOpts().CPlusPlus) {
3301  Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
3302  << AK << 0;
3303  Info.Note(Base->getExprLoc(), diag::note_constexpr_temporary_here);
3304  } else {
3305  Info.FFDiag(E);
3306  }
3307  return CompleteObject();
3308  }
3309  }
3310 
3311  // During the construction of an object, it is not yet 'const'.
3312  // FIXME: This doesn't do quite the right thing for const subobjects of the
3313  // object under construction.
3314  if (Info.isEvaluatingConstructor(LVal.getLValueBase(),
3315  LVal.getLValueCallIndex(),
3316  LVal.getLValueVersion())) {
3317  BaseType = Info.Ctx.getCanonicalType(BaseType);
3318  BaseType.removeLocalConst();
3319  LifetimeStartedInEvaluation = true;
3320  }
3321 
3322  // In C++14, we can't safely access any mutable state when we might be
3323  // evaluating after an unmodeled side effect.
3324  //
3325  // FIXME: Not all local state is mutable. Allow local constant subobjects
3326  // to be read here (but take care with 'mutable' fields).
3327  if ((Frame && Info.getLangOpts().CPlusPlus14 &&
3328  Info.EvalStatus.HasSideEffects) ||
3329  (AK != AK_Read && Info.IsSpeculativelyEvaluating))
3330  return CompleteObject();
3331 
3332  return CompleteObject(BaseVal, BaseType, LifetimeStartedInEvaluation);
3333 }
3334 
3335 /// Perform an lvalue-to-rvalue conversion on the given glvalue. This
3336 /// can also be used for 'lvalue-to-lvalue' conversions for looking up the
3337 /// glvalue referred to by an entity of reference type.
3338 ///
3339 /// \param Info - Information about the ongoing evaluation.
3340 /// \param Conv - The expression for which we are performing the conversion.
3341 /// Used for diagnostics.
3342 /// \param Type - The type of the glvalue (before stripping cv-qualifiers in the
3343 /// case of a non-class type).
3344 /// \param LVal - The glvalue on which we are attempting to perform this action.
3345 /// \param RVal - The produced value will be placed here.
3346 static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
3347  QualType Type,
3348  const LValue &LVal, APValue &RVal) {
3349  if (LVal.Designator.Invalid)
3350  return false;
3351 
3352  // Check for special cases where there is no existing APValue to look at.
3353  const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3354  if (Base && !LVal.getLValueCallIndex() && !Type.isVolatileQualified()) {
3355  if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
3356  // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the
3357  // initializer until now for such expressions. Such an expression can't be
3358  // an ICE in C, so this only matters for fold.
3359  if (Type.isVolatileQualified()) {
3360  Info.FFDiag(Conv);
3361  return false;
3362  }
3363  APValue Lit;
3364  if (!Evaluate(Lit, Info, CLE->getInitializer()))
3365  return false;
3366  CompleteObject LitObj(&Lit, Base->getType(), false);
3367  return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal);
3368  } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) {
3369  // We represent a string literal array as an lvalue pointing at the
3370  // corresponding expression, rather than building an array of chars.
3371  // FIXME: Support ObjCEncodeExpr, MakeStringConstant
3372  APValue Str(Base, CharUnits::Zero(), APValue::NoLValuePath(), 0);
3373  CompleteObject StrObj(&Str, Base->getType(), false);
3374  return extractSubobject(Info, Conv, StrObj, LVal.Designator, RVal);
3375  }
3376  }
3377 
3378  CompleteObject Obj = findCompleteObject(Info, Conv, AK_Read, LVal, Type);
3379  return Obj && extractSubobject(Info, Conv, Obj, LVal.Designator, RVal);
3380 }
3381 
3382 /// Perform an assignment of Val to LVal. Takes ownership of Val.
3383 static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal,
3384  QualType LValType, APValue &Val) {
3385  if (LVal.Designator.Invalid)
3386  return false;
3387 
3388  if (!Info.getLangOpts().CPlusPlus14) {
3389  Info.FFDiag(E);
3390  return false;
3391  }
3392 
3393  CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
3394  return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val);
3395 }
3396 
3397 namespace {
3398 struct CompoundAssignSubobjectHandler {
3399  EvalInfo &Info;
3400  const Expr *E;
3401  QualType PromotedLHSType;
3402  BinaryOperatorKind Opcode;
3403  const APValue &RHS;
3404 
3405  static const AccessKinds AccessKind = AK_Assign;
3406 
3407  typedef bool result_type;
3408 
3409  bool checkConst(QualType QT) {
3410  // Assigning to a const object has undefined behavior.
3411  if (QT.isConstQualified()) {
3412  Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3413  return false;
3414  }
3415  return true;
3416  }
3417 
3418  bool failed() { return false; }
3419  bool found(APValue &Subobj, QualType SubobjType) {
3420  switch (Subobj.getKind()) {
3421  case APValue::Int:
3422  return found(Subobj.getInt(), SubobjType);
3423  case APValue::Float:
3424  return found(Subobj.getFloat(), SubobjType);
3425  case APValue::ComplexInt:
3426  case APValue::ComplexFloat:
3427  // FIXME: Implement complex compound assignment.
3428  Info.FFDiag(E);
3429  return false;
3430  case APValue::LValue:
3431  return foundPointer(Subobj, SubobjType);
3432  default:
3433  // FIXME: can this happen?
3434  Info.FFDiag(E);
3435  return false;
3436  }
3437  }
3438  bool found(APSInt &Value, QualType SubobjType) {
3439  if (!checkConst(SubobjType))
3440  return false;
3441 
3442  if (!SubobjType->isIntegerType()) {
3443  // We don't support compound assignment on integer-cast-to-pointer
3444  // values.
3445  Info.FFDiag(E);
3446  return false;
3447  }
3448 
3449  if (RHS.isInt()) {
3450  APSInt LHS =
3451  HandleIntToIntCast(Info, E, PromotedLHSType, SubobjType, Value);
3452  if (!handleIntIntBinOp(Info, E, LHS, Opcode, RHS.getInt(), LHS))
3453  return false;
3454  Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS);
3455  return true;
3456  } else if (RHS.isFloat()) {
3457  APFloat FValue(0.0);
3458  return HandleIntToFloatCast(Info, E, SubobjType, Value, PromotedLHSType,
3459  FValue) &&
3460  handleFloatFloatBinOp(Info, E, FValue, Opcode, RHS.getFloat()) &&
3461  HandleFloatToIntCast(Info, E, PromotedLHSType, FValue, SubobjType,
3462  Value);
3463  }
3464 
3465  Info.FFDiag(E);
3466  return false;
3467  }
3468  bool found(APFloat &Value, QualType SubobjType) {
3469  return checkConst(SubobjType) &&
3470  HandleFloatToFloatCast(Info, E, SubobjType, PromotedLHSType,
3471  Value) &&
3472  handleFloatFloatBinOp(Info, E, Value, Opcode, RHS.getFloat()) &&
3473  HandleFloatToFloatCast(Info, E, PromotedLHSType, SubobjType, Value);
3474  }
3475  bool foundPointer(APValue &Subobj, QualType SubobjType) {
3476  if (!checkConst(SubobjType))
3477  return false;
3478 
3479  QualType PointeeType;
3480  if (const PointerType *PT = SubobjType->getAs<PointerType>())
3481  PointeeType = PT->getPointeeType();
3482 
3483  if (PointeeType.isNull() || !RHS.isInt() ||
3484  (Opcode != BO_Add && Opcode != BO_Sub)) {
3485  Info.FFDiag(E);
3486  return false;
3487  }
3488 
3489  APSInt Offset = RHS.getInt();
3490  if (Opcode == BO_Sub)
3491  negateAsSigned(Offset);
3492 
3493  LValue LVal;
3494  LVal.setFrom(Info.Ctx, Subobj);
3495  if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, Offset))
3496  return false;
3497  LVal.moveInto(Subobj);
3498  return true;
3499  }
3500  bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
3501  llvm_unreachable("shouldn't encounter string elements here");
3502  }
3503 };
3504 } // end anonymous namespace
3505 
3507 
3508 /// Perform a compound assignment of LVal <op>= RVal.
3510  EvalInfo &Info, const Expr *E,
3511  const LValue &LVal, QualType LValType, QualType PromotedLValType,
3512  BinaryOperatorKind Opcode, const APValue &RVal) {
3513  if (LVal.Designator.Invalid)
3514  return false;
3515 
3516  if (!Info.getLangOpts().CPlusPlus14) {
3517  Info.FFDiag(E);
3518  return false;
3519  }
3520 
3521  CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
3522  CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode,
3523  RVal };
3524  return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
3525 }
3526 
3527 namespace {
3528 struct IncDecSubobjectHandler {
3529  EvalInfo &Info;
3530  const UnaryOperator *E;
3532  APValue *Old;
3533 
3534  typedef bool result_type;
3535 
3536  bool checkConst(QualType QT) {
3537  // Assigning to a const object has undefined behavior.
3538  if (QT.isConstQualified()) {
3539  Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3540  return false;
3541  }
3542  return true;
3543  }
3544 
3545  bool failed() { return false; }
3546  bool found(APValue &Subobj, QualType SubobjType) {
3547  // Stash the old value. Also clear Old, so we don't clobber it later
3548  // if we're post-incrementing a complex.
3549  if (Old) {
3550  *Old = Subobj;
3551  Old = nullptr;
3552  }
3553 
3554  switch (Subobj.getKind()) {
3555  case APValue::Int:
3556  return found(Subobj.getInt(), SubobjType);
3557  case APValue::Float:
3558  return found(Subobj.getFloat(), SubobjType);
3559  case APValue::ComplexInt:
3560  return found(Subobj.getComplexIntReal(),
3561  SubobjType->castAs<ComplexType>()->getElementType()
3562  .withCVRQualifiers(SubobjType.getCVRQualifiers()));
3563  case APValue::ComplexFloat:
3564  return found(Subobj.getComplexFloatReal(),
3565  SubobjType->castAs<ComplexType>()->getElementType()
3566  .withCVRQualifiers(SubobjType.getCVRQualifiers()));
3567  case APValue::LValue:
3568  return foundPointer(Subobj, SubobjType);
3569  default:
3570  // FIXME: can this happen?
3571  Info.FFDiag(E);
3572  return false;
3573  }
3574  }
3575  bool found(APSInt &Value, QualType SubobjType) {
3576  if (!checkConst(SubobjType))
3577  return false;
3578 
3579  if (!SubobjType->isIntegerType()) {
3580  // We don't support increment / decrement on integer-cast-to-pointer
3581  // values.
3582  Info.FFDiag(E);
3583  return false;
3584  }
3585 
3586  if (Old) *Old = APValue(Value);
3587 
3588  // bool arithmetic promotes to int, and the conversion back to bool
3589  // doesn't reduce mod 2^n, so special-case it.
3590  if (SubobjType->isBooleanType()) {
3591  if (AccessKind == AK_Increment)
3592  Value = 1;
3593  else
3594  Value = !Value;
3595  return true;
3596  }
3597 
3598  bool WasNegative = Value.isNegative();
3599  if (AccessKind == AK_Increment) {
3600  ++Value;
3601 
3602  if (!WasNegative && Value.isNegative() && E->canOverflow()) {
3603  APSInt ActualValue(Value, /*IsUnsigned*/true);
3604  return HandleOverflow(Info, E, ActualValue, SubobjType);
3605  }
3606  } else {
3607  --Value;
3608 
3609  if (WasNegative && !Value.isNegative() && E->canOverflow()) {
3610  unsigned BitWidth = Value.getBitWidth();
3611  APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false);
3612  ActualValue.setBit(BitWidth);
3613  return HandleOverflow(Info, E, ActualValue, SubobjType);
3614  }
3615  }
3616  return true;
3617  }
3618  bool found(APFloat &Value, QualType SubobjType) {
3619  if (!checkConst(SubobjType))
3620  return false;
3621 
3622  if (Old) *Old = APValue(Value);
3623 
3624  APFloat One(Value.getSemantics(), 1);
3625  if (AccessKind == AK_Increment)
3626  Value.add(One, APFloat::rmNearestTiesToEven);
3627  else
3628  Value.subtract(One, APFloat::rmNearestTiesToEven);
3629  return true;
3630  }
3631  bool foundPointer(APValue &Subobj, QualType SubobjType) {
3632  if (!checkConst(SubobjType))
3633  return false;
3634 
3635  QualType PointeeType;
3636  if (const PointerType *PT = SubobjType->getAs<PointerType>())
3637  PointeeType = PT->getPointeeType();
3638  else {
3639  Info.FFDiag(E);
3640  return false;
3641  }
3642 
3643  LValue LVal;
3644  LVal.setFrom(Info.Ctx, Subobj);
3645  if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType,
3646  AccessKind == AK_Increment ? 1 : -1))
3647  return false;
3648  LVal.moveInto(Subobj);
3649  return true;
3650  }
3651  bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
3652  llvm_unreachable("shouldn't encounter string elements here");
3653  }
3654 };
3655 } // end anonymous namespace
3656 
3657 /// Perform an increment or decrement on LVal.
3658 static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal,
3659  QualType LValType, bool IsIncrement, APValue *Old) {
3660  if (LVal.Designator.Invalid)
3661  return false;
3662 
3663  if (!Info.getLangOpts().CPlusPlus14) {
3664  Info.FFDiag(E);
3665  return false;
3666  }
3667 
3668  AccessKinds AK = IsIncrement ? AK_Increment : AK_Decrement;
3669  CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType);
3670  IncDecSubobjectHandler Handler = {Info, cast<UnaryOperator>(E), AK, Old};
3671  return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
3672 }
3673 
3674 /// Build an lvalue for the object argument of a member function call.
3675 static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
3676  LValue &This) {
3677  if (Object->getType()->isPointerType())
3678  return EvaluatePointer(Object, This, Info);
3679 
3680  if (Object->isGLValue())
3681  return EvaluateLValue(Object, This, Info);
3682 
3683  if (Object->getType()->isLiteralType(Info.Ctx))
3684  return EvaluateTemporary(Object, This, Info);
3685 
3686  Info.FFDiag(Object, diag::note_constexpr_nonliteral) << Object->getType();
3687  return false;
3688 }
3689 
3690 /// HandleMemberPointerAccess - Evaluate a member access operation and build an
3691 /// lvalue referring to the result.
3692 ///
3693 /// \param Info - Information about the ongoing evaluation.
3694 /// \param LV - An lvalue referring to the base of the member pointer.
3695 /// \param RHS - The member pointer expression.
3696 /// \param IncludeMember - Specifies whether the member itself is included in
3697 /// the resulting LValue subobject designator. This is not possible when
3698 /// creating a bound member function.
3699 /// \return The field or method declaration to which the member pointer refers,
3700 /// or 0 if evaluation fails.
3701 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
3702  QualType LVType,
3703  LValue &LV,
3704  const Expr *RHS,
3705  bool IncludeMember = true) {
3706  MemberPtr MemPtr;
3707  if (!EvaluateMemberPointer(RHS, MemPtr, Info))
3708  return nullptr;
3709 
3710  // C++11 [expr.mptr.oper]p6: If the second operand is the null pointer to
3711  // member value, the behavior is undefined.
3712  if (!MemPtr.getDecl()) {
3713  // FIXME: Specific diagnostic.
3714  Info.FFDiag(RHS);
3715  return nullptr;
3716  }
3717 
3718  if (MemPtr.isDerivedMember()) {
3719  // This is a member of some derived class. Truncate LV appropriately.
3720  // The end of the derived-to-base path for the base object must match the
3721  // derived-to-base path for the member pointer.
3722  if (LV.Designator.MostDerivedPathLength + MemPtr.Path.size() >
3723  LV.Designator.Entries.size()) {
3724  Info.FFDiag(RHS);
3725  return nullptr;
3726  }
3727  unsigned PathLengthToMember =
3728  LV.Designator.Entries.size() - MemPtr.Path.size();
3729  for (unsigned I = 0, N = MemPtr.Path.size(); I != N; ++I) {
3730  const CXXRecordDecl *LVDecl = getAsBaseClass(
3731  LV.Designator.Entries[PathLengthToMember + I]);
3732  const CXXRecordDecl *MPDecl = MemPtr.Path[I];
3733  if (LVDecl->getCanonicalDecl() != MPDecl->getCanonicalDecl()) {
3734  Info.FFDiag(RHS);
3735  return nullptr;
3736  }
3737  }
3738 
3739  // Truncate the lvalue to the appropriate derived class.
3740  if (!CastToDerivedClass(Info, RHS, LV, MemPtr.getContainingRecord(),
3741  PathLengthToMember))
3742  return nullptr;
3743  } else if (!MemPtr.Path.empty()) {
3744  // Extend the LValue path with the member pointer's path.
3745  LV.Designator.Entries.reserve(LV.Designator.Entries.size() +
3746  MemPtr.Path.size() + IncludeMember);
3747 
3748  // Walk down to the appropriate base class.
3749  if (const PointerType *PT = LVType->getAs<PointerType>())
3750  LVType = PT->getPointeeType();
3751  const CXXRecordDecl *RD = LVType->getAsCXXRecordDecl();
3752  assert(RD && "member pointer access on non-class-type expression");
3753  // The first class in the path is that of the lvalue.
3754  for (unsigned I = 1, N = MemPtr.Path.size(); I != N; ++I) {
3755  const CXXRecordDecl *Base = MemPtr.Path[N - I - 1];
3756  if (!HandleLValueDirectBase(Info, RHS, LV, RD, Base))
3757  return nullptr;
3758  RD = Base;
3759  }
3760  // Finally cast to the class containing the member.
3761  if (!HandleLValueDirectBase(Info, RHS, LV, RD,
3762  MemPtr.getContainingRecord()))
3763  return nullptr;
3764  }
3765 
3766  // Add the member. Note that we cannot build bound member functions here.
3767  if (IncludeMember) {
3768  if (const FieldDecl *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) {
3769  if (!HandleLValueMember(Info, RHS, LV, FD))
3770  return nullptr;
3771  } else if (const IndirectFieldDecl *IFD =
3772  dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) {
3773  if (!HandleLValueIndirectMember(Info, RHS, LV, IFD))
3774  return nullptr;
3775  } else {
3776  llvm_unreachable("can't construct reference to bound member function");
3777  }
3778  }
3779 
3780  return MemPtr.getDecl();
3781 }
3782 
3783 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
3784  const BinaryOperator *BO,
3785  LValue &LV,
3786  bool IncludeMember = true) {
3787  assert(BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI);
3788 
3789  if (!EvaluateObjectArgument(Info, BO->getLHS(), LV)) {
3790  if (Info.noteFailure()) {
3791  MemberPtr MemPtr;
3792  EvaluateMemberPointer(BO->getRHS(), MemPtr, Info);
3793  }
3794  return nullptr;
3795  }
3796 
3797  return HandleMemberPointerAccess(Info, BO->getLHS()->getType(), LV,
3798  BO->getRHS(), IncludeMember);
3799 }
3800 
3801 /// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on
3802 /// the provided lvalue, which currently refers to the base object.
3803 static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E,
3804  LValue &Result) {
3805  SubobjectDesignator &D = Result.Designator;
3806  if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
3807  return false;
3808 
3809  QualType TargetQT = E->getType();
3810  if (const PointerType *PT = TargetQT->getAs<PointerType>())
3811  TargetQT = PT->getPointeeType();
3812 
3813  // Check this cast lands within the final derived-to-base subobject path.
3814  if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) {
3815  Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3816  << D.MostDerivedType << TargetQT;
3817  return false;
3818  }
3819 
3820  // Check the type of the final cast. We don't need to check the path,
3821  // since a cast can only be formed if the path is unique.
3822  unsigned NewEntriesSize = D.Entries.size() - E->path_size();
3823  const CXXRecordDecl *TargetType = TargetQT->getAsCXXRecordDecl();
3824  const CXXRecordDecl *FinalType;
3825  if (NewEntriesSize == D.MostDerivedPathLength)
3826  FinalType = D.MostDerivedType->getAsCXXRecordDecl();
3827  else
3828  FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
3829  if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) {
3830  Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3831  << D.MostDerivedType << TargetQT;
3832  return false;
3833  }
3834 
3835  // Truncate the lvalue to the appropriate derived class.
3836  return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize);
3837 }
3838 
3839 namespace {
3841  /// Evaluation failed.
3842  ESR_Failed,
3843  /// Hit a 'return' statement.
3844  ESR_Returned,
3845  /// Evaluation succeeded.
3846  ESR_Succeeded,
3847  /// Hit a 'continue' statement.
3848  ESR_Continue,
3849  /// Hit a 'break' statement.
3850  ESR_Break,
3851  /// Still scanning for 'case' or 'default' statement.
3852  ESR_CaseNotFound
3853 };
3854 }
3855 
3856 static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD) {
3857  // We don't need to evaluate the initializer for a static local.
3858  if (!VD->hasLocalStorage())
3859  return true;
3860 
3861  LValue Result;
3862  APValue &Val = createTemporary(VD, true, Result, *Info.CurrentCall);
3863 
3864  const Expr *InitE = VD->getInit();
3865  if (!InitE) {
3866  Info.FFDiag(VD->getBeginLoc(), diag::note_constexpr_uninitialized)
3867  << false << VD->getType();
3868  Val = APValue();
3869  return false;
3870  }
3871 
3872  if (InitE->isValueDependent())
3873  return false;
3874 
3875  if (!EvaluateInPlace(Val, Info, Result, InitE)) {
3876  // Wipe out any partially-computed value, to allow tracking that this
3877  // evaluation failed.
3878  Val = APValue();
3879  return false;
3880  }
3881 
3882  return true;
3883 }
3884 
3885 static bool EvaluateDecl(EvalInfo &Info, const Decl *D) {
3886  bool OK = true;
3887 
3888  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
3889  OK &= EvaluateVarDecl(Info, VD);
3890 
3891  if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(D))
3892  for (auto *BD : DD->bindings())
3893  if (auto *VD = BD->getHoldingVar())
3894  OK &= EvaluateDecl(Info, VD);
3895 
3896  return OK;
3897 }
3898 
3899 
3900 /// Evaluate a condition (either a variable declaration or an expression).
3901 static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
3902  const Expr *Cond, bool &Result) {
3903  FullExpressionRAII Scope(Info);
3904  if (CondDecl && !EvaluateDecl(Info, CondDecl))
3905  return false;
3906  return EvaluateAsBooleanCondition(Cond, Result, Info);
3907 }
3908 
3909 namespace {
3910 /// A location where the result (returned value) of evaluating a
3911 /// statement should be stored.
3912 struct StmtResult {
3913  /// The APValue that should be filled in with the returned value.
3914  APValue &Value;
3915  /// The location containing the result, if any (used to support RVO).
3916  const LValue *Slot;
3917 };
3918 
3919 struct TempVersionRAII {
3920  CallStackFrame &Frame;
3921 
3922  TempVersionRAII(CallStackFrame &Frame) : Frame(Frame) {
3923  Frame.pushTempVersion();
3924  }
3925 
3926  ~TempVersionRAII() {
3927  Frame.popTempVersion();
3928  }
3929 };
3930 
3931 }
3932 
3933 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
3934  const Stmt *S,
3935  const SwitchCase *SC = nullptr);
3936 
3937 /// Evaluate the body of a loop, and translate the result as appropriate.
3938 static EvalStmtResult EvaluateLoopBody(StmtResult &Result, EvalInfo &Info,
3939  const Stmt *Body,
3940  const SwitchCase *Case = nullptr) {
3941  BlockScopeRAII Scope(Info);
3942  switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, Body, Case)) {
3943  case ESR_Break:
3944  return ESR_Succeeded;
3945  case ESR_Succeeded:
3946  case ESR_Continue:
3947  return ESR_Continue;
3948  case ESR_Failed:
3949  case ESR_Returned:
3950  case ESR_CaseNotFound:
3951  return ESR;
3952  }
3953  llvm_unreachable("Invalid EvalStmtResult!");
3954 }
3955 
3956 /// Evaluate a switch statement.
3957 static EvalStmtResult EvaluateSwitch(StmtResult &Result, EvalInfo &Info,
3958  const SwitchStmt *SS) {
3959  BlockScopeRAII Scope(Info);
3960 
3961  // Evaluate the switch condition.
3962  APSInt Value;
3963  {
3964  FullExpressionRAII Scope(Info);
3965  if (const Stmt *Init = SS->getInit()) {
3966  EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
3967  if (ESR != ESR_Succeeded)
3968  return ESR;
3969  }
3970  if (SS->getConditionVariable() &&
3971  !EvaluateDecl(Info, SS->getConditionVariable()))
3972  return ESR_Failed;
3973  if (!EvaluateInteger(SS->getCond(), Value, Info))
3974  return ESR_Failed;
3975  }
3976 
3977  // Find the switch case corresponding to the value of the condition.
3978  // FIXME: Cache this lookup.
3979  const SwitchCase *Found = nullptr;
3980  for (const SwitchCase *SC = SS->getSwitchCaseList(); SC;
3981  SC = SC->getNextSwitchCase()) {
3982  if (isa<DefaultStmt>(SC)) {
3983  Found = SC;
3984  continue;
3985  }
3986 
3987  const CaseStmt *CS = cast<CaseStmt>(SC);
3988  APSInt LHS = CS->getLHS()->EvaluateKnownConstInt(Info.Ctx);
3989  APSInt RHS = CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx)
3990  : LHS;
3991  if (LHS <= Value && Value <= RHS) {
3992  Found = SC;
3993  break;
3994  }
3995  }
3996 
3997  if (!Found)
3998  return ESR_Succeeded;
3999 
4000  // Search the switch body for the switch case and evaluate it from there.
4001  switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, SS->getBody(), Found)) {
4002  case ESR_Break:
4003  return ESR_Succeeded;
4004  case ESR_Succeeded:
4005  case ESR_Continue:
4006  case ESR_Failed:
4007  case ESR_Returned:
4008  return ESR;
4009  case ESR_CaseNotFound:
4010  // This can only happen if the switch case is nested within a statement
4011  // expression. We have no intention of supporting that.
4012  Info.FFDiag(Found->getBeginLoc(),
4013  diag::note_constexpr_stmt_expr_unsupported);
4014  return ESR_Failed;
4015  }
4016  llvm_unreachable("Invalid EvalStmtResult!");
4017 }
4018 
4019 // Evaluate a statement.
4020 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
4021  const Stmt *S, const SwitchCase *Case) {
4022  if (!Info.nextStep(S))
4023  return ESR_Failed;
4024 
4025  // If we're hunting down a 'case' or 'default' label, recurse through
4026  // substatements until we hit the label.
4027  if (Case) {
4028  // FIXME: We don't start the lifetime of objects whose initialization we
4029  // jump over. However, such objects must be of class type with a trivial
4030  // default constructor that initialize all subobjects, so must be empty,
4031  // so this almost never matters.
4032  switch (S->getStmtClass()) {
4033  case Stmt::CompoundStmtClass:
4034  // FIXME: Precompute which substatement of a compound statement we
4035  // would jump to, and go straight there rather than performing a
4036  // linear scan each time.
4037  case Stmt::LabelStmtClass:
4038  case Stmt::AttributedStmtClass:
4039  case Stmt::DoStmtClass:
4040  break;
4041 
4042  case Stmt::CaseStmtClass:
4043  case Stmt::DefaultStmtClass:
4044  if (Case == S)
4045  Case = nullptr;
4046  break;
4047 
4048  case Stmt::IfStmtClass: {
4049  // FIXME: Precompute which side of an 'if' we would jump to, and go
4050  // straight there rather than scanning both sides.
4051  const IfStmt *IS = cast<IfStmt>(S);
4052 
4053  // Wrap the evaluation in a block scope, in case it's a DeclStmt
4054  // preceded by our switch label.
4055  BlockScopeRAII Scope(Info);
4056 
4057  EvalStmtResult ESR = EvaluateStmt(Result, Info, IS->getThen(), Case);
4058  if (ESR != ESR_CaseNotFound || !IS->getElse())
4059  return ESR;
4060  return EvaluateStmt(Result, Info, IS->getElse(), Case);
4061  }
4062 
4063  case Stmt::WhileStmtClass: {
4064  EvalStmtResult ESR =
4065  EvaluateLoopBody(Result, Info, cast<WhileStmt>(S)->getBody(), Case);
4066  if (ESR != ESR_Continue)
4067  return ESR;
4068  break;
4069  }
4070 
4071  case Stmt::ForStmtClass: {
4072  const ForStmt *FS = cast<ForStmt>(S);
4073  EvalStmtResult ESR =
4074  EvaluateLoopBody(Result, Info, FS->getBody(), Case);
4075  if (ESR != ESR_Continue)
4076  return ESR;
4077  if (FS->getInc()) {
4078  FullExpressionRAII IncScope(Info);
4079  if (!EvaluateIgnoredValue(Info, FS->getInc()))
4080  return ESR_Failed;
4081  }
4082  break;
4083  }
4084 
4085  case Stmt::DeclStmtClass:
4086  // FIXME: If the variable has initialization that can't be jumped over,
4087  // bail out of any immediately-surrounding compound-statement too.
4088  default:
4089  return ESR_CaseNotFound;
4090  }
4091  }
4092 
4093  switch (S->getStmtClass()) {
4094  default:
4095  if (const Expr *E = dyn_cast<Expr>(S)) {
4096  // Don't bother evaluating beyond an expression-statement which couldn't
4097  // be evaluated.
4098  FullExpressionRAII Scope(Info);
4099  if (!EvaluateIgnoredValue(Info, E))
4100  return ESR_Failed;
4101  return ESR_Succeeded;
4102  }
4103 
4104  Info.FFDiag(S->getBeginLoc());
4105  return ESR_Failed;
4106 
4107  case Stmt::NullStmtClass:
4108  return ESR_Succeeded;
4109 
4110  case Stmt::DeclStmtClass: {
4111  const DeclStmt *DS = cast<DeclStmt>(S);
4112  for (const auto *DclIt : DS->decls()) {
4113  // Each declaration initialization is its own full-expression.
4114  // FIXME: This isn't quite right; if we're performing aggregate
4115  // initialization, each braced subexpression is its own full-expression.
4116  FullExpressionRAII Scope(Info);
4117  if (!EvaluateDecl(Info, DclIt) && !Info.noteFailure())
4118  return ESR_Failed;
4119  }
4120  return ESR_Succeeded;
4121  }
4122 
4123  case Stmt::ReturnStmtClass: {
4124  const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
4125  FullExpressionRAII Scope(Info);
4126  if (RetExpr &&
4127  !(Result.Slot
4128  ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
4129  : Evaluate(Result.Value, Info, RetExpr)))
4130  return ESR_Failed;
4131  return ESR_Returned;
4132  }
4133 
4134  case Stmt::CompoundStmtClass: {
4135  BlockScopeRAII Scope(Info);
4136 
4137  const CompoundStmt *CS = cast<CompoundStmt>(S);
4138  for (const auto *BI : CS->body()) {
4139  EvalStmtResult ESR = EvaluateStmt(Result, Info, BI, Case);
4140  if (ESR == ESR_Succeeded)
4141  Case = nullptr;
4142  else if (ESR != ESR_CaseNotFound)
4143  return ESR;
4144  }
4145  return Case ? ESR_CaseNotFound : ESR_Succeeded;
4146  }
4147 
4148  case Stmt::IfStmtClass: {
4149  const IfStmt *IS = cast<IfStmt>(S);
4150 
4151  // Evaluate the condition, as either a var decl or as an expression.
4152  BlockScopeRAII Scope(Info);
4153  if (const Stmt *Init = IS->getInit()) {
4154  EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
4155  if (ESR != ESR_Succeeded)
4156  return ESR;
4157  }
4158  bool Cond;
4159  if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
4160  return ESR_Failed;
4161 
4162  if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
4163  EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt);
4164  if (ESR != ESR_Succeeded)
4165  return ESR;
4166  }
4167  return ESR_Succeeded;
4168  }
4169 
4170  case Stmt::WhileStmtClass: {
4171  const WhileStmt *WS = cast<WhileStmt>(S);
4172  while (true) {
4173  BlockScopeRAII Scope(Info);
4174  bool Continue;
4175  if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(),
4176  Continue))
4177  return ESR_Failed;
4178  if (!Continue)
4179  break;
4180 
4181  EvalStmtResult ESR = EvaluateLoopBody(Result, Info, WS->getBody());
4182  if (ESR != ESR_Continue)
4183  return ESR;
4184  }
4185  return ESR_Succeeded;
4186  }
4187 
4188  case Stmt::DoStmtClass: {
4189  const DoStmt *DS = cast<DoStmt>(S);
4190  bool Continue;
4191  do {
4192  EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case);
4193  if (ESR != ESR_Continue)
4194  return ESR;
4195  Case = nullptr;
4196 
4197  FullExpressionRAII CondScope(Info);
4198  if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info))
4199  return ESR_Failed;
4200  } while (Continue);
4201  return ESR_Succeeded;
4202  }
4203 
4204  case Stmt::ForStmtClass: {
4205  const ForStmt *FS = cast<ForStmt>(S);
4206  BlockScopeRAII Scope(Info);
4207  if (FS->getInit()) {
4208  EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
4209  if (ESR != ESR_Succeeded)
4210  return ESR;
4211  }
4212  while (true) {
4213  BlockScopeRAII Scope(Info);
4214  bool Continue = true;
4215  if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(),
4216  FS->getCond(), Continue))
4217  return ESR_Failed;
4218  if (!Continue)
4219  break;
4220 
4221  EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody());
4222  if (ESR != ESR_Continue)
4223  return ESR;
4224 
4225  if (FS->getInc()) {
4226  FullExpressionRAII IncScope(Info);
4227  if (!EvaluateIgnoredValue(Info, FS->getInc()))
4228  return ESR_Failed;
4229  }
4230  }
4231  return ESR_Succeeded;
4232  }
4233 
4234  case Stmt::CXXForRangeStmtClass: {
4235  const CXXForRangeStmt *FS = cast<CXXForRangeStmt>(S);
4236  BlockScopeRAII Scope(Info);
4237 
4238  // Evaluate the init-statement if present.
4239  if (FS->getInit()) {
4240  EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
4241  if (ESR != ESR_Succeeded)
4242  return ESR;
4243  }
4244 
4245  // Initialize the __range variable.
4246  EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getRangeStmt());
4247  if (ESR != ESR_Succeeded)
4248  return ESR;
4249 
4250  // Create the __begin and __end iterators.
4251  ESR = EvaluateStmt(Result, Info, FS->getBeginStmt());
4252  if (ESR != ESR_Succeeded)
4253  return ESR;
4254  ESR = EvaluateStmt(Result, Info, FS->getEndStmt());
4255  if (ESR != ESR_Succeeded)
4256  return ESR;
4257 
4258  while (true) {
4259  // Condition: __begin != __end.
4260  {
4261  bool Continue = true;
4262  FullExpressionRAII CondExpr(Info);
4263  if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info))
4264  return ESR_Failed;
4265  if (!Continue)
4266  break;
4267  }
4268 
4269  // User's variable declaration, initialized by *__begin.
4270  BlockScopeRAII InnerScope(Info);
4271  ESR = EvaluateStmt(Result, Info, FS->getLoopVarStmt());
4272  if (ESR != ESR_Succeeded)
4273  return ESR;
4274 
4275  // Loop body.
4276  ESR = EvaluateLoopBody(Result, Info, FS->getBody());
4277  if (ESR != ESR_Continue)
4278  return ESR;
4279 
4280  // Increment: ++__begin
4281  if (!EvaluateIgnoredValue(Info, FS->getInc()))
4282  return ESR_Failed;
4283  }
4284 
4285  return ESR_Succeeded;
4286  }
4287 
4288  case Stmt::SwitchStmtClass:
4289  return EvaluateSwitch(Result, Info, cast<SwitchStmt>(S));
4290 
4291  case Stmt::ContinueStmtClass:
4292  return ESR_Continue;
4293 
4294  case Stmt::BreakStmtClass:
4295  return ESR_Break;
4296 
4297  case Stmt::LabelStmtClass:
4298  return EvaluateStmt(Result, Info, cast<LabelStmt>(S)->getSubStmt(), Case);
4299 
4300  case Stmt::AttributedStmtClass:
4301  // As a general principle, C++11 attributes can be ignored without
4302  // any semantic impact.
4303  return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(),
4304  Case);
4305 
4306  case Stmt::CaseStmtClass:
4307  case Stmt::DefaultStmtClass:
4308  return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case);
4309  case Stmt::CXXTryStmtClass:
4310  // Evaluate try blocks by evaluating all sub statements.
4311  return EvaluateStmt(Result, Info, cast<CXXTryStmt>(S)->getTryBlock(), Case);
4312  }
4313 }
4314 
4315 /// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial
4316 /// default constructor. If so, we'll fold it whether or not it's marked as
4317 /// constexpr. If it is marked as constexpr, we will never implicitly define it,
4318 /// so we need special handling.
4319 static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,
4320  const CXXConstructorDecl *CD,
4321  bool IsValueInitialization) {
4322  if (!CD->isTrivial() || !CD->isDefaultConstructor())
4323  return false;
4324 
4325  // Value-initialization does not call a trivial default constructor, so such a
4326  // call is a core constant expression whether or not the constructor is
4327  // constexpr.
4328  if (!CD->isConstexpr() && !IsValueInitialization) {
4329  if (Info.getLangOpts().CPlusPlus11) {
4330  // FIXME: If DiagDecl is an implicitly-declared special member function,
4331  // we should be much more explicit about why it's not constexpr.
4332  Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
4333  << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD;
4334  Info.Note(CD->getLocation(), diag::note_declared_at);
4335  } else {
4336  Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
4337  }
4338  }
4339  return true;
4340 }
4341 
4342 /// CheckConstexprFunction - Check that a function can be called in a constant
4343 /// expression.
4344 static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc,
4345  const FunctionDecl *Declaration,
4346  const FunctionDecl *Definition,
4347  const Stmt *Body) {
4348  // Potential constant expressions can contain calls to declared, but not yet
4349  // defined, constexpr functions.
4350  if (Info.checkingPotentialConstantExpression() && !Definition &&
4351  Declaration->isConstexpr())
4352  return false;
4353 
4354  // Bail out if the function declaration itself is invalid. We will
4355  // have produced a relevant diagnostic while parsing it, so just
4356  // note the problematic sub-expression.
4357  if (Declaration->isInvalidDecl()) {
4358  Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
4359  return false;
4360  }
4361 
4362  // Can we evaluate this function call?
4363  if (Definition && Definition->isConstexpr() &&
4364  !Definition->isInvalidDecl() && Body)
4365  return true;
4366 
4367  if (Info.getLangOpts().CPlusPlus11) {
4368  const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;
4369 
4370  // If this function is not constexpr because it is an inherited
4371  // non-constexpr constructor, diagnose that directly.
4372  auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
4373  if (CD && CD->isInheritingConstructor()) {
4374  auto *Inherited = CD->getInheritedConstructor().getConstructor();
4375  if (!Inherited->isConstexpr())
4376  DiagDecl = CD = Inherited;
4377  }
4378 
4379  // FIXME: If DiagDecl is an implicitly-declared special member function
4380  // or an inheriting constructor, we should be much more explicit about why
4381  // it's not constexpr.
4382  if (CD && CD->isInheritingConstructor())
4383  Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1)
4384  << CD->getInheritedConstructor().getConstructor()->getParent();
4385  else
4386  Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1)
4387  << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
4388  Info.Note(DiagDecl->getLocation(), diag::note_declared_at);
4389  } else {
4390  Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
4391  }
4392  return false;
4393 }
4394 
4395 /// Determine if a class has any fields that might need to be copied by a
4396 /// trivial copy or move operation.
4397 static bool hasFields(const CXXRecordDecl *RD) {
4398  if (!RD || RD->isEmpty())
4399  return false;
4400  for (auto *FD : RD->fields()) {
4401  if (FD->isUnnamedBitfield())
4402  continue;
4403  return true;
4404  }
4405  for (auto &Base : RD->bases())
4406  if (hasFields(Base.getType()->getAsCXXRecordDecl()))
4407  return true;
4408  return false;
4409 }
4410 
4411 namespace {
4412 typedef SmallVector<APValue, 8> ArgVector;
4413 }
4414 
4415 /// EvaluateArgs - Evaluate the arguments to a function call.
4416 static bool EvaluateArgs(ArrayRef<const Expr*> Args, ArgVector &ArgValues,
4417  EvalInfo &Info) {
4418  bool Success = true;
4419  for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end();
4420  I != E; ++I) {
4421  if (!Evaluate(ArgValues[I - Args.begin()], Info, *I)) {
4422  // If we're checking for a potential constant expression, evaluate all
4423  // initializers even if some of them fail.
4424  if (!Info.noteFailure())
4425  return false;
4426  Success = false;
4427  }
4428  }
4429  return Success;
4430 }
4431 
4432 /// Evaluate a function call.
4434  const FunctionDecl *Callee, const LValue *This,
4435  ArrayRef<const Expr*> Args, const Stmt *Body,
4436  EvalInfo &Info, APValue &Result,
4437  const LValue *ResultSlot) {
4438  ArgVector ArgValues(Args.size());
4439  if (!EvaluateArgs(Args, ArgValues, Info))
4440  return false;
4441 
4442  if (!Info.CheckCallLimit(CallLoc))
4443  return false;
4444 
4445  CallStackFrame Frame(Info, CallLoc, Callee, This, ArgValues.data());
4446 
4447  // For a trivial copy or move assignment, perform an APValue copy. This is
4448  // essential for unions, where the operations performed by the assignment
4449  // operator cannot be represented as statements.
4450  //
4451  // Skip this for non-union classes with no fields; in that case, the defaulted
4452  // copy/move does not actually read the object.
4453  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee);
4454  if (MD && MD->isDefaulted() &&
4455  (MD->getParent()->isUnion() ||
4456  (MD->isTrivial() && hasFields(MD->getParent())))) {
4457  assert(This &&
4458  (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()));
4459  LValue RHS;
4460  RHS.setFrom(Info.Ctx, ArgValues[0]);
4461  APValue RHSValue;
4462  if (!handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(),
4463  RHS, RHSValue))
4464  return false;
4465  if (!handleAssignment(Info, Args[0], *This, MD->getThisType(),
4466  RHSValue))
4467  return false;
4468  This->moveInto(Result);
4469  return true;
4470  } else if (MD && isLambdaCallOperator(MD)) {
4471  // We're in a lambda; determine the lambda capture field maps unless we're
4472  // just constexpr checking a lambda's call operator. constexpr checking is
4473  // done before the captures have been added to the closure object (unless
4474  // we're inferring constexpr-ness), so we don't have access to them in this
4475  // case. But since we don't need the captures to constexpr check, we can
4476  // just ignore them.
4477  if (!Info.checkingPotentialConstantExpression())
4478  MD->getParent()->getCaptureFields(Frame.LambdaCaptureFields,
4479  Frame.LambdaThisCaptureField);
4480  }
4481 
4482  StmtResult Ret = {Result, ResultSlot};
4483  EvalStmtResult ESR = EvaluateStmt(Ret, Info, Body);
4484  if (ESR == ESR_Succeeded) {
4485  if (Callee->getReturnType()->isVoidType())
4486  return true;
4487  Info.FFDiag(Callee->getEndLoc(), diag::note_constexpr_no_return);
4488  }
4489  return ESR == ESR_Returned;
4490 }
4491 
4492 /// Evaluate a constructor call.
4493 static bool HandleConstructorCall(const Expr *E, const LValue &This,
4494  APValue *ArgValues,
4495  const CXXConstructorDecl *Definition,
4496  EvalInfo &Info, APValue &Result) {
4497  SourceLocation CallLoc = E->getExprLoc();
4498  if (!Info.CheckCallLimit(CallLoc))
4499  return false;
4500 
4501  const CXXRecordDecl *RD = Definition->getParent();
4502  if (RD->getNumVBases()) {
4503  Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
4504  return false;
4505  }
4506 
4507  EvalInfo::EvaluatingConstructorRAII EvalObj(
4508  Info, {This.getLValueBase(),
4509  {This.getLValueCallIndex(), This.getLValueVersion()}});
4510  CallStackFrame Frame(Info, CallLoc, Definition, &This, ArgValues);
4511 
4512  // FIXME: Creating an APValue just to hold a nonexistent return value is
4513  // wasteful.
4514  APValue RetVal;
4515  StmtResult Ret = {RetVal, nullptr};
4516 
4517  // If it's a delegating constructor, delegate.
4518  if (Definition->isDelegatingConstructor()) {
4520  {
4521  FullExpressionRAII InitScope(Info);
4522  if (!EvaluateInPlace(Result, Info, This, (*I)->getInit()))
4523  return false;
4524  }
4525  return EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed;
4526  }
4527 
4528  // For a trivial copy or move constructor, perform an APValue copy. This is
4529  // essential for unions (or classes with anonymous union members), where the
4530  // operations performed by the constructor cannot be represented by
4531  // ctor-initializers.
4532  //
4533  // Skip this for empty non-union classes; we should not perform an
4534  // lvalue-to-rvalue conversion on them because their copy constructor does not
4535  // actually read them.
4536  if (Definition->isDefaulted() && Definition->isCopyOrMoveConstructor() &&
4537  (Definition->getParent()->isUnion() ||
4538  (Definition->isTrivial() && hasFields(Definition->getParent())))) {
4539  LValue RHS;
4540  RHS.setFrom(Info.Ctx, ArgValues[0]);
4542  Info, E, Definition->getParamDecl(0)->getType().getNonReferenceType(),
4543  RHS, Result);
4544  }
4545 
4546  // Reserve space for the struct members.
4547  if (!RD->isUnion() && Result.isUninit())
4548  Result = APValue(APValue::UninitStruct(), RD->getNumBases(),
4549  std::distance(RD->field_begin(), RD->field_end()));
4550 
4551  if (RD->isInvalidDecl()) return false;
4552  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
4553 
4554  // A scope for temporaries lifetime-extended by reference members.
4555  BlockScopeRAII LifetimeExtendedScope(Info);
4556 
4557  bool Success = true;
4558  unsigned BasesSeen = 0;
4559 #ifndef NDEBUG
4561 #endif
4562  for (const auto *I : Definition->inits()) {
4563  LValue Subobject = This;
4564  LValue SubobjectParent = This;
4565  APValue *Value = &Result;
4566 
4567  // Determine the subobject to initialize.
4568  FieldDecl *FD = nullptr;
4569  if (I->isBaseInitializer()) {
4570  QualType BaseType(I->getBaseClass(), 0);
4571 #ifndef NDEBUG
4572  // Non-virtual base classes are initialized in the order in the class
4573  // definition. We have already checked for virtual base classes.
4574  assert(!BaseIt->isVirtual() && "virtual base for literal type");
4575  assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&
4576  "base class initializers not in expected order");
4577  ++BaseIt;
4578 #endif
4579  if (!HandleLValueDirectBase(Info, I->getInit(), Subobject, RD,
4580  BaseType->getAsCXXRecordDecl(), &Layout))
4581  return false;
4582  Value = &Result.getStructBase(BasesSeen++);
4583  } else if ((FD = I->getMember())) {
4584  if (!HandleLValueMember(Info, I->getInit(), Subobject, FD, &Layout))
4585  return false;
4586  if (RD->isUnion()) {
4587  Result = APValue(FD);
4588  Value = &Result.getUnionValue();
4589  } else {
4590  Value = &Result.getStructField(FD->getFieldIndex());
4591  }
4592  } else if (IndirectFieldDecl *IFD = I->getIndirectMember()) {
4593  // Walk the indirect field decl's chain to find the object to initialize,
4594  // and make sure we've initialized every step along it.
4595  auto IndirectFieldChain = IFD->chain();
4596  for (auto *C : IndirectFieldChain) {
4597  FD = cast<FieldDecl>(C);
4598  CXXRecordDecl *CD = cast<CXXRecordDecl>(FD->getParent());
4599  // Switch the union field if it differs. This happens if we had
4600  // preceding zero-initialization, and we're now initializing a union
4601  // subobject other than the first.
4602  // FIXME: In this case, the values of the other subobjects are
4603  // specified, since zero-initialization sets all padding bits to zero.
4604  if (Value->isUninit() ||
4605  (Value->isUnion() && Value->getUnionField() != FD)) {
4606  if (CD->isUnion())
4607  *Value = APValue(FD);
4608  else
4609  *Value = APValue(APValue::UninitStruct(), CD->getNumBases(),
4610  std::distance(CD->field_begin(), CD->field_end()));
4611  }
4612  // Store Subobject as its parent before updating it for the last element
4613  // in the chain.
4614  if (C == IndirectFieldChain.back())
4615  SubobjectParent = Subobject;
4616  if (!HandleLValueMember(Info, I->getInit(), Subobject, FD))
4617  return false;
4618  if (CD->isUnion())
4619  Value = &Value->getUnionValue();
4620  else
4621  Value = &Value->getStructField(FD->getFieldIndex());
4622  }
4623  } else {
4624  llvm_unreachable("unknown base initializer kind");
4625  }
4626 
4627  // Need to override This for implicit field initializers as in this case
4628  // This refers to innermost anonymous struct/union containing initializer,
4629  // not to currently constructed class.
4630  const Expr *Init = I->getInit();
4631  ThisOverrideRAII ThisOverride(*Info.CurrentCall, &SubobjectParent,
4632  isa<CXXDefaultInitExpr>(Init));
4633  FullExpressionRAII InitScope(Info);
4634  if (!EvaluateInPlace(*Value, Info, Subobject, Init) ||
4635  (FD && FD->isBitField() &&
4636  !truncateBitfieldValue(Info, Init, *Value, FD))) {
4637  // If we're checking for a potential constant expression, evaluate all
4638  // initializers even if some of them fail.
4639  if (!Info.noteFailure())
4640  return false;
4641  Success = false;
4642  }
4643  }
4644 
4645  return Success &&
4646  EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed;
4647 }
4648 
4649 static bool HandleConstructorCall(const Expr *E, const LValue &This,
4650  ArrayRef<const Expr*> Args,
4651  const CXXConstructorDecl *Definition,
4652  EvalInfo &Info, APValue &Result) {
4653  ArgVector ArgValues(Args.size());
4654  if (!EvaluateArgs(Args, ArgValues, Info))
4655  return false;
4656 
4657  return HandleConstructorCall(E, This, ArgValues.data(), Definition,
4658  Info, Result);
4659 }
4660 
4661 //===----------------------------------------------------------------------===//
4662 // Generic Evaluation
4663 //===----------------------------------------------------------------------===//
4664 namespace {
4665 
4666 template <class Derived>
4667 class ExprEvaluatorBase
4668  : public ConstStmtVisitor<Derived, bool> {
4669 private:
4670  Derived &getDerived() { return static_cast<Derived&>(*this); }
4671  bool DerivedSuccess(const APValue &V, const Expr *E) {
4672  return getDerived().Success(V, E);
4673  }
4674  bool DerivedZeroInitialization(const Expr *E) {
4675  return getDerived().ZeroInitialization(E);
4676  }
4677 
4678  // Check whether a conditional operator with a non-constant condition is a
4679  // potential constant expression. If neither arm is a potential constant
4680  // expression, then the conditional operator is not either.
4681  template<typename ConditionalOperator>
4682  void CheckPotentialConstantConditional(const ConditionalOperator *E) {
4683  assert(Info.checkingPotentialConstantExpression());
4684 
4685  // Speculatively evaluate both arms.
4687  {
4688  SpeculativeEvaluationRAII Speculate(Info, &Diag);
4689  StmtVisitorTy::Visit(E->getFalseExpr());
4690  if (Diag.empty())
4691  return;
4692  }
4693 
4694  {
4695  SpeculativeEvaluationRAII Speculate(Info, &Diag);
4696  Diag.clear();
4697  StmtVisitorTy::Visit(E->getTrueExpr());
4698  if (Diag.empty())
4699  return;
4700  }
4701 
4702  Error(E, diag::note_constexpr_conditional_never_const);
4703  }
4704 
4705 
4706  template<typename ConditionalOperator>
4707  bool HandleConditionalOperator(const ConditionalOperator *E) {
4708  bool BoolResult;
4709  if (!EvaluateAsBooleanCondition(E->getCond(), BoolResult, Info)) {
4710  if (Info.checkingPotentialConstantExpression() && Info.noteFailure()) {
4711  CheckPotentialConstantConditional(E);
4712  return false;
4713  }
4714  if (Info.noteFailure()) {
4715  StmtVisitorTy::Visit(E->getTrueExpr());
4716  StmtVisitorTy::Visit(E->getFalseExpr());
4717  }
4718  return false;
4719  }
4720 
4721  Expr *EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr();
4722  return StmtVisitorTy::Visit(EvalExpr);
4723  }
4724 
4725 protected:
4726  EvalInfo &Info;
4727  typedef ConstStmtVisitor<Derived, bool> StmtVisitorTy;
4728  typedef ExprEvaluatorBase ExprEvaluatorBaseTy;
4729 
4730  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
4731  return Info.CCEDiag(E, D);
4732  }
4733 
4734  bool ZeroInitialization(const Expr *E) { return Error(E); }
4735 
4736 public:
4737  ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
4738 
4739  EvalInfo &getEvalInfo() { return Info; }
4740 
4741  /// Report an evaluation error. This should only be called when an error is
4742  /// first discovered. When propagating an error, just return false.
4743  bool Error(const Expr *E, diag::kind D) {
4744  Info.FFDiag(E, D);
4745  return false;
4746  }
4747  bool Error(const Expr *E) {
4748  return Error(E, diag::note_invalid_subexpr_in_const_expr);
4749  }
4750 
4751  bool VisitStmt(const Stmt *) {
4752  llvm_unreachable("Expression evaluator should not be called on stmts");
4753  }
4754  bool VisitExpr(const Expr *E) {
4755  return Error(E);
4756  }
4757 
4758  bool VisitConstantExpr(const ConstantExpr *E)
4759  { return StmtVisitorTy::Visit(E->getSubExpr()); }
4760  bool VisitParenExpr(const ParenExpr *E)
4761  { return StmtVisitorTy::Visit(E->getSubExpr()); }
4762  bool VisitUnaryExtension(const UnaryOperator *E)
4763  { return StmtVisitorTy::Visit(E->getSubExpr()); }
4764  bool VisitUnaryPlus(const UnaryOperator *E)
4765  { return StmtVisitorTy::Visit(E->getSubExpr()); }
4766  bool VisitChooseExpr(const ChooseExpr *E)
4767  { return StmtVisitorTy::Visit(E->getChosenSubExpr()); }
4768  bool VisitGenericSelectionExpr(const GenericSelectionExpr *E)
4769  { return StmtVisitorTy::Visit(E->getResultExpr()); }
4770  bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E)
4771  { return StmtVisitorTy::Visit(E->getReplacement()); }
4772  bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) {
4773  TempVersionRAII RAII(*Info.CurrentCall);
4774  return StmtVisitorTy::Visit(E->getExpr());
4775  }
4776  bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
4777  TempVersionRAII RAII(*Info.CurrentCall);
4778  // The initializer may not have been parsed yet, or might be erroneous.
4779  if (!E->getExpr())
4780  return Error(E);
4781  return StmtVisitorTy::Visit(E->getExpr());
4782  }
4783  // We cannot create any objects for which cleanups are required, so there is
4784  // nothing to do here; all cleanups must come from unevaluated subexpressions.
4785  bool VisitExprWithCleanups(const ExprWithCleanups *E)
4786  { return StmtVisitorTy::Visit(E->getSubExpr()); }
4787 
4788  bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
4789  CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
4790  return static_cast<Derived*>(this)->VisitCastExpr(E);
4791  }
4792  bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
4793  CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
4794  return static_cast<Derived*>(this)->VisitCastExpr(E);
4795  }
4796 
4797  bool VisitBinaryOperator(const BinaryOperator *E) {
4798  switch (E->getOpcode()) {
4799  default:
4800  return Error(E);
4801 
4802  case BO_Comma:
4803  VisitIgnoredValue(E->getLHS());
4804  return StmtVisitorTy::Visit(E->getRHS());
4805 
4806  case BO_PtrMemD:
4807  case BO_PtrMemI: {
4808  LValue Obj;
4809  if (!HandleMemberPointerAccess(Info, E, Obj))
4810  return false;
4811  APValue Result;
4812  if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result))
4813  return false;
4814  return DerivedSuccess(Result, E);
4815  }
4816  }
4817  }
4818 
4819  bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E) {
4820  // Evaluate and cache the common expression. We treat it as a temporary,
4821  // even though it's not quite the same thing.
4822  if (!Evaluate(Info.CurrentCall->createTemporary(E->getOpaqueValue(), false),
4823  Info, E->getCommon()))
4824  return false;
4825 
4826  return HandleConditionalOperator(E);
4827  }
4828 
4829  bool VisitConditionalOperator(const ConditionalOperator *E) {
4830  bool IsBcpCall = false;
4831  // If the condition (ignoring parens) is a __builtin_constant_p call,
4832  // the result is a constant expression if it can be folded without
4833  // side-effects. This is an important GNU extension. See GCC PR38377
4834  // for discussion.
4835  if (const CallExpr *CallCE =
4836  dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
4837  if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
4838  IsBcpCall = true;
4839 
4840  // Always assume __builtin_constant_p(...) ? ... : ... is a potential
4841  // constant expression; we can't check whether it's potentially foldable.
4842  if (Info.checkingPotentialConstantExpression() && IsBcpCall)
4843  return false;
4844 
4845  FoldConstant Fold(Info, IsBcpCall);
4846  if (!HandleConditionalOperator(E)) {
4847  Fold.keepDiagnostics();
4848  return false;
4849  }
4850 
4851  return true;
4852  }
4853 
4854  bool VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
4855  if (APValue *Value = Info.CurrentCall->getCurrentTemporary(E))
4856  return DerivedSuccess(*Value, E);
4857 
4858  const Expr *Source = E->getSourceExpr();
4859  if (!Source)
4860  return Error(E);
4861  if (Source == E) { // sanity checking.
4862  assert(0 && "OpaqueValueExpr recursively refers to itself");
4863  return Error(E);
4864  }
4865  return StmtVisitorTy::Visit(Source);
4866  }
4867 
4868  bool VisitCallExpr(const CallExpr *E) {
4869  APValue Result;
4870  if (!handleCallExpr(E, Result, nullptr))
4871  return false;
4872  return DerivedSuccess(Result, E);
4873  }
4874 
4875  bool handleCallExpr(const CallExpr *E, APValue &Result,
4876  const LValue *ResultSlot) {
4877  const Expr *Callee = E->getCallee()->IgnoreParens();
4878  QualType CalleeType = Callee->getType();
4879 
4880  const FunctionDecl *FD = nullptr;
4881  LValue *This = nullptr, ThisVal;
4882  auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
4883  bool HasQualifier = false;
4884 
4885  // Extract function decl and 'this' pointer from the callee.
4886  if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) {
4887  const ValueDecl *Member = nullptr;
4888  if (const MemberExpr *ME = dyn_cast<MemberExpr>(Callee)) {
4889  // Explicit bound member calls, such as x.f() or p->g();
4890  if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal))
4891  return false;
4892  Member = ME->getMemberDecl();
4893  This = &ThisVal;
4894  HasQualifier = ME->hasQualifier();
4895  } else if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) {
4896  // Indirect bound member calls ('.*' or '->*').
4897  Member = HandleMemberPointerAccess(Info, BE, ThisVal, false);
4898  if (!Member) return false;
4899  This = &ThisVal;
4900  } else
4901  return Error(Callee);
4902 
4903  FD = dyn_cast<FunctionDecl>(Member);
4904  if (!FD)
4905  return Error(Callee);
4906  } else if (CalleeType->isFunctionPointerType()) {
4907  LValue Call;
4908  if (!EvaluatePointer(Callee, Call, Info))
4909  return false;
4910 
4911  if (!Call.getLValueOffset().isZero())
4912  return Error(Callee);
4913  FD = dyn_cast_or_null<FunctionDecl>(
4914  Call.getLValueBase().dyn_cast<const ValueDecl*>());
4915  if (!FD)
4916  return Error(Callee);
4917  // Don't call function pointers which have been cast to some other type.
4918  // Per DR (no number yet), the caller and callee can differ in noexcept.
4919  if (!Info.Ctx.hasSameFunctionTypeIgnoringExceptionSpec(
4920  CalleeType->getPointeeType(), FD->getType())) {
4921  return Error(E);
4922  }
4923 
4924  // Overloaded operator calls to member functions are represented as normal
4925  // calls with '*this' as the first argument.
4926  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
4927  if (MD && !MD->isStatic()) {
4928  // FIXME: When selecting an implicit conversion for an overloaded
4929  // operator delete, we sometimes try to evaluate calls to conversion
4930  // operators without a 'this' parameter!
4931  if (Args.empty())
4932  return Error(E);
4933 
4934  if (!EvaluateObjectArgument(Info, Args[0], ThisVal))
4935  return false;
4936  This = &ThisVal;
4937  Args = Args.slice(1);
4938  } else if (MD && MD->isLambdaStaticInvoker()) {
4939  // Map the static invoker for the lambda back to the call operator.
4940  // Conveniently, we don't have to slice out the 'this' argument (as is
4941  // being done for the non-static case), since a static member function
4942  // doesn't have an implicit argument passed in.
4943  const CXXRecordDecl *ClosureClass = MD->getParent();
4944  assert(
4945  ClosureClass->captures_begin() == ClosureClass->captures_end() &&
4946  "Number of captures must be zero for conversion to function-ptr");
4947 
4948  const CXXMethodDecl *LambdaCallOp =
4949  ClosureClass->getLambdaCallOperator();
4950 
4951  // Set 'FD', the function that will be called below, to the call
4952  // operator. If the closure object represents a generic lambda, find
4953  // the corresponding specialization of the call operator.
4954 
4955  if (ClosureClass->isGenericLambda()) {
4956  assert(MD->isFunctionTemplateSpecialization() &&
4957  "A generic lambda's static-invoker function must be a "
4958  "template specialization");
4960  FunctionTemplateDecl *CallOpTemplate =
4961  LambdaCallOp->getDescribedFunctionTemplate();
4962  void *InsertPos = nullptr;
4963  FunctionDecl *CorrespondingCallOpSpecialization =
4964  CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos);
4965  assert(CorrespondingCallOpSpecialization &&
4966  "We must always have a function call operator specialization "
4967  "that corresponds to our static invoker specialization");
4968  FD = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization);
4969  } else
4970  FD = LambdaCallOp;
4971  }
4972 
4973 
4974  } else
4975  return Error(E);
4976 
4977  if (This && !This->checkSubobject(Info, E, CSK_This))
4978  return false;
4979 
4980  // DR1358 allows virtual constexpr functions in some cases. Don't allow
4981  // calls to such functions in constant expressions.
4982  if (This && !HasQualifier &&
4983  isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isVirtual())
4984  return Error(E, diag::note_constexpr_virtual_call);
4985 
4986  const FunctionDecl *Definition = nullptr;
4987  Stmt *Body = FD->getBody(Definition);
4988 
4989  if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body) ||
4990  !HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Body, Info,
4991  Result, ResultSlot))
4992  return false;
4993 
4994  return true;
4995  }
4996 
4997  bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
4998  return StmtVisitorTy::Visit(E->getInitializer());
4999  }
5000  bool VisitInitListExpr(const InitListExpr *E) {
5001  if (E->getNumInits() == 0)
5002  return DerivedZeroInitialization(E);
5003  if (E->getNumInits() == 1)
5004  return StmtVisitorTy::Visit(E->getInit(0));
5005  return Error(E);
5006  }
5007  bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
5008  return DerivedZeroInitialization(E);
5009  }
5010  bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
5011  return DerivedZeroInitialization(E);
5012  }
5013  bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
5014  return DerivedZeroInitialization(E);
5015  }
5016 
5017  /// A member expression where the object is a prvalue is itself a prvalue.
5018  bool VisitMemberExpr(const MemberExpr *E) {
5019  assert(!E->isArrow() && "missing call to bound member function?");
5020 
5021  APValue Val;
5022  if (!Evaluate(Val, Info, E->getBase()))
5023  return false;
5024 
5025  QualType BaseTy = E->getBase()->getType();
5026 
5027  const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
5028  if (!FD) return Error(E);
5029  assert(!FD->getType()->isReferenceType() && "prvalue reference?");
5030  assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() ==
5031  FD->getParent()->getCanonicalDecl() && "record / field mismatch");
5032 
5033  CompleteObject Obj(&Val, BaseTy, true);
5034  SubobjectDesignator Designator(BaseTy);
5035  Designator.addDeclUnchecked(FD);
5036 
5037  APValue Result;
5038  return extractSubobject(Info, E, Obj, Designator, Result) &&
5039  DerivedSuccess(Result, E);
5040  }
5041 
5042  bool VisitCastExpr(const CastExpr *E) {
5043  switch (E->getCastKind()) {
5044  default:
5045  break;
5046 
5047  case CK_AtomicToNonAtomic: {
5048  APValue AtomicVal;
5049  // This does not need to be done in place even for class/array types:
5050  // atomic-to-non-atomic conversion implies copying the object
5051  // representation.
5052  if (!Evaluate(AtomicVal, Info, E->getSubExpr()))
5053  return false;
5054  return DerivedSuccess(AtomicVal, E);
5055  }
5056 
5057  case CK_NoOp:
5058  case CK_UserDefinedConversion:
5059  return StmtVisitorTy::Visit(E->getSubExpr());
5060 
5061  case CK_LValueToRValue: {
5062  LValue LVal;
5063  if (!EvaluateLValue(E->getSubExpr(), LVal, Info))
5064  return false;
5065  APValue RVal;
5066  // Note, we use the subexpression's type in order to retain cv-qualifiers.
5067  if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
5068  LVal, RVal))
5069  return false;
5070  return DerivedSuccess(RVal, E);
5071  }
5072  }
5073 
5074  return Error(E);
5075  }
5076 
5077  bool VisitUnaryPostInc(const UnaryOperator *UO) {
5078  return VisitUnaryPostIncDec(UO);
5079  }
5080  bool VisitUnaryPostDec(const UnaryOperator *UO) {
5081  return VisitUnaryPostIncDec(UO);
5082  }
5083  bool VisitUnaryPostIncDec(const UnaryOperator *UO) {
5084  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5085  return Error(UO);
5086 
5087  LValue LVal;
5088  if (!EvaluateLValue(UO->getSubExpr(), LVal, Info))
5089  return false;
5090  APValue RVal;
5091  if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(),
5092  UO->isIncrementOp(), &RVal))
5093  return false;
5094  return DerivedSuccess(RVal, UO);
5095  }
5096 
5097  bool VisitStmtExpr(const StmtExpr *E) {
5098  // We will have checked the full-expressions inside the statement expression
5099  // when they were completed, and don't need to check them again now.
5100  if (Info.checkingForOverflow())
5101  return Error(E);
5102 
5103  BlockScopeRAII Scope(Info);
5104  const CompoundStmt *CS = E->getSubStmt();
5105  if (CS->body_empty())
5106  return true;
5107 
5109  BE = CS->body_end();
5110  /**/; ++BI) {
5111  if (BI + 1 == BE) {
5112  const Expr *FinalExpr = dyn_cast<Expr>(*BI);
5113  if (!FinalExpr) {
5114  Info.FFDiag((*BI)->getBeginLoc(),
5115  diag::note_constexpr_stmt_expr_unsupported);
5116  return false;
5117  }
5118  return this->Visit(FinalExpr);
5119  }
5120 
5121  APValue ReturnValue;
5122  StmtResult Result = { ReturnValue, nullptr };
5123  EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI);
5124  if (ESR != ESR_Succeeded) {
5125  // FIXME: If the statement-expression terminated due to 'return',
5126  // 'break', or 'continue', it would be nice to propagate that to
5127  // the outer statement evaluation rather than bailing out.
5128  if (ESR != ESR_Failed)
5129  Info.FFDiag((*BI)->getBeginLoc(),
5130  diag::note_constexpr_stmt_expr_unsupported);
5131  return false;
5132  }
5133  }
5134 
5135  llvm_unreachable("Return from function from the loop above.");
5136  }
5137 
5138  /// Visit a value which is evaluated, but whose value is ignored.
5139  void VisitIgnoredValue(const Expr *E) {
5140  EvaluateIgnoredValue(Info, E);
5141  }
5142 
5143  /// Potentially visit a MemberExpr's base expression.
5144  void VisitIgnoredBaseExpression(const Expr *E) {
5145  // While MSVC doesn't evaluate the base expression, it does diagnose the
5146  // presence of side-effecting behavior.
5147  if (Info.getLangOpts().MSVCCompat && !E->HasSideEffects(Info.Ctx))
5148  return;
5149  VisitIgnoredValue(E);
5150  }
5151 };
5152 
5153 } // namespace
5154 
5155 //===----------------------------------------------------------------------===//
5156 // Common base class for lvalue and temporary evaluation.
5157 //===----------------------------------------------------------------------===//
5158 namespace {
5159 template<class Derived>
5160 class LValueExprEvaluatorBase
5161  : public ExprEvaluatorBase<Derived> {
5162 protected:
5163  LValue &Result;
5164  bool InvalidBaseOK;
5165  typedef LValueExprEvaluatorBase LValueExprEvaluatorBaseTy;
5166  typedef ExprEvaluatorBase<Derived> ExprEvaluatorBaseTy;
5167 
5168  bool Success(APValue::LValueBase B) {
5169  Result.set(B);
5170  return true;
5171  }
5172 
5173  bool evaluatePointer(const Expr *E, LValue &Result) {
5174  return EvaluatePointer(E, Result, this->Info, InvalidBaseOK);
5175  }
5176 
5177 public:
5178  LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result, bool InvalidBaseOK)
5179  : ExprEvaluatorBaseTy(Info), Result(Result),
5180  InvalidBaseOK(InvalidBaseOK) {}
5181 
5182  bool Success(const APValue &V, const Expr *E) {
5183  Result.setFrom(this->Info.Ctx, V);
5184  return true;
5185  }
5186 
5187  bool VisitMemberExpr(const MemberExpr *E) {
5188  // Handle non-static data members.
5189  QualType BaseTy;
5190  bool EvalOK;
5191  if (E->isArrow()) {
5192  EvalOK = evaluatePointer(E->getBase(), Result);
5193  BaseTy = E->getBase()->getType()->castAs<PointerType>()->getPointeeType();
5194  } else if (E->getBase()->isRValue()) {
5195  assert(E->getBase()->getType()->isRecordType());
5196  EvalOK = EvaluateTemporary(E->getBase(), Result, this->Info);
5197  BaseTy = E->getBase()->getType();
5198  } else {
5199  EvalOK = this->Visit(E->getBase());
5200  BaseTy = E->getBase()->getType();
5201  }
5202  if (!EvalOK) {
5203  if (!InvalidBaseOK)
5204  return false;
5205  Result.setInvalid(E);
5206  return true;
5207  }
5208 
5209  const ValueDecl *MD = E->getMemberDecl();
5210  if (const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
5211  assert(BaseTy->getAs<RecordType>()->getDecl()->getCanonicalDecl() ==
5212  FD->getParent()->getCanonicalDecl() && "record / field mismatch");
5213  (void)BaseTy;
5214  if (!HandleLValueMember(this->Info, E, Result, FD))
5215  return false;
5216  } else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(MD)) {
5217  if (!HandleLValueIndirectMember(this->Info, E, Result, IFD))
5218  return false;
5219  } else
5220  return this->Error(E);
5221 
5222  if (MD->getType()->isReferenceType()) {
5223  APValue RefValue;
5224  if (!handleLValueToRValueConversion(this->Info, E, MD->getType(), Result,
5225  RefValue))
5226  return false;
5227  return Success(RefValue, E);
5228  }
5229  return true;
5230  }
5231 
5232  bool VisitBinaryOperator(const BinaryOperator *E) {
5233  switch (E->getOpcode()) {
5234  default:
5235  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
5236 
5237  case BO_PtrMemD:
5238  case BO_PtrMemI:
5239  return HandleMemberPointerAccess(this->Info, E, Result);
5240  }
5241  }
5242 
5243  bool VisitCastExpr(const CastExpr *E) {
5244  switch (E->getCastKind()) {
5245  default:
5246  return ExprEvaluatorBaseTy::VisitCastExpr(E);
5247 
5248  case CK_DerivedToBase:
5249  case CK_UncheckedDerivedToBase:
5250  if (!this->Visit(E->getSubExpr()))
5251  return false;
5252 
5253  // Now figure out the necessary offset to add to the base LV to get from
5254  // the derived class to the base class.
5255  return HandleLValueBasePath(this->Info, E, E->getSubExpr()->getType(),
5256  Result);
5257  }
5258  }
5259 };
5260 }
5261 
5262 //===----------------------------------------------------------------------===//
5263 // LValue Evaluation
5264 //
5265 // This is used for evaluating lvalues (in C and C++), xvalues (in C++11),
5266 // function designators (in C), decl references to void objects (in C), and
5267 // temporaries (if building with -Wno-address-of-temporary).
5268 //
5269 // LValue evaluation produces values comprising a base expression of one of the
5270 // following types:
5271 // - Declarations
5272 // * VarDecl
5273 // * FunctionDecl
5274 // - Literals
5275 // * CompoundLiteralExpr in C (and in global scope in C++)
5276 // * StringLiteral
5277 // * CXXTypeidExpr
5278 // * PredefinedExpr
5279 // * ObjCStringLiteralExpr
5280 // * ObjCEncodeExpr
5281 // * AddrLabelExpr
5282 // * BlockExpr
5283 // * CallExpr for a MakeStringConstant builtin
5284 // - Locals and temporaries
5285 // * MaterializeTemporaryExpr
5286 // * Any Expr, with a CallIndex indicating the function in which the temporary
5287 // was evaluated, for cases where the MaterializeTemporaryExpr is missing
5288 // from the AST (FIXME).
5289 // * A MaterializeTemporaryExpr that has static storage duration, with no
5290 // CallIndex, for a lifetime-extended temporary.
5291 // plus an offset in bytes.
5292 //===----------------------------------------------------------------------===//
5293 namespace {
5294 class LValueExprEvaluator
5295  : public LValueExprEvaluatorBase<LValueExprEvaluator> {
5296 public:
5297  LValueExprEvaluator(EvalInfo &Info, LValue &Result, bool InvalidBaseOK) :
5298  LValueExprEvaluatorBaseTy(Info, Result, InvalidBaseOK) {}
5299 
5300  bool VisitVarDecl(const Expr *E, const VarDecl *VD);
5301  bool VisitUnaryPreIncDec(const UnaryOperator *UO);
5302 
5303  bool VisitDeclRefExpr(const DeclRefExpr *E);
5304  bool VisitPredefinedExpr(const PredefinedExpr *E) { return Success(E); }
5305  bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
5306  bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
5307  bool VisitMemberExpr(const MemberExpr *E);
5308  bool VisitStringLiteral(const StringLiteral *E) { return Success(E); }
5309  bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { return Success(E); }
5310  bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
5311  bool VisitCXXUuidofExpr(const CXXUuidofExpr *E);
5312  bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
5313  bool VisitUnaryDeref(const UnaryOperator *E);
5314  bool VisitUnaryReal(const UnaryOperator *E);
5315  bool VisitUnaryImag(const UnaryOperator *E);
5316  bool VisitUnaryPreInc(const UnaryOperator *UO) {
5317  return VisitUnaryPreIncDec(UO);
5318  }
5319  bool VisitUnaryPreDec(const UnaryOperator *UO) {
5320  return VisitUnaryPreIncDec(UO);
5321  }
5322  bool VisitBinAssign(const BinaryOperator *BO);
5323  bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO);
5324 
5325  bool VisitCastExpr(const CastExpr *E) {
5326  switch (E->getCastKind()) {
5327  default:
5328  return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
5329 
5330  case CK_LValueBitCast:
5331  this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5332  if (!Visit(E->getSubExpr()))
5333  return false;
5334  Result.Designator.setInvalid();
5335  return true;
5336 
5337  case CK_BaseToDerived:
5338  if (!Visit(E->getSubExpr()))
5339  return false;
5340  return HandleBaseToDerivedCast(Info, E, Result);
5341  }
5342  }
5343 };
5344 } // end anonymous namespace
5345 
5346 /// Evaluate an expression as an lvalue. This can be legitimately called on
5347 /// expressions which are not glvalues, in three cases:
5348 /// * function designators in C, and
5349 /// * "extern void" objects
5350 /// * @selector() expressions in Objective-C
5351 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
5352  bool InvalidBaseOK) {
5353  assert(E->isGLValue() || E->getType()->isFunctionType() ||
5354  E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E));
5355  return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
5356 }
5357 
5358 bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) {
5359  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(E->getDecl()))
5360  return Success(FD);
5361  if (const VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
5362  return VisitVarDecl(E, VD);
5363  if (const BindingDecl *BD = dyn_cast<BindingDecl>(E->getDecl()))
5364  return Visit(BD->getBinding());
5365  return Error(E);
5366 }
5367 
5368 
5369 bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
5370 
5371  // If we are within a lambda's call operator, check whether the 'VD' referred
5372  // to within 'E' actually represents a lambda-capture that maps to a
5373  // data-member/field within the closure object, and if so, evaluate to the
5374  // field or what the field refers to.
5375  if (Info.CurrentCall && isLambdaCallOperator(Info.CurrentCall->Callee) &&
5376  isa<DeclRefExpr>(E) &&
5377  cast<DeclRefExpr>(E)->refersToEnclosingVariableOrCapture()) {
5378  // We don't always have a complete capture-map when checking or inferring if
5379  // the function call operator meets the requirements of a constexpr function
5380  // - but we don't need to evaluate the captures to determine constexprness
5381  // (dcl.constexpr C++17).
5382  if (Info.checkingPotentialConstantExpression())
5383  return false;
5384 
5385  if (auto *FD = Info.CurrentCall->LambdaCaptureFields.lookup(VD)) {
5386  // Start with 'Result' referring to the complete closure object...
5387  Result = *Info.CurrentCall->This;
5388  // ... then update it to refer to the field of the closure object
5389  // that represents the capture.
5390  if (!HandleLValueMember(Info, E, Result, FD))
5391  return false;
5392  // And if the field is of reference type, update 'Result' to refer to what
5393  // the field refers to.
5394  if (FD->getType()->isReferenceType()) {
5395  APValue RVal;
5396  if (!handleLValueToRValueConversion(Info, E, FD->getType(), Result,
5397  RVal))
5398  return false;
5399  Result.setFrom(Info.Ctx, RVal);
5400  }
5401  return true;
5402  }
5403  }
5404  CallStackFrame *Frame = nullptr;
5405  if (VD->hasLocalStorage() && Info.CurrentCall->Index > 1) {
5406  // Only if a local variable was declared in the function currently being
5407  // evaluated, do we expect to be able to find its value in the current
5408  // frame. (Otherwise it was likely declared in an enclosing context and
5409  // could either have a valid evaluatable value (for e.g. a constexpr
5410  // variable) or be ill-formed (and trigger an appropriate evaluation
5411  // diagnostic)).
5412  if (Info.CurrentCall->Callee &&
5413  Info.CurrentCall->Callee->Equals(VD->getDeclContext())) {
5414  Frame = Info.CurrentCall;
5415  }
5416  }
5417 
5418  if (!VD->getType()->isReferenceType()) {
5419  if (Frame) {
5420  Result.set({VD, Frame->Index,
5421  Info.CurrentCall->getCurrentTemporaryVersion(VD)});
5422  return true;
5423  }
5424  return Success(VD);
5425  }
5426 
5427  APValue *V;
5428  if (!evaluateVarDeclInit(Info, E, VD, Frame, V, nullptr))
5429  return false;
5430  if (V->isUninit()) {
5431  if (!Info.checkingPotentialConstantExpression())
5432  Info.FFDiag(E, diag::note_constexpr_use_uninit_reference);
5433  return false;
5434  }
5435  return Success(*V, E);
5436 }
5437 
5438 bool LValueExprEvaluator::VisitMaterializeTemporaryExpr(
5439  const MaterializeTemporaryExpr *E) {
5440  // Walk through the expression to find the materialized temporary itself.
5441  SmallVector<const Expr *, 2> CommaLHSs;
5443  const Expr *Inner = E->GetTemporaryExpr()->
5444  skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
5445 
5446  // If we passed any comma operators, evaluate their LHSs.
5447  for (unsigned I = 0, N = CommaLHSs.size(); I != N; ++I)
5448  if (!EvaluateIgnoredValue(Info, CommaLHSs[I]))
5449  return false;
5450 
5451  // A materialized temporary with static storage duration can appear within the
5452  // result of a constant expression evaluation, so we need to preserve its
5453  // value for use outside this evaluation.
5454  APValue *Value;
5455  if (E->getStorageDuration() == SD_Static) {
5456  Value = Info.Ctx.getMaterializedTemporaryValue(E, true);
5457  *Value = APValue();
5458  Result.set(E);
5459  } else {
5461  *Info.CurrentCall);
5462  }
5463 
5464  QualType Type = Inner->getType();
5465 
5466  // Materialize the temporary itself.
5467  if (!EvaluateInPlace(*Value, Info, Result, Inner) ||
5468  (E->getStorageDuration() == SD_Static &&
5469  !CheckConstantExpression(Info, E->getExprLoc(), Type, *Value))) {
5470  *Value = APValue();
5471  return false;
5472  }
5473 
5474  // Adjust our lvalue to refer to the desired subobject.
5475  for (unsigned I = Adjustments.size(); I != 0; /**/) {
5476  --I;
5477  switch (Adjustments[I].Kind) {
5479  if (!HandleLValueBasePath(Info, Adjustments[I].DerivedToBase.BasePath,
5480  Type, Result))
5481  return false;
5482  Type = Adjustments[I].DerivedToBase.BasePath->getType();
5483  break;
5484 
5486  if (!HandleLValueMember(Info, E, Result, Adjustments[I].Field))
5487  return false;
5488  Type = Adjustments[I].Field->getType();
5489  break;
5490 
5492  if (!HandleMemberPointerAccess(this->Info, Type, Result,
5493  Adjustments[I].Ptr.RHS))
5494  return false;
5495  Type = Adjustments[I].Ptr.MPT->getPointeeType();
5496  break;
5497  }
5498  }
5499 
5500  return true;
5501 }
5502 
5503 bool
5504 LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
5505  assert((!Info.getLangOpts().CPlusPlus || E->isFileScope()) &&
5506  "lvalue compound literal in c++?");
5507  // Defer visiting the literal until the lvalue-to-rvalue conversion. We can
5508  // only see this when folding in C, so there's no standard to follow here.
5509  return Success(E);
5510 }
5511 
5512 bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
5513  if (!E->isPotentiallyEvaluated())
5514  return Success(E);
5515 
5516  Info.FFDiag(E, diag::note_constexpr_typeid_polymorphic)
5517  << E->getExprOperand()->getType()
5518  << E->getExprOperand()->getSourceRange();
5519  return false;
5520 }
5521 
5522 bool LValueExprEvaluator::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
5523  return Success(E);
5524 }
5525 
5526 bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
5527  // Handle static data members.
5528  if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) {
5529  VisitIgnoredBaseExpression(E->getBase());
5530  return VisitVarDecl(E, VD);
5531  }
5532 
5533  // Handle static member functions.
5534  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) {
5535  if (MD->isStatic()) {
5536  VisitIgnoredBaseExpression(E->getBase());
5537  return Success(MD);
5538  }
5539  }
5540 
5541  // Handle non-static data members.
5542  return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
5543 }
5544 
5545 bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
5546  // FIXME: Deal with vectors as array subscript bases.
5547  if (E->getBase()->getType()->isVectorType())
5548  return Error(E);
5549 
5550  bool Success = true;
5551  if (!evaluatePointer(E->getBase(), Result)) {
5552  if (!Info.noteFailure())
5553  return false;
5554  Success = false;
5555  }
5556 
5557  APSInt Index;
5558  if (!EvaluateInteger(E->getIdx(), Index, Info))
5559  return false;
5560 
5561  return Success &&
5562  HandleLValueArrayAdjustment(Info, E, Result, E->getType(), Index);
5563 }
5564 
5565 bool LValueExprEvaluator::VisitUnaryDeref(const UnaryOperator *E) {
5566  return evaluatePointer(E->getSubExpr(), Result);
5567 }
5568 
5569 bool LValueExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
5570  if (!Visit(E->getSubExpr()))
5571  return false;
5572  // __real is a no-op on scalar lvalues.
5573  if (E->getSubExpr()->getType()->isAnyComplexType())
5574  HandleLValueComplexElement(Info, E, Result, E->getType(), false);
5575  return true;
5576 }
5577 
5578 bool LValueExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
5579  assert(E->getSubExpr()->getType()->isAnyComplexType() &&
5580  "lvalue __imag__ on scalar?");
5581  if (!Visit(E->getSubExpr()))
5582  return false;
5583  HandleLValueComplexElement(Info, E, Result, E->getType(), true);
5584  return true;
5585 }
5586 
5587 bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) {
5588  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5589  return Error(UO);
5590 
5591  if (!this->Visit(UO->getSubExpr()))
5592  return false;
5593 
5594  return handleIncDec(
5595  this->Info, UO, Result, UO->getSubExpr()->getType(),
5596  UO->isIncrementOp(), nullptr);
5597 }
5598 
5599 bool LValueExprEvaluator::VisitCompoundAssignOperator(
5600  const CompoundAssignOperator *CAO) {
5601  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5602  return Error(CAO);
5603 
5604  APValue RHS;
5605 
5606  // The overall lvalue result is the result of evaluating the LHS.
5607  if (!this->Visit(CAO->getLHS())) {
5608  if (Info.noteFailure())
5609  Evaluate(RHS, this->Info, CAO->getRHS());
5610  return false;
5611  }
5612 
5613  if (!Evaluate(RHS, this->Info, CAO->getRHS()))
5614  return false;
5615 
5616  return handleCompoundAssignment(
5617  this->Info, CAO,
5618  Result, CAO->getLHS()->getType(), CAO->getComputationLHSType(),
5619  CAO->getOpForCompoundAssignment(CAO->getOpcode()), RHS);
5620 }
5621 
5622 bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) {
5623  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5624  return Error(E);
5625 
5626  APValue NewVal;
5627 
5628  if (!this->Visit(E->getLHS())) {
5629  if (Info.noteFailure())
5630  Evaluate(NewVal, this->Info, E->getRHS());
5631  return false;
5632  }
5633 
5634  if (!Evaluate(NewVal, this->Info, E->getRHS()))
5635  return false;
5636 
5637  return handleAssignment(this->Info, E, Result, E->getLHS()->getType(),
5638  NewVal);
5639 }
5640 
5641 //===----------------------------------------------------------------------===//
5642 // Pointer Evaluation
5643 //===----------------------------------------------------------------------===//
5644 
5645 /// Attempts to compute the number of bytes available at the pointer
5646 /// returned by a function with the alloc_size attribute. Returns true if we
5647 /// were successful. Places an unsigned number into `Result`.
5648 ///
5649 /// This expects the given CallExpr to be a call to a function with an
5650 /// alloc_size attribute.
5652  const CallExpr *Call,
5653  llvm::APInt &Result) {
5654  const AllocSizeAttr *AllocSize = getAllocSizeAttr(Call);
5655 
5656  assert(AllocSize && AllocSize->getElemSizeParam().isValid());
5657  unsigned SizeArgNo = AllocSize->getElemSizeParam().getASTIndex();
5658  unsigned BitsInSizeT = Ctx.getTypeSize(Ctx.getSizeType());
5659  if (Call->getNumArgs() <= SizeArgNo)
5660  return false;
5661 
5662  auto EvaluateAsSizeT = [&](const Expr *E, APSInt &Into) {
5664  if (!E->EvaluateAsInt(ExprResult, Ctx, Expr::SE_AllowSideEffects))
5665  return false;
5666  Into = ExprResult.Val.getInt();
5667  if (Into.isNegative() || !Into.isIntN(BitsInSizeT))
5668  return false;
5669  Into = Into.zextOrSelf(BitsInSizeT);
5670  return true;
5671  };
5672 
5673  APSInt SizeOfElem;
5674  if (!EvaluateAsSizeT(Call->getArg(SizeArgNo), SizeOfElem))
5675  return false;
5676 
5677  if (!AllocSize->getNumElemsParam().isValid()) {
5678  Result = std::move(SizeOfElem);
5679  return true;
5680  }
5681 
5682  APSInt NumberOfElems;
5683  unsigned NumArgNo = AllocSize->getNumElemsParam().getASTIndex();
5684  if (!EvaluateAsSizeT(Call->getArg(NumArgNo), NumberOfElems))
5685  return false;
5686 
5687  bool Overflow;
5688  llvm::APInt BytesAvailable = SizeOfElem.umul_ov(NumberOfElems, Overflow);
5689  if (Overflow)
5690  return false;
5691 
5692  Result = std::move(BytesAvailable);
5693  return true;
5694 }
5695 
5696 /// Convenience function. LVal's base must be a call to an alloc_size
5697 /// function.
5699  const LValue &LVal,
5700  llvm::APInt &Result) {
5701  assert(isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
5702  "Can't get the size of a non alloc_size function");
5703  const auto *Base = LVal.getLValueBase().get<const Expr *>();
5704  const CallExpr *CE = tryUnwrapAllocSizeCall(Base);
5705  return getBytesReturnedByAllocSizeCall(Ctx, CE, Result);
5706 }
5707 
5708 /// Attempts to evaluate the given LValueBase as the result of a call to
5709 /// a function with the alloc_size attribute. If it was possible to do so, this
5710 /// function will return true, make Result's Base point to said function call,
5711 /// and mark Result's Base as invalid.
5712 static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base,
5713  LValue &Result) {
5714  if (Base.isNull())
5715  return false;
5716 
5717  // Because we do no form of static analysis, we only support const variables.
5718  //
5719  // Additionally, we can't support parameters, nor can we support static
5720  // variables (in the latter case, use-before-assign isn't UB; in the former,
5721  // we have no clue what they'll be assigned to).
5722  const auto *VD =
5723  dyn_cast_or_null<VarDecl>(Base.dyn_cast<const ValueDecl *>());
5724  if (!VD || !VD->isLocalVarDecl() || !VD->getType().isConstQualified())
5725  return false;
5726 
5727  const Expr *Init = VD->getAnyInitializer();
5728  if (!Init)
5729  return false;
5730 
5731  const Expr *E = Init->IgnoreParens();
5732  if (!tryUnwrapAllocSizeCall(E))
5733  return false;
5734 
5735  // Store E instead of E unwrapped so that the type of the LValue's base is
5736  // what the user wanted.
5737  Result.setInvalid(E);
5738 
5739  QualType Pointee = E->getType()->castAs<PointerType>()->getPointeeType();
5740  Result.addUnsizedArray(Info, E, Pointee);
5741  return true;
5742 }
5743 
5744 namespace {
5745 class PointerExprEvaluator
5746  : public ExprEvaluatorBase<PointerExprEvaluator> {
5747  LValue &Result;
5748  bool InvalidBaseOK;
5749 
5750  bool Success(const Expr *E) {
5751  Result.set(E);
5752  return true;
5753  }
5754 
5755  bool evaluateLValue(const Expr *E, LValue &Result) {
5756  return EvaluateLValue(E, Result, Info, InvalidBaseOK);
5757  }
5758 
5759  bool evaluatePointer(const Expr *E, LValue &Result) {
5760  return EvaluatePointer(E, Result, Info, InvalidBaseOK);
5761  }
5762 
5763  bool visitNonBuiltinCallExpr(const CallExpr *E);
5764 public:
5765 
5766  PointerExprEvaluator(EvalInfo &info, LValue &Result, bool InvalidBaseOK)
5767  : ExprEvaluatorBaseTy(info), Result(Result),
5768  InvalidBaseOK(InvalidBaseOK) {}
5769 
5770  bool Success(const APValue &V, const Expr *E) {
5771  Result.setFrom(Info.Ctx, V);
5772  return true;
5773  }
5774  bool ZeroInitialization(const Expr *E) {
5775  auto TargetVal = Info.Ctx.getTargetNullPointerValue(E->getType());
5776  Result.setNull(E->getType(), TargetVal);
5777  return true;
5778  }
5779 
5780  bool VisitBinaryOperator(const BinaryOperator *E);
5781  bool VisitCastExpr(const CastExpr* E);
5782  bool VisitUnaryAddrOf(const UnaryOperator *E);
5783  bool VisitObjCStringLiteral(const ObjCStringLiteral *E)
5784  { return Success(E); }
5785  bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
5786  if (Info.noteFailure())
5787  EvaluateIgnoredValue(Info, E->getSubExpr());
5788  return Error(E);
5789  }
5790  bool VisitAddrLabelExpr(const AddrLabelExpr *E)
5791  { return Success(E); }
5792  bool VisitCallExpr(const CallExpr *E);
5793  bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
5794  bool VisitBlockExpr(const BlockExpr *E) {
5795  if (!E->getBlockDecl()->hasCaptures())
5796  return Success(E);
5797  return Error(E);
5798  }
5799  bool VisitCXXThisExpr(const CXXThisExpr *E) {
5800  // Can't look at 'this' when checking a potential constant expression.
5801  if (Info.checkingPotentialConstantExpression())
5802  return false;
5803  if (!Info.CurrentCall->This) {
5804  if (Info.getLangOpts().CPlusPlus11)
5805  Info.FFDiag(E, diag::note_constexpr_this) << E->isImplicit();
5806  else
5807  Info.FFDiag(E);
5808  return false;
5809  }
5810  Result = *Info.CurrentCall->This;
5811  // If we are inside a lambda's call operator, the 'this' expression refers
5812  // to the enclosing '*this' object (either by value or reference) which is
5813  // either copied into the closure object's field that represents the '*this'
5814  // or refers to '*this'.
5815  if (isLambdaCallOperator(Info.CurrentCall->Callee)) {
5816  // Update 'Result' to refer to the data member/field of the closure object
5817  // that represents the '*this' capture.
5818  if (!HandleLValueMember(Info, E, Result,
5819  Info.CurrentCall->LambdaThisCaptureField))
5820  return false;
5821  // If we captured '*this' by reference, replace the field with its referent.
5822  if (Info.CurrentCall->LambdaThisCaptureField->getType()
5823  ->isPointerType()) {
5824  APValue RVal;
5825  if (!handleLValueToRValueConversion(Info, E, E->getType(), Result,
5826  RVal))
5827  return false;
5828 
5829  Result.setFrom(Info.Ctx, RVal);
5830  }
5831  }
5832  return true;
5833  }
5834 
5835  // FIXME: Missing: @protocol, @selector
5836 };
5837 } // end anonymous namespace
5838 
5839 static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
5840  bool InvalidBaseOK) {
5841  assert(E->isRValue() && E->getType()->hasPointerRepresentation());
5842  return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
5843 }
5844 
5845 bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
5846  if (E->getOpcode() != BO_Add &&
5847  E->getOpcode() != BO_Sub)
5848  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
5849 
5850  const Expr *PExp = E->getLHS();
5851  const Expr *IExp = E->getRHS();
5852  if (IExp->getType()->isPointerType())
5853  std::swap(PExp, IExp);
5854 
5855  bool EvalPtrOK = evaluatePointer(PExp, Result);
5856  if (!EvalPtrOK && !Info.noteFailure())
5857  return false;
5858 
5859  llvm::APSInt Offset;
5860  if (!EvaluateInteger(IExp, Offset, Info) || !EvalPtrOK)
5861  return false;
5862 
5863  if (E->getOpcode() == BO_Sub)
5864  negateAsSigned(Offset);
5865 
5866  QualType Pointee = PExp->getType()->castAs<PointerType>()->getPointeeType();
5867  return HandleLValueArrayAdjustment(Info, E, Result, Pointee, Offset);
5868 }
5869 
5870 bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
5871  return evaluateLValue(E->getSubExpr(), Result);
5872 }
5873 
5874 bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
5875  const Expr *SubExpr = E->getSubExpr();
5876 
5877  switch (E->getCastKind()) {
5878  default:
5879  break;
5880 
5881  case CK_BitCast:
5882  case CK_CPointerToObjCPointerCast:
5883  case CK_BlockPointerToObjCPointerCast:
5884  case CK_AnyPointerToBlockPointerCast:
5885  case CK_AddressSpaceConversion:
5886  if (!Visit(SubExpr))
5887  return false;
5888  // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are
5889  // permitted in constant expressions in C++11. Bitcasts from cv void* are
5890  // also static_casts, but we disallow them as a resolution to DR1312.
5891  if (!E->getType()->isVoidPointerType()) {
5892  Result.Designator.setInvalid();
5893  if (SubExpr->getType()->isVoidPointerType())
5894  CCEDiag(E, diag::note_constexpr_invalid_cast)
5895  << 3 << SubExpr->getType();
5896  else
5897  CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5898  }
5899  if (E->getCastKind() == CK_AddressSpaceConversion && Result.IsNullPtr)
5900  ZeroInitialization(E);
5901  return true;
5902 
5903  case CK_DerivedToBase:
5904  case CK_UncheckedDerivedToBase:
5905  if (!evaluatePointer(E->getSubExpr(), Result))
5906  return false;
5907  if (!Result.Base && Result.Offset.isZero())
5908  return true;
5909 
5910  // Now figure out the necessary offset to add to the base LV to get from
5911  // the derived class to the base class.
5912  return HandleLValueBasePath(Info, E, E->getSubExpr()->getType()->
5913  castAs<PointerType>()->getPointeeType(),
5914  Result);
5915 
5916  case CK_BaseToDerived:
5917  if (!Visit(E->getSubExpr()))
5918  return false;
5919  if (!Result.Base && Result.Offset.isZero())
5920  return true;
5921  return HandleBaseToDerivedCast(Info, E, Result);
5922 
5923  case CK_NullToPointer:
5924  VisitIgnoredValue(E->getSubExpr());
5925  return ZeroInitialization(E);
5926 
5927  case CK_IntegralToPointer: {
5928  CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5929 
5930  APValue Value;
5931  if (!EvaluateIntegerOrLValue(SubExpr, Value, Info))
5932  break;
5933 
5934  if (Value.isInt()) {
5935  unsigned Size = Info.Ctx.getTypeSize(E->getType());
5936  uint64_t N = Value.getInt().extOrTrunc(Size).getZExtValue();
5937  Result.Base = (Expr*)nullptr;
5938  Result.InvalidBase = false;
5939  Result.Offset = CharUnits::fromQuantity(N);
5940  Result.Designator.setInvalid();
5941  Result.IsNullPtr = false;
5942  return true;
5943  } else {
5944  // Cast is of an lvalue, no need to change value.
5945  Result.setFrom(Info.Ctx, Value);
5946  return true;
5947  }
5948  }
5949 
5950  case CK_ArrayToPointerDecay: {
5951  if (SubExpr->isGLValue()) {
5952  if (!evaluateLValue(SubExpr, Result))
5953  return false;
5954  } else {
5955  APValue &Value = createTemporary(SubExpr, false, Result,
5956  *Info.CurrentCall);
5957  if (!EvaluateInPlace(Value, Info, Result, SubExpr))
5958  return false;
5959  }
5960  // The result is a pointer to the first element of the array.
5961  auto *AT = Info.Ctx.getAsArrayType(SubExpr->getType());
5962  if (auto *CAT = dyn_cast<ConstantArrayType>(AT))
5963  Result.addArray(Info, E, CAT);
5964  else
5965  Result.addUnsizedArray(Info, E, AT->getElementType());
5966  return true;
5967  }
5968 
5969  case CK_FunctionToPointerDecay:
5970  return evaluateLValue(SubExpr, Result);
5971 
5972  case CK_LValueToRValue: {
5973  LValue LVal;
5974  if (!evaluateLValue(E->getSubExpr(), LVal))
5975  return false;
5976 
5977  APValue RVal;
5978  // Note, we use the subexpression's type in order to retain cv-qualifiers.
5979  if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
5980  LVal, RVal))
5981  return InvalidBaseOK &&
5982  evaluateLValueAsAllocSize(Info, LVal.Base, Result);
5983  return Success(RVal, E);
5984  }
5985  }
5986 
5987  return ExprEvaluatorBaseTy::VisitCastExpr(E);
5988 }
5989 
5990 static CharUnits GetAlignOfType(EvalInfo &Info, QualType T,
5991  UnaryExprOrTypeTrait ExprKind) {
5992  // C++ [expr.alignof]p3:
5993  // When alignof is applied to a reference type, the result is the
5994  // alignment of the referenced type.
5995  if (const ReferenceType *Ref = T->getAs<ReferenceType>())
5996  T = Ref->getPointeeType();
5997 
5998  if (T.getQualifiers().hasUnaligned())
5999  return CharUnits::One();
6000 
6001  const bool AlignOfReturnsPreferred =
6002  Info.Ctx.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver7;
6003 
6004  // __alignof is defined to return the preferred alignment.
6005  // Before 8, clang returned the preferred alignment for alignof and _Alignof
6006  // as well.
6007  if (ExprKind == UETT_PreferredAlignOf || AlignOfReturnsPreferred)
6008  return Info.Ctx.toCharUnitsFromBits(
6009  Info.Ctx.getPreferredTypeAlign(T.getTypePtr()));
6010  // alignof and _Alignof are defined to return the ABI alignment.
6011  else if (ExprKind == UETT_AlignOf)
6012  return Info.Ctx.getTypeAlignInChars(T.getTypePtr());
6013  else
6014  llvm_unreachable("GetAlignOfType on a non-alignment ExprKind");
6015 }
6016 
6017 static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E,
6018  UnaryExprOrTypeTrait ExprKind) {
6019  E = E->IgnoreParens();
6020 
6021  // The kinds of expressions that we have special-case logic here for
6022  // should be kept up to date with the special checks for those
6023  // expressions in Sema.
6024 
6025  // alignof decl is always accepted, even if it doesn't make sense: we default
6026  // to 1 in those cases.
6027  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
6028  return Info.Ctx.getDeclAlign(DRE->getDecl(),
6029  /*RefAsPointee*/true);
6030 
6031  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
6032  return Info.Ctx.getDeclAlign(ME->getMemberDecl(),
6033  /*RefAsPointee*/true);
6034 
6035  return GetAlignOfType(Info, E->getType(), ExprKind);
6036 }
6037 
6038 // To be clear: this happily visits unsupported builtins. Better name welcomed.
6039 bool PointerExprEvaluator::visitNonBuiltinCallExpr(const CallExpr *E) {
6040  if (ExprEvaluatorBaseTy::VisitCallExpr(E))
6041  return true;
6042 
6043  if (!(InvalidBaseOK && getAllocSizeAttr(E)))
6044  return false;
6045 
6046  Result.setInvalid(E);
6047  QualType PointeeTy = E->getType()->castAs<PointerType>()->getPointeeType();
6048  Result.addUnsizedArray(Info, E, PointeeTy);
6049  return true;
6050 }
6051 
6052 bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) {
6053  if (IsStringLiteralCall(E))
6054  return Success(E);
6055 
6056  if (unsigned BuiltinOp = E->getBuiltinCallee())
6057  return VisitBuiltinCallExpr(E, BuiltinOp);
6058 
6059  return visitNonBuiltinCallExpr(E);
6060 }
6061 
6062 bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
6063  unsigned BuiltinOp) {
6064  switch (BuiltinOp) {
6065  case Builtin::BI__builtin_addressof:
6066  return evaluateLValue(E->getArg(0), Result);
6067  case Builtin::BI__builtin_assume_aligned: {
6068  // We need to be very careful here because: if the pointer does not have the
6069  // asserted alignment, then the behavior is undefined, and undefined
6070  // behavior is non-constant.
6071  if (!evaluatePointer(E->getArg(0), Result))
6072  return false;
6073 
6074  LValue OffsetResult(Result);
6075  APSInt Alignment;
6076  if (!EvaluateInteger(E->getArg(1), Alignment, Info))
6077  return false;
6078  CharUnits Align = CharUnits::fromQuantity(Alignment.getZExtValue());
6079 
6080  if (E->getNumArgs() > 2) {
6081  APSInt Offset;
6082  if (!EvaluateInteger(E->getArg(2), Offset, Info))
6083  return false;
6084 
6085  int64_t AdditionalOffset = -Offset.getZExtValue();
6086  OffsetResult.Offset += CharUnits::fromQuantity(AdditionalOffset);
6087  }
6088 
6089  // If there is a base object, then it must have the correct alignment.
6090  if (OffsetResult.Base) {
6091  CharUnits BaseAlignment;
6092  if (const ValueDecl *VD =
6093  OffsetResult.Base.dyn_cast<const ValueDecl*>()) {
6094  BaseAlignment = Info.Ctx.getDeclAlign(VD);
6095  } else {
6096  BaseAlignment = GetAlignOfExpr(
6097  Info, OffsetResult.Base.get<const Expr *>(), UETT_AlignOf);
6098  }
6099 
6100  if (BaseAlignment < Align) {
6101  Result.Designator.setInvalid();
6102  // FIXME: Add support to Diagnostic for long / long long.
6103  CCEDiag(E->getArg(0),
6104  diag::note_constexpr_baa_insufficient_alignment) << 0
6105  << (unsigned)BaseAlignment.getQuantity()
6106  << (unsigned)Align.getQuantity();
6107  return false;
6108  }
6109  }
6110 
6111  // The offset must also have the correct alignment.
6112  if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) {
6113  Result.Designator.setInvalid();
6114 
6115  (OffsetResult.Base
6116  ? CCEDiag(E->getArg(0),
6117  diag::note_constexpr_baa_insufficient_alignment) << 1
6118  : CCEDiag(E->getArg(0),
6119  diag::note_constexpr_baa_value_insufficient_alignment))
6120  << (int)OffsetResult.Offset.getQuantity()
6121  << (unsigned)Align.getQuantity();
6122  return false;
6123  }
6124 
6125  return true;
6126  }
6127  case Builtin::BI__builtin_launder:
6128  return evaluatePointer(E->getArg(0), Result);
6129  case Builtin::BIstrchr:
6130  case Builtin::BIwcschr:
6131  case Builtin::BImemchr:
6132  case Builtin::BIwmemchr:
6133  if (Info.getLangOpts().CPlusPlus11)
6134  Info.CCEDiag(E, diag::note_constexpr_invalid_function)
6135  << /*isConstexpr*/0 << /*isConstructor*/0
6136  << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
6137  else
6138  Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
6139  LLVM_FALLTHROUGH;
6140  case Builtin::BI__builtin_strchr:
6141  case Builtin::BI__builtin_wcschr:
6142  case Builtin::BI__builtin_memchr:
6143  case Builtin::BI__builtin_char_memchr:
6144  case Builtin::BI__builtin_wmemchr: {
6145  if (!Visit(E->getArg(0)))
6146  return false;
6147  APSInt Desired;
6148  if (!EvaluateInteger(E->getArg(1), Desired, Info))
6149  return false;
6150  uint64_t MaxLength = uint64_t(-1);
6151  if (BuiltinOp != Builtin::BIstrchr &&
6152  BuiltinOp != Builtin::BIwcschr &&
6153  BuiltinOp != Builtin::BI__builtin_strchr &&
6154  BuiltinOp != Builtin::BI__builtin_wcschr) {
6155  APSInt N;
6156  if (!EvaluateInteger(E->getArg(2), N, Info))
6157  return false;
6158  MaxLength = N.getExtValue();
6159  }
6160  // We cannot find the value if there are no candidates to match against.
6161  if (MaxLength == 0u)
6162  return ZeroInitialization(E);
6163  if (!Result.checkNullPointerForFoldAccess(Info, E, AK_Read) ||
6164  Result.Designator.Invalid)
6165  return false;
6166  QualType CharTy = Result.Designator.getType(Info.Ctx);
6167  bool IsRawByte = BuiltinOp == Builtin::BImemchr ||
6168  BuiltinOp == Builtin::BI__builtin_memchr;
6169  assert(IsRawByte ||
6170  Info.Ctx.hasSameUnqualifiedType(
6171  CharTy, E->getArg(0)->getType()->getPointeeType()));
6172  // Pointers to const void may point to objects of incomplete type.
6173  if (IsRawByte && CharTy->isIncompleteType()) {
6174  Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy;
6175  return false;
6176  }
6177  // Give up on byte-oriented matching against multibyte elements.
6178  // FIXME: We can compare the bytes in the correct order.
6179  if (IsRawByte && Info.Ctx.getTypeSizeInChars(CharTy) != CharUnits::One())
6180  return false;
6181  // Figure out what value we're actually looking for (after converting to
6182  // the corresponding unsigned type if necessary).
6183  uint64_t DesiredVal;
6184  bool StopAtNull = false;
6185  switch (BuiltinOp) {
6186  case Builtin::BIstrchr:
6187  case Builtin::BI__builtin_strchr:
6188  // strchr compares directly to the passed integer, and therefore
6189  // always fails if given an int that is not a char.
6190  if (!APSInt::isSameValue(HandleIntToIntCast(Info, E, CharTy,
6191  E->getArg(1)->getType(),
6192  Desired),
6193  Desired))
6194  return ZeroInitialization(E);
6195  StopAtNull = true;
6196  LLVM_FALLTHROUGH;
6197  case Builtin::BImemchr:
6198  case Builtin::BI__builtin_memchr:
6199  case Builtin::BI__builtin_char_memchr:
6200  // memchr compares by converting both sides to unsigned char. That's also
6201  // correct for strchr if we get this far (to cope with plain char being
6202  // unsigned in the strchr case).
6203  DesiredVal = Desired.trunc(Info.Ctx.getCharWidth()).getZExtValue();
6204  break;
6205 
6206  case Builtin::BIwcschr:
6207  case Builtin::BI__builtin_wcschr:
6208  StopAtNull = true;
6209  LLVM_FALLTHROUGH;
6210  case Builtin::BIwmemchr:
6211  case Builtin::BI__builtin_wmemchr:
6212  // wcschr and wmemchr are given a wchar_t to look for. Just use it.
6213  DesiredVal = Desired.getZExtValue();
6214  break;
6215  }
6216 
6217  for (; MaxLength; --MaxLength) {
6218  APValue Char;
6219  if (!handleLValueToRValueConversion(Info, E, CharTy, Result, Char) ||
6220  !Char.isInt())
6221  return false;
6222  if (Char.getInt().getZExtValue() == DesiredVal)
6223  return true;
6224  if (StopAtNull && !Char.getInt())
6225  break;
6226  if (!HandleLValueArrayAdjustment(Info, E, Result, CharTy, 1))
6227  return false;
6228  }
6229  // Not found: return nullptr.
6230  return ZeroInitialization(E);
6231  }
6232 
6233  case Builtin::BImemcpy:
6234  case Builtin::BImemmove:
6235  case Builtin::BIwmemcpy:
6236  case Builtin::BIwmemmove:
6237  if (Info.getLangOpts().CPlusPlus11)
6238  Info.CCEDiag(E, diag::note_constexpr_invalid_function)
6239  << /*isConstexpr*/0 << /*isConstructor*/0
6240  << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
6241  else
6242  Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
6243  LLVM_FALLTHROUGH;
6244  case Builtin::BI__builtin_memcpy:
6245  case Builtin::BI__builtin_memmove:
6246  case Builtin::BI__builtin_wmemcpy:
6247  case Builtin::BI__builtin_wmemmove: {
6248  bool WChar = BuiltinOp == Builtin::BIwmemcpy ||
6249  BuiltinOp == Builtin::BIwmemmove ||
6250  BuiltinOp == Builtin::BI__builtin_wmemcpy ||
6251  BuiltinOp == Builtin::BI__builtin_wmemmove;
6252  bool Move = BuiltinOp == Builtin::BImemmove ||
6253  BuiltinOp == Builtin::BIwmemmove ||
6254  BuiltinOp == Builtin::BI__builtin_memmove ||
6255  BuiltinOp == Builtin::BI__builtin_wmemmove;
6256 
6257  // The result of mem* is the first argument.
6258  if (!Visit(E->getArg(0)))
6259  return false;
6260  LValue Dest = Result;
6261 
6262  LValue Src;
6263  if (!EvaluatePointer(E->getArg(1), Src, Info))
6264  return false;
6265 
6266  APSInt N;
6267  if (!EvaluateInteger(E->getArg(2), N, Info))
6268  return false;
6269  assert(!N.isSigned() && "memcpy and friends take an unsigned size");
6270 
6271  // If the size is zero, we treat this as always being a valid no-op.
6272  // (Even if one of the src and dest pointers is null.)
6273  if (!N)
6274  return true;
6275 
6276  // Otherwise, if either of the operands is null, we can't proceed. Don't
6277  // try to determine the type of the copied objects, because there aren't
6278  // any.
6279  if (!Src.Base || !Dest.Base) {
6280  APValue Val;
6281  (!Src.Base ? Src : Dest).moveInto(Val);
6282  Info.FFDiag(E, diag::note_constexpr_memcpy_null)
6283  << Move << WChar << !!Src.Base
6284  << Val.getAsString(Info.Ctx, E->getArg(0)->getType());
6285  return false;
6286  }
6287  if (Src.Designator.Invalid || Dest.Designator.Invalid)
6288  return false;
6289 
6290  // We require that Src and Dest are both pointers to arrays of
6291  // trivially-copyable type. (For the wide version, the designator will be
6292  // invalid if the designated object is not a wchar_t.)
6293  QualType T = Dest.Designator.getType(Info.Ctx);
6294  QualType SrcT = Src.Designator.getType(Info.Ctx);
6295  if (!Info.Ctx.hasSameUnqualifiedType(T, SrcT)) {
6296  Info.FFDiag(E, diag::note_constexpr_memcpy_type_pun) << Move << SrcT << T;
6297  return false;
6298  }
6299  if (T->isIncompleteType()) {
6300  Info.FFDiag(E, diag::note_constexpr_memcpy_incomplete_type) << Move << T;
6301  return false;
6302  }
6303  if (!T.isTriviallyCopyableType(Info.Ctx)) {
6304  Info.FFDiag(E, diag::note_constexpr_memcpy_nontrivial) << Move << T;
6305  return false;
6306  }
6307 
6308  // Figure out how many T's we're copying.
6309  uint64_t TSize = Info.Ctx.getTypeSizeInChars(T).getQuantity();
6310  if (!WChar) {
6311  uint64_t Remainder;
6312  llvm::APInt OrigN = N;
6313  llvm::APInt::udivrem(OrigN, TSize, N, Remainder);
6314  if (Remainder) {
6315  Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported)
6316  << Move << WChar << 0 << T << OrigN.toString(10, /*Signed*/false)
6317  << (unsigned)TSize;
6318  return false;
6319  }
6320  }
6321 
6322  // Check that the copying will remain within the arrays, just so that we
6323  // can give a more meaningful diagnostic. This implicitly also checks that
6324  // N fits into 64 bits.
6325  uint64_t RemainingSrcSize = Src.Designator.validIndexAdjustments().second;
6326  uint64_t RemainingDestSize = Dest.Designator.validIndexAdjustments().second;
6327  if (N.ugt(RemainingSrcSize) || N.ugt(RemainingDestSize)) {
6328  Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported)
6329  << Move << WChar << (N.ugt(RemainingSrcSize) ? 1 : 2) << T
6330  << N.toString(10, /*Signed*/false);
6331  return false;
6332  }
6333  uint64_t NElems = N.getZExtValue();
6334  uint64_t NBytes = NElems * TSize;
6335 
6336  // Check for overlap.
6337  int Direction = 1;
6338  if (HasSameBase(Src, Dest)) {
6339  uint64_t SrcOffset = Src.getLValueOffset().getQuantity();
6340  uint64_t DestOffset = Dest.getLValueOffset().getQuantity();
6341  if (DestOffset >= SrcOffset && DestOffset - SrcOffset < NBytes) {
6342  // Dest is inside the source region.
6343  if (!Move) {
6344  Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar;
6345  return false;
6346  }
6347  // For memmove and friends, copy backwards.
6348  if (!HandleLValueArrayAdjustment(Info, E, Src, T, NElems - 1) ||
6349  !HandleLValueArrayAdjustment(Info, E, Dest, T, NElems - 1))
6350  return false;
6351  Direction = -1;
6352  } else if (!Move && SrcOffset >= DestOffset &&
6353  SrcOffset - DestOffset < NBytes) {
6354  // Src is inside the destination region for memcpy: invalid.
6355  Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar;
6356  return false;
6357  }
6358  }
6359 
6360  while (true) {
6361  APValue Val;
6362  if (!handleLValueToRValueConversion(Info, E, T, Src, Val) ||
6363  !handleAssignment(Info, E, Dest, T, Val))
6364  return false;
6365  // Do not iterate past the last element; if we're copying backwards, that
6366  // might take us off the start of the array.
6367  if (--NElems == 0)
6368  return true;
6369  if (!HandleLValueArrayAdjustment(Info, E, Src, T, Direction) ||
6370  !HandleLValueArrayAdjustment(Info, E, Dest, T, Direction))
6371  return false;
6372  }
6373  }
6374 
6375  default:
6376  return visitNonBuiltinCallExpr(E);
6377  }
6378 }
6379 
6380 //===----------------------------------------------------------------------===//
6381 // Member Pointer Evaluation
6382 //===----------------------------------------------------------------------===//
6383 
6384 namespace {
6385 class MemberPointerExprEvaluator
6386  : public ExprEvaluatorBase<MemberPointerExprEvaluator> {
6387  MemberPtr &Result;
6388 
6389  bool Success(const ValueDecl *D) {
6390  Result = MemberPtr(D);
6391  return true;
6392  }
6393 public:
6394 
6395  MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result)
6396  : ExprEvaluatorBaseTy(Info), Result(Result) {}
6397 
6398  bool Success(const APValue &V, const Expr *E) {
6399  Result.setFrom(V);
6400  return true;
6401  }
6402  bool ZeroInitialization(const Expr *E) {
6403  return Success((const ValueDecl*)nullptr);
6404  }
6405 
6406  bool VisitCastExpr(const CastExpr *E);
6407  bool VisitUnaryAddrOf(const UnaryOperator *E);
6408 };
6409 } // end anonymous namespace
6410 
6411 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
6412  EvalInfo &Info) {
6413  assert(E->isRValue() && E->getType()->isMemberPointerType());
6414  return MemberPointerExprEvaluator(Info, Result).Visit(E);
6415 }
6416 
6417 bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
6418  switch (E->getCastKind()) {
6419  default:
6420  return ExprEvaluatorBaseTy::VisitCastExpr(E);
6421 
6422  case CK_NullToMemberPointer:
6423  VisitIgnoredValue(E->getSubExpr());
6424  return ZeroInitialization(E);
6425 
6426  case CK_BaseToDerivedMemberPointer: {
6427  if (!Visit(E->getSubExpr()))
6428  return false;
6429  if (E->path_empty())
6430  return true;
6431  // Base-to-derived member pointer casts store the path in derived-to-base
6432  // order, so iterate backwards. The CXXBaseSpecifier also provides us with
6433  // the wrong end of the derived->base arc, so stagger the path by one class.
6434  typedef std::reverse_iterator<CastExpr::path_const_iterator> ReverseIter;
6435  for (ReverseIter PathI(E->path_end() - 1), PathE(E->path_begin());
6436  PathI != PathE; ++PathI) {
6437  assert(!(*PathI)->isVirtual() && "memptr cast through vbase");
6438  const CXXRecordDecl *Derived = (*PathI)->getType()->getAsCXXRecordDecl();
6439  if (!Result.castToDerived(Derived))
6440  return Error(E);
6441  }
6442  const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass();
6443  if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl()))
6444  return Error(E);
6445  return true;
6446  }
6447 
6448  case CK_DerivedToBaseMemberPointer:
6449  if (!Visit(E->getSubExpr()))
6450  return false;
6451  for (CastExpr::path_const_iterator PathI = E->path_begin(),
6452  PathE = E->path_end(); PathI != PathE; ++PathI) {
6453  assert(!(*PathI)->isVirtual() && "memptr cast through vbase");
6454  const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
6455  if (!Result.castToBase(Base))
6456  return Error(E);
6457  }
6458  return true;
6459  }
6460 }
6461 
6462 bool MemberPointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
6463  // C++11 [expr.unary.op]p3 has very strict rules on how the address of a
6464  // member can be formed.
6465  return Success(cast<DeclRefExpr>(E->getSubExpr())->getDecl());
6466 }
6467 
6468 //===----------------------------------------------------------------------===//
6469 // Record Evaluation
6470 //===----------------------------------------------------------------------===//
6471 
6472 namespace {
6473  class RecordExprEvaluator
6474  : public ExprEvaluatorBase<RecordExprEvaluator> {
6475  const LValue &This;
6476  APValue &Result;
6477  public:
6478 
6479  RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result)
6480  : ExprEvaluatorBaseTy(info), This(This), Result(Result) {}
6481 
6482  bool Success(const APValue &V, const Expr *E) {
6483  Result = V;
6484  return true;
6485  }
6486  bool ZeroInitialization(const Expr *E) {
6487  return ZeroInitialization(E, E->getType());
6488  }
6489  bool ZeroInitialization(const Expr *E, QualType T);
6490 
6491  bool VisitCallExpr(const CallExpr *E) {
6492  return handleCallExpr(E, Result, &This);
6493  }
6494  bool VisitCastExpr(const CastExpr *E);
6495  bool VisitInitListExpr(const InitListExpr *E);
6496  bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
6497  return VisitCXXConstructExpr(E, E->getType());
6498  }
6499  bool VisitLambdaExpr(const LambdaExpr *E);
6500  bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
6501  bool VisitCXXConstructExpr(const CXXConstructExpr *E, QualType T);
6502  bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E);
6503 
6504  bool VisitBinCmp(const BinaryOperator *E);
6505  };
6506 }
6507 
6508 /// Perform zero-initialization on an object of non-union class type.
6509 /// C++11 [dcl.init]p5:
6510 /// To zero-initialize an object or reference of type T means:
6511 /// [...]
6512 /// -- if T is a (possibly cv-qualified) non-union class type,
6513 /// each non-static data member and each base-class subobject is
6514 /// zero-initialized
6515 static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E,
6516  const RecordDecl *RD,
6517  const LValue &This, APValue &Result) {
6518  assert(!RD->isUnion() && "Expected non-union class type");
6519  const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
6520  Result = APValue(APValue::UninitStruct(), CD ? CD->getNumBases() : 0,
6521  std::distance(RD->field_begin(), RD->field_end()));
6522 
6523  if (RD->isInvalidDecl()) return false;
6524  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6525 
6526  if (CD) {
6527  unsigned Index = 0;
6528  for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(),
6529  End = CD->bases_end(); I != End; ++I, ++Index) {
6530  const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl();
6531  LValue Subobject = This;
6532  if (!HandleLValueDirectBase(Info, E, Subobject, CD, Base, &Layout))
6533  return false;
6534  if (!HandleClassZeroInitialization(Info, E, Base, Subobject,
6535  Result.getStructBase(Index)))
6536  return false;
6537  }
6538  }
6539 
6540  for (const auto *I : RD->fields()) {
6541  // -- if T is a reference type, no initialization is performed.
6542  if (I->getType()->isReferenceType())
6543  continue;
6544 
6545  LValue Subobject = This;
6546  if (!HandleLValueMember(Info, E, Subobject, I, &Layout))
6547  return false;
6548 
6549  ImplicitValueInitExpr VIE(I->getType());
6550  if (!EvaluateInPlace(
6551  Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE))
6552  return false;
6553  }
6554 
6555  return true;
6556 }
6557 
6558 bool RecordExprEvaluator::ZeroInitialization(const Expr *E, QualType T) {
6559  const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
6560  if (RD->isInvalidDecl()) return false;
6561  if (RD->isUnion()) {
6562  // C++11 [dcl.init]p5: If T is a (possibly cv-qualified) union type, the
6563  // object's first non-static named data member is zero-initialized
6565  if (I == RD->field_end()) {
6566  Result = APValue((const FieldDecl*)nullptr);
6567  return true;
6568  }
6569 
6570  LValue Subobject = This;
6571  if (!HandleLValueMember(Info, E, Subobject, *I))
6572  return false;
6573  Result = APValue(*I);
6574  ImplicitValueInitExpr VIE(I->getType());
6575  return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE);
6576  }
6577 
6578  if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->getNumVBases()) {
6579  Info.FFDiag(E, diag::note_constexpr_virtual_base) << RD;
6580  return false;
6581  }
6582 
6583  return HandleClassZeroInitialization(Info, E, RD, This, Result);
6584 }
6585 
6586 bool RecordExprEvaluator::VisitCastExpr(const CastExpr *E) {
6587  switch (E->getCastKind()) {
6588  default:
6589  return ExprEvaluatorBaseTy::VisitCastExpr(E);
6590 
6591  case CK_ConstructorConversion:
6592  return Visit(E->getSubExpr());
6593 
6594  case CK_DerivedToBase:
6595  case CK_UncheckedDerivedToBase: {
6596  APValue DerivedObject;
6597  if (!Evaluate(DerivedObject, Info, E->getSubExpr()))
6598  return false;
6599  if (!DerivedObject.isStruct())
6600  return Error(E->getSubExpr());
6601 
6602  // Derived-to-base rvalue conversion: just slice off the derived part.
6603  APValue *Value = &DerivedObject;
6604  const CXXRecordDecl *RD = E->getSubExpr()->getType()->getAsCXXRecordDecl();
6605  for (CastExpr::path_const_iterator PathI = E->path_begin(),
6606  PathE = E->path_end(); PathI != PathE; ++PathI) {
6607  assert(!(*PathI)->isVirtual() && "record rvalue with virtual base");
6608  const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
6609  Value = &Value->getStructBase(getBaseIndex(RD, Base));
6610  RD = Base;
6611  }
6612  Result = *Value;
6613  return true;
6614  }
6615  }
6616 }
6617 
6618 bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
6619  if (E->isTransparent())
6620  return Visit(E->getInit(0));
6621 
6622  const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl();
6623  if (RD->isInvalidDecl()) return false;
6624  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6625 
6626  if (RD->isUnion()) {
6627  const FieldDecl *Field = E->getInitializedFieldInUnion();
6628  Result = APValue(Field);
6629  if (!Field)
6630  return true;
6631 
6632  // If the initializer list for a union does not contain any elements, the
6633  // first element of the union is value-initialized.
6634  // FIXME: The element should be initialized from an initializer list.
6635  // Is this difference ever observable for initializer lists which
6636  // we don't build?
6637  ImplicitValueInitExpr VIE(Field->getType());
6638  const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE;
6639 
6640  LValue Subobject = This;
6641  if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout))
6642  return false;
6643 
6644  // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
6645  ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
6646  isa<CXXDefaultInitExpr>(InitExpr));
6647 
6648  return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr);
6649  }
6650 
6651  auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
6652  if (Result.isUninit())
6653  Result = APValue(APValue::UninitStruct(), CXXRD ? CXXRD->getNumBases() : 0,
6654  std::distance(RD->field_begin(), RD->field_end()));
6655  unsigned ElementNo = 0;
6656  bool Success = true;
6657 
6658  // Initialize base classes.
6659  if (CXXRD) {
6660  for (const auto &Base : CXXRD->bases()) {
6661  assert(ElementNo < E->getNumInits() && "missing init for base class");
6662  const Expr *Init = E->getInit(ElementNo);
6663 
6664  LValue Subobject = This;
6665  if (!HandleLValueBase(Info, Init, Subobject, CXXRD, &Base))
6666  return false;
6667 
6668  APValue &FieldVal = Result.getStructBase(ElementNo);
6669  if (!EvaluateInPlace(FieldVal, Info, Subobject, Init)) {
6670  if (!Info.noteFailure())
6671  return false;
6672  Success = false;
6673  }
6674  ++ElementNo;
6675  }
6676  }
6677 
6678  // Initialize members.
6679  for (const auto *Field : RD->fields()) {
6680  // Anonymous bit-fields are not considered members of the class for
6681  // purposes of aggregate initialization.
6682  if (Field->isUnnamedBitfield())
6683  continue;
6684 
6685  LValue Subobject = This;
6686 
6687  bool HaveInit = ElementNo < E->getNumInits();
6688 
6689  // FIXME: Diagnostics here should point to the end of the initializer
6690  // list, not the start.
6691  if (!HandleLValueMember(Info, HaveInit ? E->getInit(ElementNo) : E,
6692  Subobject, Field, &Layout))
6693  return false;
6694 
6695  // Perform an implicit value-initialization for members beyond the end of
6696  // the initializer list.
6697  ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType());
6698  const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE;
6699 
6700  // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
6701  ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
6702  isa<CXXDefaultInitExpr>(Init));
6703 
6704  APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
6705  if (!EvaluateInPlace(FieldVal, Info, Subobject, Init) ||
6706  (Field->isBitField() && !truncateBitfieldValue(Info, Init,
6707  FieldVal, Field))) {
6708  if (!Info.noteFailure())
6709  return false;
6710  Success = false;
6711  }
6712  }
6713 
6714  return Success;
6715 }
6716 
6717 bool RecordExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
6718  QualType T) {
6719  // Note that E's type is not necessarily the type of our class here; we might
6720  // be initializing an array element instead.
6721  const CXXConstructorDecl *FD = E->getConstructor();
6722  if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl()) return false;
6723 
6724  bool ZeroInit = E->requiresZeroInitialization();
6725  if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) {
6726  // If we've already performed zero-initialization, we're already done.
6727  if (!Result.isUninit())
6728  return true;
6729 
6730  // We can get here in two different ways:
6731  // 1) We're performing value-initialization, and should zero-initialize
6732  // the object, or
6733  // 2) We're performing default-initialization of an object with a trivial
6734  // constexpr default constructor, in which case we should start the
6735  // lifetimes of all the base subobjects (there can be no data member
6736  // subobjects in this case) per [basic.life]p1.
6737  // Either way, ZeroInitialization is appropriate.
6738  return ZeroInitialization(E, T);
6739  }
6740 
6741  const FunctionDecl *Definition = nullptr;
6742  auto Body = FD->getBody(Definition);
6743 
6744  if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
6745  return false;
6746 
6747  // Avoid materializing a temporary for an elidable copy/move constructor.
6748  if (E->isElidable() && !ZeroInit)
6749  if (const MaterializeTemporaryExpr *ME
6750  = dyn_cast<MaterializeTemporaryExpr>(E->getArg(0)))
6751  return Visit(ME->GetTemporaryExpr());
6752 
6753  if (ZeroInit && !ZeroInitialization(E, T))
6754  return false;
6755 
6756  auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
6757  return HandleConstructorCall(E, This, Args,
6758  cast<CXXConstructorDecl>(Definition), Info,
6759  Result);
6760 }
6761 
6762 bool RecordExprEvaluator::VisitCXXInheritedCtorInitExpr(
6763  const CXXInheritedCtorInitExpr *E) {
6764  if (!Info.CurrentCall) {
6765  assert(Info.checkingPotentialConstantExpression());
6766  return false;
6767  }
6768 
6769  const CXXConstructorDecl *FD = E->getConstructor();
6770  if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl())
6771  return false;
6772 
6773  const FunctionDecl *Definition = nullptr;
6774  auto Body = FD->getBody(Definition);
6775 
6776  if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
6777  return false;
6778 
6779  return HandleConstructorCall(E, This, Info.CurrentCall->Arguments,
6780  cast<CXXConstructorDecl>(Definition), Info,
6781  Result);
6782 }
6783 
6784 bool RecordExprEvaluator::VisitCXXStdInitializerListExpr(
6785  const CXXStdInitializerListExpr *E) {
6786  const ConstantArrayType *ArrayType =
6787  Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
6788 
6789  LValue Array;
6790  if (!EvaluateLValue(E->getSubExpr(), Array, Info))
6791  return false;
6792 
6793  // Get a pointer to the first element of the array.
6794  Array.addArray(Info, E, ArrayType);
6795 
6796  // FIXME: Perform the checks on the field types in SemaInit.
6797  RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
6798  RecordDecl::field_iterator Field = Record->field_begin();
6799  if (Field == Record->field_end())
6800  return Error(E);
6801 
6802  // Start pointer.
6803  if (!Field->getType()->isPointerType() ||
6804  !Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
6805  ArrayType->getElementType()))
6806  return Error(E);
6807 
6808  // FIXME: What if the initializer_list type has base classes, etc?
6809  Result = APValue(APValue::UninitStruct(), 0, 2);
6810  Array.moveInto(Result.getStructField(0));
6811 
6812  if (++Field == Record->field_end())
6813  return Error(E);
6814 
6815  if (Field->getType()->isPointerType() &&
6816  Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
6817  ArrayType->getElementType())) {
6818  // End pointer.
6819  if (!HandleLValueArrayAdjustment(Info, E, Array,
6820  ArrayType->getElementType(),
6821  ArrayType->getSize().getZExtValue()))
6822  return false;
6823  Array.moveInto(Result.getStructField(1));
6824  } else if (Info.Ctx.hasSameType(Field->getType(), Info.Ctx.getSizeType()))
6825  // Length.
6826  Result.getStructField(1) = APValue(APSInt(ArrayType->getSize()));
6827  else
6828  return Error(E);
6829 
6830  if (++Field != Record->field_end())
6831  return Error(E);
6832 
6833  return true;
6834 }
6835 
6836 bool RecordExprEvaluator::VisitLambdaExpr(const LambdaExpr *E) {
6837  const CXXRecordDecl *ClosureClass = E->getLambdaClass();
6838  if (ClosureClass->isInvalidDecl()) return false;
6839 
6840  if (Info.checkingPotentialConstantExpression()) return true;
6841 
6842  const size_t NumFields =
6843  std::distance(ClosureClass->field_begin(), ClosureClass->field_end());
6844 
6845  assert(NumFields == (size_t)std::distance(E->capture_init_begin(),
6846  E->capture_init_end()) &&
6847  "The number of lambda capture initializers should equal the number of "
6848  "fields within the closure type");
6849 
6850  Result = APValue(APValue::UninitStruct(), /*NumBases*/0, NumFields);
6851  // Iterate through all the lambda's closure object's fields and initialize
6852  // them.
6853  auto *CaptureInitIt = E->capture_init_begin();
6854  const LambdaCapture *CaptureIt = ClosureClass->captures_begin();
6855  bool Success = true;
6856  for (const auto *Field : ClosureClass->fields()) {
6857  assert(CaptureInitIt != E->capture_init_end());
6858  // Get the initializer for this field
6859  Expr *const CurFieldInit = *CaptureInitIt++;
6860 
6861  // If there is no initializer, either this is a VLA or an error has
6862  // occurred.
6863  if (!CurFieldInit)
6864  return Error(E);
6865 
6866  APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
6867  if (!EvaluateInPlace(FieldVal, Info, This, CurFieldInit)) {
6868  if (!Info.keepEvaluatingAfterFailure())
6869  return false;
6870  Success = false;
6871  }
6872  ++CaptureIt;
6873  }
6874  return Success;
6875 }
6876 
6877 static bool EvaluateRecord(const Expr *E, const LValue &This,
6878  APValue &Result, EvalInfo &Info) {
6879  assert(E->isRValue() && E->getType()->isRecordType() &&
6880  "can't evaluate expression as a record rvalue");
6881  return RecordExprEvaluator(Info, This, Result).Visit(E);
6882 }
6883 
6884 //===----------------------------------------------------------------------===//
6885 // Temporary Evaluation
6886 //
6887 // Temporaries are represented in the AST as rvalues, but generally behave like
6888 // lvalues. The full-object of which the temporary is a subobject is implicitly
6889 // materialized so that a reference can bind to it.
6890 //===----------------------------------------------------------------------===//
6891 namespace {
6892 class TemporaryExprEvaluator
6893  : public LValueExprEvaluatorBase<TemporaryExprEvaluator> {
6894 public:
6895  TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) :
6896  LValueExprEvaluatorBaseTy(Info, Result, false) {}
6897 
6898  /// Visit an expression which constructs the value of this temporary.
6899  bool VisitConstructExpr(const Expr *E) {
6900  APValue &Value = createTemporary(E, false, Result, *Info.CurrentCall);
6901  return EvaluateInPlace(Value, Info, Result, E);
6902  }
6903 
6904  bool VisitCastExpr(const CastExpr *E) {
6905  switch (E->getCastKind()) {
6906  default:
6907  return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
6908 
6909  case CK_ConstructorConversion:
6910  return VisitConstructExpr(E->getSubExpr());
6911  }
6912  }
6913  bool VisitInitListExpr(const InitListExpr *E) {
6914  return VisitConstructExpr(E);
6915  }
6916  bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
6917  return VisitConstructExpr(E);
6918  }
6919  bool VisitCallExpr(const CallExpr *E) {
6920  return VisitConstructExpr(E);
6921  }
6922  bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E) {
6923  return VisitConstructExpr(E);
6924  }
6925  bool VisitLambdaExpr(const LambdaExpr *E) {
6926  return VisitConstructExpr(E);
6927  }
6928 };
6929 } // end anonymous namespace
6930 
6931 /// Evaluate an expression of record type as a temporary.
6932 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
6933  assert(E->isRValue() && E->getType()->isRecordType());
6934  return TemporaryExprEvaluator(Info, Result).Visit(E);
6935 }
6936 
6937 //===----------------------------------------------------------------------===//
6938 // Vector Evaluation
6939 //===----------------------------------------------------------------------===//
6940 
6941 namespace {
6942  class VectorExprEvaluator
6943  : public ExprEvaluatorBase<VectorExprEvaluator> {
6944  APValue &Result;
6945  public:
6946 
6947  VectorExprEvaluator(EvalInfo &info, APValue &Result)
6948  : ExprEvaluatorBaseTy(info), Result(Result) {}
6949 
6950  bool Success(ArrayRef<APValue> V, const Expr *E) {
6951  assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements());
6952  // FIXME: remove this APValue copy.
6953  Result = APValue(V.data(), V.size());
6954  return true;
6955  }
6956  bool Success(const APValue &V, const Expr *E) {
6957  assert(V.isVector());
6958  Result = V;
6959  return true;
6960  }
6961  bool ZeroInitialization(const Expr *E);
6962 
6963  bool VisitUnaryReal(const UnaryOperator *E)
6964  { return Visit(E->getSubExpr()); }
6965  bool VisitCastExpr(const CastExpr* E);
6966  bool VisitInitListExpr(const InitListExpr *E);
6967  bool VisitUnaryImag(const UnaryOperator *E);
6968  // FIXME: Missing: unary -, unary ~, binary add/sub/mul/div,
6969  // binary comparisons, binary and/or/xor,
6970  // shufflevector, ExtVectorElementExpr
6971  };
6972 } // end anonymous namespace
6973 
6974 static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
6975  assert(E->isRValue() && E->getType()->isVectorType() &&"not a vector rvalue");
6976  return VectorExprEvaluator(Info, Result).Visit(E);
6977 }
6978 
6979 bool VectorExprEvaluator::VisitCastExpr(const CastExpr *E) {
6980  const VectorType *VTy = E->getType()->castAs<VectorType>();
6981  unsigned NElts = VTy->getNumElements();
6982 
6983  const Expr *SE = E->getSubExpr();
6984  QualType SETy = SE->getType();
6985 
6986  switch (E->getCastKind()) {
6987  case CK_VectorSplat: {
6988  APValue Val = APValue();
6989  if (SETy->isIntegerType()) {
6990  APSInt IntResult;
6991  if (!EvaluateInteger(SE, IntResult, Info))
6992  return false;
6993  Val = APValue(std::move(IntResult));
6994  } else if (SETy->isRealFloatingType()) {
6995  APFloat FloatResult(0.0);
6996  if (!EvaluateFloat(SE, FloatResult, Info))
6997  return false;
6998  Val = APValue(std::move(FloatResult));
6999  } else {
7000  return Error(E);
7001  }
7002 
7003  // Splat and create vector APValue.
7004  SmallVector<APValue, 4> Elts(NElts, Val);
7005  return Success(Elts, E);
7006  }
7007  case CK_BitCast: {
7008  // Evaluate the operand into an APInt we can extract from.
7009  llvm::APInt SValInt;
7010  if (!EvalAndBitcastToAPInt(Info, SE, SValInt))
7011  return false;
7012  // Extract the elements
7013  QualType EltTy = VTy->getElementType();
7014  unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
7015  bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
7017  if (EltTy->isRealFloatingType()) {
7018  const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy);
7019  unsigned FloatEltSize = EltSize;
7020  if (&Sem == &APFloat::x87DoubleExtended())
7021  FloatEltSize = 80;
7022  for (unsigned i = 0; i < NElts; i++) {
7023  llvm::APInt Elt;
7024  if (BigEndian)
7025  Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize);
7026  else
7027  Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize);
7028  Elts.push_back(APValue(APFloat(Sem, Elt)));
7029  }
7030  } else if (EltTy->isIntegerType()) {
7031  for (unsigned i = 0; i < NElts; i++) {
7032  llvm::APInt Elt;
7033  if (BigEndian)
7034  Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize);
7035  else
7036  Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize);
7037  Elts.push_back(APValue(APSInt(Elt, EltTy->isSignedIntegerType())));
7038  }
7039  } else {
7040  return Error(E);
7041  }
7042  return Success(Elts, E);
7043  }
7044  default:
7045  return ExprEvaluatorBaseTy::VisitCastExpr(E);
7046  }
7047 }
7048 
7049 bool
7050 VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
7051  const VectorType *VT = E->getType()->castAs<VectorType>();
7052  unsigned NumInits = E->getNumInits();
7053  unsigned NumElements = VT->getNumElements();
7054 
7055  QualType EltTy = VT->getElementType();
7056  SmallVector<APValue, 4> Elements;
7057 
7058  // The number of initializers can be less than the number of
7059  // vector elements. For OpenCL, this can be due to nested vector
7060  // initialization. For GCC compatibility, missing trailing elements
7061  // should be initialized with zeroes.
7062  unsigned CountInits = 0, CountElts = 0;
7063  while (CountElts < NumElements) {
7064  // Handle nested vector initialization.
7065  if (CountInits < NumInits
7066  && E->getInit(CountInits)->getType()->isVectorType()) {
7067  APValue v;
7068  if (!EvaluateVector(E->getInit(CountInits), v, Info))
7069  return Error(E);
7070  unsigned vlen = v.getVectorLength();
7071  for (unsigned j = 0; j < vlen; j++)
7072  Elements.push_back(v.getVectorElt(j));
7073  CountElts += vlen;
7074  } else if (EltTy->isIntegerType()) {
7075  llvm::APSInt sInt(32);
7076  if (CountInits < NumInits) {
7077  if (!EvaluateInteger(E->getInit(CountInits), sInt, Info))
7078  return false;
7079  } else // trailing integer zero.
7080  sInt = Info.Ctx.MakeIntValue(0, EltTy);
7081  Elements.push_back(APValue(sInt));
7082  CountElts++;
7083  } else {
7084  llvm::APFloat f(0.0);
7085  if (CountInits < NumInits) {
7086  if (!EvaluateFloat(E->getInit(CountInits), f, Info))
7087  return false;
7088  } else // trailing float zero.
7089  f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
7090  Elements.push_back(APValue(f));
7091  CountElts++;
7092  }
7093  CountInits++;
7094  }
7095  return Success(Elements, E);
7096 }
7097 
7098 bool
7099 VectorExprEvaluator::ZeroInitialization(const Expr *E) {
7100  const VectorType *VT = E->getType()->getAs<VectorType>();
7101  QualType EltTy = VT->getElementType();
7102  APValue ZeroElement;
7103  if (EltTy->isIntegerType())
7104  ZeroElement = APValue(Info.Ctx.MakeIntValue(0, EltTy));
7105  else
7106  ZeroElement =
7107  APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
7108 
7109  SmallVector<APValue, 4> Elements(VT->getNumElements(), ZeroElement);
7110  return Success(Elements, E);
7111 }
7112 
7113 bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
7114  VisitIgnoredValue(E->getSubExpr());
7115  return ZeroInitialization(E);
7116 }
7117 
7118 //===----------------------------------------------------------------------===//
7119 // Array Evaluation
7120 //===----------------------------------------------------------------------===//
7121 
7122 namespace {
7123  class ArrayExprEvaluator
7124  : public ExprEvaluatorBase<ArrayExprEvaluator> {
7125  const LValue &This;
7126  APValue &Result;
7127  public:
7128 
7129  ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result)
7130  : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
7131 
7132  bool Success(const APValue &V, const Expr *E) {
7133  assert((V.isArray() || V.isLValue()) &&
7134  "expected array or string literal");
7135  Result = V;
7136  return true;
7137  }
7138 
7139  bool ZeroInitialization(const Expr *E) {
7140  const ConstantArrayType *CAT =
7141  Info.Ctx.getAsConstantArrayType(E->getType());
7142  if (!CAT)
7143  return Error(E);
7144 
7145  Result = APValue(APValue::UninitArray(), 0,
7146  CAT->getSize().getZExtValue());
7147  if (!Result.hasArrayFiller()) return true;
7148 
7149  // Zero-initialize all elements.
7150  LValue Subobject = This;
7151  Subobject.addArray(Info, E, CAT);
7153  return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
7154  }
7155 
7156  bool VisitCallExpr(const CallExpr *E) {
7157  return handleCallExpr(E, Result, &This);
7158  }
7159  bool VisitInitListExpr(const InitListExpr *E);
7160  bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E);
7161  bool VisitCXXConstructExpr(const CXXConstructExpr *E);
7162  bool VisitCXXConstructExpr(const CXXConstructExpr *E,
7163  const LValue &Subobject,
7164  APValue *Value, QualType Type);
7165  };
7166 } // end anonymous namespace
7167 
7168 static bool EvaluateArray(const Expr *E, const LValue &This,
7169  APValue &Result, EvalInfo &Info) {
7170  assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue");
7171  return ArrayExprEvaluator(Info, This, Result).Visit(E);
7172 }
7173 
7174 // Return true iff the given array filler may depend on the element index.
7175 static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {
7176  // For now, just whitelist non-class value-initialization and initialization
7177  // lists comprised of them.
7178  if (isa<ImplicitValueInitExpr>(FillerExpr))
7179  return false;
7180  if (const InitListExpr *ILE = dyn_cast<InitListExpr>(FillerExpr)) {
7181  for (unsigned I = 0, E = ILE->getNumInits(); I != E; ++I) {
7182  if (MaybeElementDependentArrayFiller(ILE->getInit(I)))
7183  return true;
7184  }
7185  return false;
7186  }
7187  return true;
7188 }
7189 
7190 bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
7191  const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(E->getType());
7192  if (!CAT)
7193  return Error(E);
7194 
7195  // C++11 [dcl.init.string]p1: A char array [...] can be initialized by [...]
7196  // an appropriately-typed string literal enclosed in braces.
7197  if (E->isStringLiteralInit()) {
7198  LValue LV;
7199  if (!EvaluateLValue(E->getInit(0), LV, Info))
7200  return false;
7201  APValue Val;
7202  LV.moveInto(Val);
7203  return Success(Val, E);
7204  }
7205 
7206  bool Success = true;
7207 
7208  assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) &&
7209  "zero-initialized array shouldn't have any initialized elts");
7210  APValue Filler;
7211  if (Result.isArray() && Result.hasArrayFiller())
7212  Filler = Result.getArrayFiller();
7213 
7214  unsigned NumEltsToInit = E->getNumInits();
7215  unsigned NumElts = CAT->getSize().getZExtValue();
7216  const Expr *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : nullptr;
7217 
7218  // If the initializer might depend on the array index, run it for each
7219  // array element.
7220  if (NumEltsToInit != NumElts && MaybeElementDependentArrayFiller(FillerExpr))
7221  NumEltsToInit = NumElts;
7222 
7223  LLVM_DEBUG(llvm::dbgs() << "The number of elements to initialize: "
7224  << NumEltsToInit << ".\n");
7225 
7226  Result = APValue(APValue::UninitArray(), NumEltsToInit, NumElts);
7227 
7228  // If the array was previously zero-initialized, preserve the
7229  // zero-initialized values.
7230  if (!Filler.isUninit()) {
7231  for (unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I)
7232  Result.getArrayInitializedElt(I) = Filler;
7233  if (Result.hasArrayFiller())
7234  Result.getArrayFiller() = Filler;
7235  }
7236 
7237  LValue Subobject = This;
7238  Subobject.addArray(Info, E, CAT);
7239  for (unsigned Index = 0; Index != NumEltsToInit; ++Index) {
7240  const Expr *Init =
7241  Index < E->getNumInits() ? E->getInit(Index) : FillerExpr;
7242  if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
7243  Info, Subobject, Init) ||
7244  !HandleLValueArrayAdjustment(Info, Init, Subobject,
7245  CAT->getElementType(), 1)) {
7246  if (!Info.noteFailure())
7247  return false;
7248  Success = false;
7249  }
7250  }
7251 
7252  if (!Result.hasArrayFiller())
7253  return Success;
7254 
7255  // If we get here, we have a trivial filler, which we can just evaluate
7256  // once and splat over the rest of the array elements.
7257  assert(FillerExpr && "no array filler for incomplete init list");
7258  return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject,
7259  FillerExpr) && Success;
7260 }
7261 
7262 bool ArrayExprEvaluator::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) {
7263  if (E->getCommonExpr() &&
7264  !Evaluate(Info.CurrentCall->createTemporary(E->getCommonExpr(), false),
7265  Info, E->getCommonExpr()->getSourceExpr()))
7266  return false;
7267 
7268  auto *CAT = cast<ConstantArrayType>(E->getType()->castAsArrayTypeUnsafe());
7269 
7270  uint64_t Elements = CAT->getSize().getZExtValue();
7271  Result = APValue(APValue::UninitArray(), Elements, Elements);
7272 
7273  LValue Subobject = This;
7274  Subobject.addArray(Info, E, CAT);
7275 
7276  bool Success = true;
7277  for (EvalInfo::ArrayInitLoopIndex Index(Info); Index != Elements; ++Index) {
7278  if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
7279  Info, Subobject, E->getSubExpr()) ||
7280  !HandleLValueArrayAdjustment(Info, E, Subobject,
7281  CAT->getElementType(), 1)) {
7282  if (!Info.noteFailure())
7283  return false;
7284  Success = false;
7285  }
7286  }
7287 
7288  return Success;
7289 }
7290 
7291 bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E) {
7292  return VisitCXXConstructExpr(E, This, &Result, E->getType());
7293 }
7294 
7295 bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
7296  const LValue &Subobject,
7297  APValue *Value,
7298  QualType Type) {
7299  bool HadZeroInit = !Value->isUninit();
7300 
7301  if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) {
7302  unsigned N = CAT->getSize().getZExtValue();
7303 
7304  // Preserve the array filler if we had prior zero-initialization.
7305  APValue Filler =
7306  HadZeroInit && Value->hasArrayFiller() ? Value->getArrayFiller()
7307  : APValue();
7308 
7309  *Value = APValue(APValue::UninitArray(), N, N);
7310 
7311  if (HadZeroInit)
7312  for (unsigned I = 0; I != N; ++I)
7313  Value->getArrayInitializedElt(I) = Filler;
7314 
7315  // Initialize the elements.
7316  LValue ArrayElt = Subobject;
7317  ArrayElt.addArray(Info, E, CAT);
7318  for (unsigned I = 0; I != N; ++I)
7319  if (!VisitCXXConstructExpr(E, ArrayElt, &Value->getArrayInitializedElt(I),
7320  CAT->getElementType()) ||
7321  !HandleLValueArrayAdjustment(Info, E, ArrayElt,
7322  CAT->getElementType(), 1))
7323  return false;
7324 
7325  return true;
7326  }
7327 
7328  if (!Type->isRecordType())
7329  return Error(E);
7330 
7331  return RecordExprEvaluator(Info, Subobject, *Value)
7332  .VisitCXXConstructExpr(E, Type);
7333 }
7334 
7335 //===----------------------------------------------------------------------===//
7336 // Integer Evaluation
7337 //
7338 // As a GNU extension, we support casting pointers to sufficiently-wide integer
7339 // types and back in constant folding. Integer values are thus represented
7340 // either as an integer-valued APValue, or as an lvalue-valued APValue.
7341 //===----------------------------------------------------------------------===//
7342 
7343 namespace {
7344 class IntExprEvaluator
7345  : public ExprEvaluatorBase<IntExprEvaluator> {
7346  APValue &Result;
7347 public:
7348  IntExprEvaluator(EvalInfo &info, APValue &result)
7349  : ExprEvaluatorBaseTy(info), Result(result) {}
7350 
7351  bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
7352  assert(E->getType()->isIntegralOrEnumerationType() &&
7353  "Invalid evaluation result.");
7354  assert(SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() &&
7355  "Invalid evaluation result.");
7356  assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
7357  "Invalid evaluation result.");
7358  Result = APValue(SI);
7359  return true;
7360  }
7361  bool Success(const llvm::APSInt &SI, const Expr *E) {
7362  return Success(SI, E, Result);
7363  }
7364 
7365  bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
7366  assert(E->getType()->isIntegralOrEnumerationType() &&
7367  "Invalid evaluation result.");
7368  assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
7369  "Invalid evaluation result.");
7370  Result = APValue(APSInt(I));
7371  Result.getInt().setIsUnsigned(
7373  return true;
7374  }
7375  bool Success(const llvm::APInt &I, const Expr *E) {
7376  return Success(I, E, Result);
7377  }
7378 
7379  bool Success(uint64_t Value, const Expr *E, APValue &Result) {
7380  assert(E->getType()->isIntegralOrEnumerationType() &&
7381  "Invalid evaluation result.");
7382  Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
7383  return true;
7384  }
7385  bool Success(uint64_t Value, const Expr *E) {
7386  return Success(Value, E, Result);
7387  }
7388 
7389  bool Success(CharUnits Size, const Expr *E) {
7390  return Success(Size.getQuantity(), E);
7391  }
7392 
7393  bool Success(const APValue &V, const Expr *E) {
7394  if (V.isLValue() || V.isAddrLabelDiff()) {
7395  Result = V;
7396  return true;
7397  }
7398  return Success(V.getInt(), E);
7399  }
7400 
7401  bool ZeroInitialization(const Expr *E) { return Success(0, E); }
7402 
7403  //===--------------------------------------------------------------------===//
7404  // Visitor Methods
7405  //===--------------------------------------------------------------------===//
7406 
7407  bool VisitConstantExpr(const ConstantExpr *E);
7408 
7409  bool VisitIntegerLiteral(const IntegerLiteral *E) {
7410  return Success(E->getValue(), E);
7411  }
7412  bool VisitCharacterLiteral(const CharacterLiteral *E) {
7413  return Success(E->getValue(), E);
7414  }
7415 
7416  bool CheckReferencedDecl(const Expr *E, const Decl *D);
7417  bool VisitDeclRefExpr(const DeclRefExpr *E) {
7418  if (CheckReferencedDecl(E, E->getDecl()))
7419  return true;
7420 
7421  return ExprEvaluatorBaseTy::VisitDeclRefExpr(E);
7422  }
7423  bool VisitMemberExpr(const MemberExpr *E) {
7424  if (CheckReferencedDecl(E, E->getMemberDecl())) {
7425  VisitIgnoredBaseExpression(E->getBase());
7426  return true;
7427  }
7428 
7429  return ExprEvaluatorBaseTy::VisitMemberExpr(E);
7430  }
7431 
7432  bool VisitCallExpr(const CallExpr *E);
7433  bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
7434  bool VisitBinaryOperator(const BinaryOperator *E);
7435  bool VisitOffsetOfExpr(const OffsetOfExpr *E);
7436  bool VisitUnaryOperator(const UnaryOperator *E);
7437 
7438  bool VisitCastExpr(const CastExpr* E);
7439  bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
7440 
7441  bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
7442  return Success(E->getValue(), E);
7443  }
7444 
7445  bool VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
7446  return Success(E->getValue(), E);
7447  }
7448 
7449  bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) {
7450  if (Info.ArrayInitIndex == uint64_t(-1)) {
7451  // We were asked to evaluate this subexpression independent of the
7452  // enclosing ArrayInitLoopExpr. We can't do that.
7453  Info.FFDiag(E);
7454  return false;
7455  }
7456  return Success(Info.ArrayInitIndex, E);
7457  }
7458 
7459  // Note, GNU defines __null as an integer, not a pointer.
7460  bool VisitGNUNullExpr(const GNUNullExpr *E) {
7461  return ZeroInitialization(E);
7462  }
7463 
7464  bool VisitTypeTraitExpr(const TypeTraitExpr *E) {
7465  return Success(E->getValue(), E);
7466  }
7467 
7468  bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
7469  return Success(E->getValue(), E);
7470  }
7471 
7472  bool VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
7473  return Success(E->getValue(), E);
7474  }
7475 
7476  bool VisitUnaryReal(const UnaryOperator *E);
7477  bool VisitUnaryImag(const UnaryOperator *E);
7478 
7479  bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E);
7480  bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
7481 
7482  // FIXME: Missing: array subscript of vector, member of vector
7483 };
7484 
7485 class FixedPointExprEvaluator
7486  : public ExprEvaluatorBase<FixedPointExprEvaluator> {
7487  APValue &Result;
7488 
7489  public:
7490  FixedPointExprEvaluator(EvalInfo &info, APValue &result)
7491  : ExprEvaluatorBaseTy(info), Result(result) {}
7492 
7493  bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
7494  assert(E->getType()->isFixedPointType() && "Invalid evaluation result.");
7495  assert(SI.isSigned() == E->getType()->isSignedFixedPointType() &&
7496  "Invalid evaluation result.");
7497  assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
7498  "Invalid evaluation result.");
7499  Result = APValue(SI);
7500  return true;
7501  }
7502  bool Success(const llvm::APSInt &SI, const Expr *E) {
7503  return Success(SI, E, Result);
7504  }
7505 
7506  bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
7507  assert(E->getType()->isFixedPointType() && "Invalid evaluation result.");
7508  assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
7509  "Invalid evaluation result.");
7510  Result = APValue(APSInt(I));
7511  Result.getInt().setIsUnsigned(E->getType()->isUnsignedFixedPointType());
7512  return true;
7513  }
7514  bool Success(const llvm::APInt &I, const Expr *E) {
7515  return Success(I, E, Result);
7516  }
7517 
7518  bool Success(uint64_t Value, const Expr *E, APValue &Result) {
7519  assert(E->getType()->isFixedPointType() && "Invalid evaluation result.");
7520  Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
7521  return true;
7522  }
7523  bool Success(uint64_t Value, const Expr *E) {
7524  return Success(Value, E, Result);
7525  }
7526 
7527  bool Success(CharUnits Size, const Expr *E) {
7528  return Success(Size.getQuantity(), E);
7529  }
7530 
7531  bool Success(const APValue &V, const Expr *E) {
7532  if (V.isLValue() || V.isAddrLabelDiff()) {
7533  Result = V;
7534  return true;
7535  }
7536  return Success(V.getInt(), E);
7537  }
7538 
7539  bool ZeroInitialization(const Expr *E) { return Success(0, E); }
7540 
7541  //===--------------------------------------------------------------------===//
7542  // Visitor Methods
7543  //===--------------------------------------------------------------------===//
7544 
7545  bool VisitFixedPointLiteral(const FixedPointLiteral *E) {
7546  return Success(E->getValue(), E);
7547  }
7548 
7549  bool VisitUnaryOperator(const UnaryOperator *E);
7550 };
7551 } // end anonymous namespace
7552 
7553 /// EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and
7554 /// produce either the integer value or a pointer.
7555 ///
7556 /// GCC has a heinous extension which folds casts between pointer types and
7557 /// pointer-sized integral types. We support this by allowing the evaluation of
7558 /// an integer rvalue to produce a pointer (represented as an lvalue) instead.
7559 /// Some simple arithmetic on such values is supported (they are treated much
7560 /// like char*).
7561 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
7562  EvalInfo &Info) {
7563  assert(E->isRValue() && E->getType()->isIntegralOrEnumerationType());
7564  return IntExprEvaluator(Info, Result).Visit(E);
7565 }
7566 
7567 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
7568  APValue Val;
7569  if (!EvaluateIntegerOrLValue(E, Val, Info))
7570  return false;
7571  if (!Val.isInt()) {
7572  // FIXME: It would be better to produce the diagnostic for casting
7573  // a pointer to an integer.
7574  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
7575  return false;
7576  }
7577  Result = Val.getInt();
7578  return true;
7579 }
7580 
7581 /// Check whether the given declaration can be directly converted to an integral
7582 /// rvalue. If not, no diagnostic is produced; there are other things we can
7583 /// try.
7584 bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) {
7585  // Enums are integer constant exprs.
7586  if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) {
7587  // Check for signedness/width mismatches between E type and ECD value.
7588  bool SameSign = (ECD->getInitVal().isSigned()
7590  bool SameWidth = (ECD->getInitVal().getBitWidth()
7591  == Info.Ctx.getIntWidth(E->getType()));
7592  if (SameSign && SameWidth)
7593  return Success(ECD->getInitVal(), E);
7594  else {
7595  // Get rid of mismatch (otherwise Success assertions will fail)
7596  // by computing a new value matching the type of E.
7597  llvm::APSInt Val = ECD->getInitVal();
7598  if (!SameSign)
7599  Val.setIsSigned(!ECD->getInitVal().isSigned());
7600  if (!SameWidth)
7601  Val = Val.extOrTrunc(Info.Ctx.getIntWidth(E->getType()));
7602  return Success(Val, E);
7603  }
7604  }
7605  return false;
7606 }
7607 
7608 /// Values returned by __builtin_classify_type, chosen to match the values
7609 /// produced by GCC's builtin.
7610 enum class GCCTypeClass {
7611  None = -1,
7612  Void = 0,
7613  Integer = 1,
7614  // GCC reserves 2 for character types, but instead classifies them as
7615  // integers.
7616  Enum = 3,
7617  Bool = 4,
7618  Pointer = 5,
7619  // GCC reserves 6 for references, but appears to never use it (because
7620  // expressions never have reference type, presumably).
7621  PointerToDataMember = 7,
7622  RealFloat = 8,
7623  Complex = 9,
7624  // GCC reserves 10 for functions, but does not use it since GCC version 6 due
7625  // to decay to pointer. (Prior to version 6 it was only used in C++ mode).
7626  // GCC claims to reserve 11 for pointers to member functions, but *actually*
7627  // uses 12 for that purpose, same as for a class or struct. Maybe it
7628  // internally implements a pointer to member as a struct? Who knows.
7629  PointerToMemberFunction = 12, // Not a bug, see above.
7630  ClassOrStruct = 12,
7631  Union = 13,
7632  // GCC reserves 14 for arrays, but does not use it since GCC version 6 due to
7633  // decay to pointer. (Prior to version 6 it was only used in C++ mode).
7634  // GCC reserves 15 for strings, but actually uses 5 (pointer) for string
7635  // literals.
7636 };
7637 
7638 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
7639 /// as GCC.
7640 static GCCTypeClass
7642  assert(!T->isDependentType() && "unexpected dependent type");
7643 
7644  QualType CanTy = T.getCanonicalType();
7645  const BuiltinType *BT = dyn_cast<BuiltinType>(CanTy);
7646 
7647  switch (CanTy->getTypeClass()) {
7648 #define TYPE(ID, BASE)
7649 #define DEPENDENT_TYPE(ID, BASE) case Type::ID:
7650 #define NON_CANONICAL_TYPE(ID, BASE) case Type::ID:
7651 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(ID, BASE) case Type::ID:
7652 #include "clang/AST/TypeNodes.def"
7653  case Type::Auto:
7654  case Type::DeducedTemplateSpecialization:
7655  llvm_unreachable("unexpected non-canonical or dependent type");
7656 
7657  case Type::Builtin:
7658  switch (BT->getKind()) {
7659 #define BUILTIN_TYPE(ID, SINGLETON_ID)
7660 #define SIGNED_TYPE(ID, SINGLETON_ID) \
7661  case BuiltinType::ID: return GCCTypeClass::Integer;
7662 #define FLOATING_TYPE(ID, SINGLETON_ID) \
7663  case BuiltinType::ID: return GCCTypeClass::RealFloat;
7664 #define PLACEHOLDER_TYPE(ID, SINGLETON_ID) \
7665  case BuiltinType::ID: break;
7666 #include "clang/AST/BuiltinTypes.def"
7667  case BuiltinType::Void:
7668  return GCCTypeClass::Void;
7669 
7670  case BuiltinType::Bool:
7671  return GCCTypeClass::Bool;
7672 
7673  case BuiltinType::Char_U:
7674  case BuiltinType::UChar:
7675  case BuiltinType::WChar_U:
7676  case BuiltinType::Char8:
7677  case BuiltinType::Char16:
7678  case BuiltinType::Char32:
7679  case BuiltinType::UShort:
7680  case BuiltinType::UInt:
7681  case BuiltinType::ULong:
7682  case BuiltinType::ULongLong:
7683  case BuiltinType::UInt128:
7684  return GCCTypeClass::Integer;
7685 
7686  case BuiltinType::UShortAccum:
7687  case BuiltinType::UAccum:
7688  case BuiltinType::ULongAccum:
7689  case BuiltinType::UShortFract:
7690  case BuiltinType::UFract:
7691  case BuiltinType::ULongFract:
7692  case BuiltinType::SatUShortAccum:
7693  case BuiltinType::SatUAccum:
7694  case BuiltinType::SatULongAccum:
7695  case BuiltinType::SatUShortFract:
7696  case BuiltinType::SatUFract:
7697  case BuiltinType::SatULongFract:
7698  return GCCTypeClass::None;
7699 
7700  case BuiltinType::NullPtr:
7701 
7702  case BuiltinType::ObjCId:
7703  case BuiltinType::ObjCClass:
7704  case BuiltinType::ObjCSel:
7705 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7706  case BuiltinType::Id:
7707 #include "clang/Basic/OpenCLImageTypes.def"
7708 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7709  case BuiltinType::Id:
7710 #include "clang/Basic/OpenCLExtensionTypes.def"
7711  case BuiltinType::OCLSampler:
7712  case BuiltinType::OCLEvent:
7713  case BuiltinType::OCLClkEvent:
7714  case BuiltinType::OCLQueue:
7715  case BuiltinType::OCLReserveID:
7716  return GCCTypeClass::None;
7717 
7718  case BuiltinType::Dependent:
7719  llvm_unreachable("unexpected dependent type");
7720  };
7721  llvm_unreachable("unexpected placeholder type");
7722 
7723  case Type::Enum:
7724  return LangOpts.CPlusPlus ? GCCTypeClass::Enum : GCCTypeClass::Integer;
7725 
7726  case Type::Pointer:
7727  case Type::ConstantArray:
7728  case Type::VariableArray:
7729  case Type::IncompleteArray:
7730  case Type::FunctionNoProto:
7731  case Type::FunctionProto:
7732  return GCCTypeClass::Pointer;
7733 
7734  case Type::MemberPointer:
7735  return CanTy->isMemberDataPointerType()
7738 
7739  case Type::Complex:
7740  return GCCTypeClass::Complex;
7741 
7742  case Type::Record:
7743  return CanTy->isUnionType() ? GCCTypeClass::Union
7745 
7746  case Type::Atomic:
7747  // GCC classifies _Atomic T the same as T.
7749  CanTy->castAs<AtomicType>()->getValueType(), LangOpts);
7750 
7751  case Type::BlockPointer:
7752  case Type::Vector:
7753  case Type::ExtVector:
7754  case Type::ObjCObject:
7755  case Type::ObjCInterface:
7756  case Type::ObjCObjectPointer:
7757  case Type::Pipe:
7758  // GCC classifies vectors as None. We follow its lead and classify all
7759  // other types that don't fit into the regular classification the same way.
7760  return GCCTypeClass::None;
7761 
7762  case Type::LValueReference:
7763  case Type::RValueReference:
7764  llvm_unreachable("invalid type for expression");
7765  }
7766 
7767  llvm_unreachable("unexpected type class");
7768 }
7769 
7770 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
7771 /// as GCC.
7772 static GCCTypeClass
7774  // If no argument was supplied, default to None. This isn't
7775  // ideal, however it is what gcc does.
7776  if (E->getNumArgs() == 0)
7777  return GCCTypeClass::None;
7778 
7779  // FIXME: Bizarrely, GCC treats a call with more than one argument as not
7780  // being an ICE, but still folds it to a constant using the type of the first
7781  // argument.
7782  return EvaluateBuiltinClassifyType(E->getArg(0)->getType(), LangOpts);
7783 }
7784 
7785 /// EvaluateBuiltinConstantPForLValue - Determine the result of
7786 /// __builtin_constant_p when applied to the given lvalue.
7787 ///
7788 /// An lvalue is only "constant" if it is a pointer or reference to the first
7789 /// character of a string literal.
7790 template<typename LValue>
7791 static bool EvaluateBuiltinConstantPForLValue(const LValue &LV) {
7792  const Expr *E = LV.getLValueBase().template dyn_cast<const Expr*>();
7793  return E && isa<StringLiteral>(E) && LV.getLValueOffset().isZero();
7794 }
7795 
7796 /// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to
7797 /// GCC as we can manage.
7798 static bool EvaluateBuiltinConstantP(ASTContext &Ctx, const Expr *Arg) {
7799  QualType ArgType = Arg->getType();
7800 
7801  // __builtin_constant_p always has one operand. The rules which gcc follows
7802  // are not precisely documented, but are as follows:
7803  //
7804  // - If the operand is of integral, floating, complex or enumeration type,
7805  // and can be folded to a known value of that type, it returns 1.
7806  // - If the operand and can be folded to a pointer to the first character
7807  // of a string literal (or such a pointer cast to an integral type), it
7808  // returns 1.
7809  //
7810  // Otherwise, it returns 0.
7811  //
7812  // FIXME: GCC also intends to return 1 for literals of aggregate types, but
7813  // its support for this does not currently work.
7814  if (ArgType->isIntegralOrEnumerationType()) {
7816  if (!Arg->EvaluateAsRValue(Result, Ctx) || Result.HasSideEffects)
7817  return false;
7818 
7819  APValue &V = Result.Val;
7820  if (V.getKind() == APValue::Int)
7821  return true;
7822  if (V.getKind() == APValue::LValue)
7824  } else if (ArgType->isFloatingType() || ArgType->isAnyComplexType()) {
7825  return Arg->isEvaluatable(Ctx);
7826  } else if (ArgType->isPointerType() || Arg->isGLValue()) {
7827  LValue LV;
7828  Expr::EvalStatus Status;
7829  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
7830  if ((Arg->isGLValue() ? EvaluateLValue(Arg, LV, Info)
7831  : EvaluatePointer(Arg, LV, Info)) &&
7832  !Status.HasSideEffects)
7834  }
7835 
7836  // Anything else isn't considered to be sufficiently constant.
7837  return false;
7838 }
7839 
7840 /// Retrieves the "underlying object type" of the given expression,
7841 /// as used by __builtin_object_size.
7843  if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
7844  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
7845  return VD->getType();
7846  } else if (const Expr *E = B.get<const Expr*>()) {
7847  if (isa<CompoundLiteralExpr>(E))
7848  return E->getType();
7849  }
7850 
7851  return QualType();
7852 }
7853 
7854 /// A more selective version of E->IgnoreParenCasts for
7855 /// tryEvaluateBuiltinObjectSize. This ignores some casts/parens that serve only
7856 /// to change the type of E.
7857 /// Ex. For E = `(short*)((char*)(&foo))`, returns `&foo`
7858 ///
7859 /// Always returns an RValue with a pointer representation.
7860 static const Expr *ignorePointerCastsAndParens(const Expr *E) {
7861  assert(E->isRValue() && E->getType()->hasPointerRepresentation());
7862 
7863  auto *NoParens = E->IgnoreParens();
7864  auto *Cast = dyn_cast<CastExpr>(NoParens);
7865  if (Cast == nullptr)
7866  return NoParens;
7867 
7868  // We only conservatively allow a few kinds of casts, because this code is
7869  // inherently a simple solution that seeks to support the common case.
7870  auto CastKind = Cast->getCastKind();
7871  if (CastKind != CK_NoOp && CastKind != CK_BitCast &&
7872  CastKind != CK_AddressSpaceConversion)
7873  return NoParens;
7874 
7875  auto *SubExpr = Cast->getSubExpr();
7876  if (!SubExpr->getType()->hasPointerRepresentation() || !SubExpr->isRValue())
7877  return NoParens;
7878  return ignorePointerCastsAndParens(SubExpr);
7879 }
7880 
7881 /// Checks to see if the given LValue's Designator is at the end of the LValue's
7882 /// record layout. e.g.
7883 /// struct { struct { int a, b; } fst, snd; } obj;
7884 /// obj.fst // no
7885 /// obj.snd // yes
7886 /// obj.fst.a // no
7887 /// obj.fst.b // no
7888 /// obj.snd.a // no
7889 /// obj.snd.b // yes
7890 ///
7891 /// Please note: this function is specialized for how __builtin_object_size
7892 /// views "objects".
7893 ///
7894 /// If this encounters an invalid RecordDecl or otherwise cannot determine the
7895 /// correct result, it will always return true.
7896 static bool isDesignatorAtObjectEnd(const ASTContext &Ctx, const LValue &LVal) {
7897  assert(!LVal.Designator.Invalid);
7898 
7899  auto IsLastOrInvalidFieldDecl = [&Ctx](const FieldDecl *FD, bool &Invalid) {
7900  const RecordDecl *Parent = FD->getParent();
7901  Invalid = Parent->isInvalidDecl();
7902  if (Invalid || Parent->isUnion())
7903  return true;
7904  const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(Parent);
7905  return FD->getFieldIndex() + 1 == Layout.getFieldCount();
7906  };
7907 
7908  auto &Base = LVal.getLValueBase();
7909  if (auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<const Expr *>())) {
7910  if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
7911  bool Invalid;
7912  if (!IsLastOrInvalidFieldDecl(FD, Invalid))
7913  return Invalid;
7914  } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(ME->getMemberDecl())) {
7915  for (auto *FD : IFD->chain()) {
7916  bool Invalid;
7917  if (!IsLastOrInvalidFieldDecl(cast<FieldDecl>(FD), Invalid))
7918  return Invalid;
7919  }
7920  }
7921  }
7922 
7923  unsigned I = 0;
7924  QualType BaseType = getType(Base);
7925  if (LVal.Designator.FirstEntryIsAnUnsizedArray) {
7926  // If we don't know the array bound, conservatively assume we're looking at
7927  // the final array element.
7928  ++I;
7929  if (BaseType->isIncompleteArrayType())
7930  BaseType = Ctx.getAsArrayType(BaseType)->getElementType();
7931  else
7932  BaseType = BaseType->castAs<PointerType>()->getPointeeType();
7933  }
7934 
7935  for (unsigned E = LVal.Designator.Entries.size(); I != E; ++I) {
7936  const auto &Entry = LVal.Designator.Entries[I];
7937  if (BaseType->isArrayType()) {
7938  // Because __builtin_object_size treats arrays as objects, we can ignore
7939  // the index iff this is the last array in the Designator.
7940  if (I + 1 == E)
7941  return true;
7942  const auto *CAT = cast<ConstantArrayType>(Ctx.getAsArrayType(BaseType));
7943  uint64_t Index = Entry.ArrayIndex;
7944  if (Index + 1 != CAT->getSize())
7945  return false;
7946  BaseType = CAT->getElementType();
7947  } else if (BaseType->isAnyComplexType()) {
7948  const auto *CT = BaseType->castAs<ComplexType>();
7949  uint64_t Index = Entry.ArrayIndex;
7950  if (Index != 1)
7951  return false;
7952  BaseType = CT->getElementType();
7953  } else if (auto *FD = getAsField(Entry)) {
7954  bool Invalid;
7955  if (!IsLastOrInvalidFieldDecl(FD, Invalid))
7956  return Invalid;
7957  BaseType = FD->getType();
7958  } else {
7959  assert(getAsBaseClass(Entry) && "Expecting cast to a base class");
7960  return false;
7961  }
7962  }
7963  return true;
7964 }
7965 
7966 /// Tests to see if the LValue has a user-specified designator (that isn't
7967 /// necessarily valid). Note that this always returns 'true' if the LValue has
7968 /// an unsized array as its first designator entry, because there's currently no
7969 /// way to tell if the user typed *foo or foo[0].
7970 static bool refersToCompleteObject(const LValue &LVal) {
7971  if (LVal.Designator.Invalid)
7972  return false;
7973 
7974  if (!LVal.Designator.Entries.empty())
7975  return LVal.Designator.isMostDerivedAnUnsizedArray();
7976 
7977  if (!LVal.InvalidBase)
7978  return true;
7979 
7980  // If `E` is a MemberExpr, then the first part of the designator is hiding in
7981  // the LValueBase.
7982  const auto *E = LVal.Base.dyn_cast<const Expr *>();
7983  return !E || !isa<MemberExpr>(E);
7984 }
7985 
7986 /// Attempts to detect a user writing into a piece of memory that's impossible
7987 /// to figure out the size of by just using types.
7988 static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal) {
7989  const SubobjectDesignator &Designator = LVal.Designator;
7990  // Notes:
7991  // - Users can only write off of the end when we have an invalid base. Invalid
7992  // bases imply we don't know where the memory came from.
7993  // - We used to be a bit more aggressive here; we'd only be conservative if
7994  // the array at the end was flexible, or if it had 0 or 1 elements. This
7995  // broke some common standard library extensions (PR30346), but was
7996  // otherwise seemingly fine. It may be useful to reintroduce this behavior
7997  // with some sort of whitelist. OTOH, it seems that GCC is always
7998  // conservative with the last element in structs (if it's an array), so our
7999  // current behavior is more compatible than a whitelisting approach would
8000  // be.
8001  return LVal.InvalidBase &&
8002  Designator.Entries.size() == Designator.MostDerivedPathLength &&
8003  Designator.MostDerivedIsArrayElement &&
8004  isDesignatorAtObjectEnd(Ctx, LVal);
8005 }
8006 
8007 /// Converts the given APInt to CharUnits, assuming the APInt is unsigned.
8008 /// Fails if the conversion would cause loss of precision.
8009 static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int,
8010  CharUnits &Result) {
8012  if (Int.ugt(CharUnitsMax))
8013  return false;
8014  Result = CharUnits::fromQuantity(Int.getZExtValue());
8015  return true;
8016 }
8017 
8018 /// Helper for tryEvaluateBuiltinObjectSize -- Given an LValue, this will
8019 /// determine how many bytes exist from the beginning of the object to either
8020 /// the end of the current subobject, or the end of the object itself, depending
8021 /// on what the LValue looks like + the value of Type.
8022 ///
8023 /// If this returns false, the value of Result is undefined.
8024 static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc,
8025  unsigned Type, const LValue &LVal,
8026  CharUnits &EndOffset) {
8027  bool DetermineForCompleteObject = refersToCompleteObject(LVal);
8028 
8029  auto CheckedHandleSizeof = [&](QualType Ty, CharUnits &Result) {
8030  if (Ty.isNull() || Ty->isIncompleteType() || Ty->isFunctionType())
8031  return false;
8032  return HandleSizeof(Info, ExprLoc, Ty, Result);
8033  };
8034 
8035  // We want to evaluate the size of the entire object. This is a valid fallback
8036  // for when Type=1 and the designator is invalid, because we're asked for an
8037  // upper-bound.
8038  if (!(Type & 1) || LVal.Designator.Invalid || DetermineForCompleteObject) {
8039  // Type=3 wants a lower bound, so we can't fall back to this.
8040  if (Type == 3 && !DetermineForCompleteObject)
8041  return false;
8042 
8043  llvm::APInt APEndOffset;
8044  if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
8045  getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
8046  return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
8047 
8048  if (LVal.InvalidBase)
8049  return false;
8050 
8051  QualType BaseTy = getObjectType(LVal.getLValueBase());
8052  return CheckedHandleSizeof(BaseTy, EndOffset);
8053  }
8054 
8055  // We want to evaluate the size of a subobject.
8056  const SubobjectDesignator &Designator = LVal.Designator;
8057 
8058  // The following is a moderately common idiom in C:
8059  //
8060  // struct Foo { int a; char c[1]; };
8061  // struct Foo *F = (struct Foo *)malloc(sizeof(struct Foo) + strlen(Bar));
8062  // strcpy(&F->c[0], Bar);
8063  //
8064  // In order to not break too much legacy code, we need to support it.
8065  if (isUserWritingOffTheEnd(Info.Ctx, LVal)) {
8066  // If we can resolve this to an alloc_size call, we can hand that back,
8067  // because we know for certain how many bytes there are to write to.
8068  llvm::APInt APEndOffset;
8069  if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
8070  getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
8071  return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
8072 
8073  // If we cannot determine the size of the initial allocation, then we can't
8074  // given an accurate upper-bound. However, we are still able to give
8075  // conservative lower-bounds for Type=3.
8076  if (Type == 1)
8077  return false;
8078  }
8079 
8080  CharUnits BytesPerElem;
8081  if (!CheckedHandleSizeof(Designator.MostDerivedType, BytesPerElem))
8082  return false;
8083 
8084  // According to the GCC documentation, we want the size of the subobject
8085  // denoted by the pointer. But that's not quite right -- what we actually
8086  // want is the size of the immediately-enclosing array, if there is one.
8087  int64_t ElemsRemaining;
8088  if (Designator.MostDerivedIsArrayElement &&
8089  Designator.Entries.size() == Designator.MostDerivedPathLength) {
8090  uint64_t ArraySize = Designator.getMostDerivedArraySize();
8091  uint64_t ArrayIndex = Designator.Entries.back().ArrayIndex;
8092  ElemsRemaining = ArraySize <= ArrayIndex ? 0 : ArraySize - ArrayIndex;
8093  } else {
8094  ElemsRemaining = Designator.isOnePastTheEnd() ? 0 : 1;
8095  }
8096 
8097  EndOffset = LVal.getLValueOffset() + BytesPerElem * ElemsRemaining;
8098  return true;
8099 }
8100 
8101 /// Tries to evaluate the __builtin_object_size for @p E. If successful,
8102 /// returns true and stores the result in @p Size.
8103 ///
8104 /// If @p WasError is non-null, this will report whether the failure to evaluate
8105 /// is to be treated as an Error in IntExprEvaluator.
8106 static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type,
8107  EvalInfo &Info, uint64_t &Size) {
8108  // Determine the denoted object.
8109  LValue LVal;
8110  {
8111  // The operand of __builtin_object_size is never evaluated for side-effects.
8112  // If there are any, but we can determine the pointed-to object anyway, then
8113  // ignore the side-effects.
8114  SpeculativeEvaluationRAII SpeculativeEval(Info);
8115  IgnoreSideEffectsRAII Fold(Info);
8116 
8117  if (E->isGLValue()) {
8118  // It's possible for us to be given GLValues if we're called via
8119  // Expr::tryEvaluateObjectSize.
8120  APValue RVal;
8121  if (!EvaluateAsRValue(Info, E, RVal))
8122  return false;
8123  LVal.setFrom(Info.Ctx, RVal);
8124  } else if (!EvaluatePointer(ignorePointerCastsAndParens(E), LVal, Info,
8125  /*InvalidBaseOK=*/true))
8126  return false;
8127  }
8128 
8129  // If we point to before the start of the object, there are no accessible
8130  // bytes.
8131  if (LVal.getLValueOffset().isNegative()) {
8132  Size = 0;
8133  return true;
8134  }
8135 
8136  CharUnits EndOffset;
8137  if (!determineEndOffset(Info, E->getExprLoc(), Type, LVal, EndOffset))
8138  return false;
8139 
8140  // If we've fallen outside of the end offset, just pretend there's nothing to
8141  // write to/read from.
8142  if (EndOffset <= LVal.getLValueOffset())
8143  Size = 0;
8144  else
8145  Size = (EndOffset - LVal.getLValueOffset()).getQuantity();
8146  return true;
8147 }
8148 
8149 bool IntExprEvaluator::VisitConstantExpr(const ConstantExpr *E) {
8150  llvm::SaveAndRestore<bool> InConstantContext(Info.InConstantContext, true);
8151  return ExprEvaluatorBaseTy::VisitConstantExpr(E);
8152 }
8153 
8154 bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
8155  if (unsigned BuiltinOp = E->getBuiltinCallee())
8156  return VisitBuiltinCallExpr(E, BuiltinOp);
8157 
8158  return ExprEvaluatorBaseTy::VisitCallExpr(E);
8159 }
8160 
8161 bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
8162  unsigned BuiltinOp) {
8163  switch (unsigned BuiltinOp = E->getBuiltinCallee()) {
8164  default:
8165  return ExprEvaluatorBaseTy::VisitCallExpr(E);
8166 
8167  case Builtin::BI__builtin_object_size: {
8168  // The type was checked when we built the expression.
8169  unsigned Type =
8170  E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
8171  assert(Type <= 3 && "unexpected type");
8172 
8173  uint64_t Size;
8174  if (tryEvaluateBuiltinObjectSize(E->getArg(0), Type, Info, Size))
8175  return Success(Size, E);
8176 
8177  if (E->getArg(0)->HasSideEffects(Info.Ctx))
8178  return Success((Type & 2) ? 0 : -1, E);
8179 
8180  // Expression had no side effects, but we couldn't statically determine the
8181  // size of the referenced object.
8182  switch (Info.EvalMode) {
8183  case EvalInfo::EM_ConstantExpression:
8184  case EvalInfo::EM_PotentialConstantExpression:
8185  case EvalInfo::EM_ConstantFold:
8186  case EvalInfo::EM_EvaluateForOverflow:
8187  case EvalInfo::EM_IgnoreSideEffects:
8188  // Leave it to IR generation.
8189  return Error(E);
8190  case EvalInfo::EM_ConstantExpressionUnevaluated:
8191  case EvalInfo::EM_PotentialConstantExpressionUnevaluated:
8192  // Reduce it to a constant now.
8193  return Success((Type & 2) ? 0 : -1, E);
8194  }
8195 
8196  llvm_unreachable("unexpected EvalMode");
8197  }
8198 
8199  case Builtin::BI__builtin_os_log_format_buffer_size: {
8201  analyze_os_log::computeOSLogBufferLayout(Info.Ctx, E, Layout);
8202  return Success(Layout.size().getQuantity(), E);
8203  }
8204 
8205  case Builtin::BI__builtin_bswap16:
8206  case Builtin::BI__builtin_bswap32:
8207  case Builtin::BI__builtin_bswap64: {
8208  APSInt Val;
8209  if (!EvaluateInteger(E->getArg(0), Val, Info))
8210  return false;
8211 
8212  return Success(Val.byteSwap(), E);
8213  }
8214 
8215  case Builtin::BI__builtin_classify_type:
8216  return Success((int)EvaluateBuiltinClassifyType(E, Info.getLangOpts()), E);
8217 
8218  case Builtin::BI__builtin_clrsb:
8219  case Builtin::BI__builtin_clrsbl:
8220  case Builtin::BI__builtin_clrsbll: {
8221  APSInt Val;
8222  if (!EvaluateInteger(E->getArg(0), Val, Info))
8223  return false;
8224 
8225  return Success(Val.getBitWidth() - Val.getMinSignedBits(), E);
8226  }
8227 
8228  case Builtin::BI__builtin_clz:
8229  case Builtin::BI__builtin_clzl:
8230  case Builtin::BI__builtin_clzll:
8231  case Builtin::BI__builtin_clzs: {
8232  APSInt Val;
8233  if (!EvaluateInteger(E->getArg(0), Val, Info))
8234  return false;
8235  if (!Val)
8236  return Error(E);
8237 
8238  return Success(Val.countLeadingZeros(), E);
8239  }
8240 
8241  case Builtin::BI__builtin_constant_p: {
8242  auto Arg = E->getArg(0);
8243  if (EvaluateBuiltinConstantP(Info.Ctx, Arg))
8244  return Success(true, E);
8245  auto ArgTy = Arg->IgnoreImplicit()->getType();
8246  if (!Info.InConstantContext && !Arg->HasSideEffects(Info.Ctx) &&
8247  !ArgTy->isAggregateType() && !ArgTy->isPointerType()) {
8248  // We can delay calculation of __builtin_constant_p until after
8249  // inlining. Note: This diagnostic won't be shown to the user.
8250  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
8251  return false;
8252  }
8253  return Success(false, E);
8254  }
8255 
8256  case Builtin::BI__builtin_ctz:
8257  case Builtin::BI__builtin_ctzl:
8258  case Builtin::BI__builtin_ctzll:
8259  case Builtin::BI__builtin_ctzs: {
8260  APSInt Val;
8261  if (!EvaluateInteger(E->getArg(0), Val, Info))
8262  return false;
8263  if (!Val)
8264  return Error(E);
8265 
8266  return Success(Val.countTrailingZeros(), E);
8267  }
8268 
8269  case Builtin::BI__builtin_eh_return_data_regno: {
8270  int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
8271  Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand);
8272  return Success(Operand, E);
8273  }
8274 
8275  case Builtin::BI__builtin_expect:
8276  return Visit(E->getArg(0));
8277 
8278  case Builtin::BI__builtin_ffs:
8279  case Builtin::BI__builtin_ffsl:
8280  case Builtin::BI__builtin_ffsll: {
8281  APSInt Val;
8282  if (!EvaluateInteger(E->getArg(0), Val, Info))
8283  return false;
8284 
8285  unsigned N = Val.countTrailingZeros();
8286  return Success(N == Val.getBitWidth() ? 0 : N + 1, E);
8287  }
8288 
8289  case Builtin::BI__builtin_fpclassify: {
8290  APFloat Val(0.0);
8291  if (!EvaluateFloat(E->getArg(5), Val, Info))
8292  return false;
8293  unsigned Arg;
8294  switch (Val.getCategory()) {
8295  case APFloat::fcNaN: Arg = 0; break;
8296  case APFloat::fcInfinity: Arg = 1; break;
8297  case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2; break;
8298  case APFloat::fcZero: Arg = 4; break;
8299  }
8300  return Visit(E->getArg(Arg));
8301  }
8302 
8303  case Builtin::BI__builtin_isinf_sign: {
8304  APFloat Val(0.0);
8305  return EvaluateFloat(E->getArg(0), Val, Info) &&
8306  Success(Val.isInfinity() ? (Val.isNegative() ? -1 : 1) : 0, E);
8307  }
8308 
8309  case Builtin::BI__builtin_isinf: {
8310  APFloat Val(0.0);
8311  return EvaluateFloat(E->getArg(0), Val, Info) &&
8312  Success(Val.isInfinity() ? 1 : 0, E);
8313  }
8314 
8315  case Builtin::BI__builtin_isfinite: {
8316  APFloat Val(0.0);
8317  return EvaluateFloat(E->getArg(0), Val, Info) &&
8318  Success(Val.isFinite() ? 1 : 0, E);
8319  }
8320 
8321  case Builtin::BI__builtin_isnan: {
8322  APFloat Val(0.0);
8323  return EvaluateFloat(E->getArg(0), Val, Info) &&
8324  Success(Val.isNaN() ? 1 : 0, E);
8325  }
8326 
8327  case Builtin::BI__builtin_isnormal: {
8328  APFloat Val(0.0);
8329  return EvaluateFloat(E->getArg(0), Val, Info) &&
8330  Success(Val.isNormal() ? 1 : 0, E);
8331  }
8332 
8333  case Builtin::BI__builtin_parity:
8334  case Builtin::BI__builtin_parityl:
8335  case Builtin::BI__builtin_parityll: {
8336  APSInt Val;
8337  if (!EvaluateInteger(E->getArg(0), Val, Info))
8338  return false;
8339 
8340  return Success(Val.countPopulation() % 2, E);
8341  }
8342 
8343  case Builtin::BI__builtin_popcount:
8344  case Builtin::BI__builtin_popcountl:
8345  case Builtin::BI__builtin_popcountll: {
8346  APSInt Val;
8347  if (!EvaluateInteger(E->getArg(0), Val, Info))
8348  return false;
8349 
8350  return Success(Val.countPopulation(), E);
8351  }
8352 
8353  case Builtin::BIstrlen:
8354  case Builtin::BIwcslen:
8355  // A call to strlen is not a constant expression.
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_strlen:
8364  case Builtin::BI__builtin_wcslen: {
8365  // As an extension, we support __builtin_strlen() as a constant expression,
8366  // and support folding strlen() to a constant.
8367  LValue String;
8368  if (!EvaluatePointer(E->getArg(0), String, Info))
8369  return false;
8370 
8371  QualType CharTy = E->getArg(0)->getType()->getPointeeType();
8372 
8373  // Fast path: if it's a string literal, search the string value.
8374  if (const StringLiteral *S = dyn_cast_or_null<StringLiteral>(
8375  String.getLValueBase().dyn_cast<const Expr *>())) {
8376  // The string literal may have embedded null characters. Find the first
8377  // one and truncate there.
8378  StringRef Str = S->getBytes();
8379  int64_t Off = String.Offset.getQuantity();
8380  if (Off >= 0 && (uint64_t)Off <= (uint64_t)Str.size() &&
8381  S->getCharByteWidth() == 1 &&
8382  // FIXME: Add fast-path for wchar_t too.
8383  Info.Ctx.hasSameUnqualifiedType(CharTy, Info.Ctx.CharTy)) {
8384  Str = Str.substr(Off);
8385 
8386  StringRef::size_type Pos = Str.find(0);
8387  if (Pos != StringRef::npos)
8388  Str = Str.substr(0, Pos);
8389 
8390  return Success(Str.size(), E);
8391  }
8392 
8393  // Fall through to slow path to issue appropriate diagnostic.
8394  }
8395 
8396  // Slow path: scan the bytes of the string looking for the terminating 0.
8397  for (uint64_t Strlen = 0; /**/; ++Strlen) {
8398  APValue Char;
8399  if (!handleLValueToRValueConversion(Info, E, CharTy, String, Char) ||
8400  !Char.isInt())
8401  return false;
8402  if (!Char.getInt())
8403  return Success(Strlen, E);
8404  if (!HandleLValueArrayAdjustment(Info, E, String, CharTy, 1))
8405  return false;
8406  }
8407  }
8408 
8409  case Builtin::BIstrcmp:
8410  case Builtin::BIwcscmp:
8411  case Builtin::BIstrncmp:
8412  case Builtin::BIwcsncmp:
8413  case Builtin::BImemcmp:
8414  case Builtin::BIwmemcmp:
8415  // A call to strlen is not a constant expression.
8416  if (Info.getLangOpts().CPlusPlus11)
8417  Info.CCEDiag(E, diag::note_constexpr_invalid_function)
8418  << /*isConstexpr*/0 << /*isConstructor*/0
8419  << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
8420  else
8421  Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
8422  LLVM_FALLTHROUGH;
8423  case Builtin::BI__builtin_strcmp:
8424  case Builtin::BI__builtin_wcscmp:
8425  case Builtin::BI__builtin_strncmp:
8426  case Builtin::BI__builtin_wcsncmp:
8427  case Builtin::BI__builtin_memcmp:
8428  case Builtin::BI__builtin_wmemcmp: {
8429  LValue String1, String2;
8430  if (!EvaluatePointer(E->getArg(0), String1, Info) ||
8431  !EvaluatePointer(E->getArg(1), String2, Info))
8432  return false;
8433 
8434  uint64_t MaxLength = uint64_t(-1);
8435  if (BuiltinOp != Builtin::BIstrcmp &&
8436  BuiltinOp != Builtin::BIwcscmp &&
8437  BuiltinOp != Builtin::BI__builtin_strcmp &&
8438  BuiltinOp != Builtin::BI__builtin_wcscmp) {
8439  APSInt N;
8440  if (!EvaluateInteger(E->getArg(2), N, Info))
8441  return false;
8442  MaxLength = N.getExtValue();
8443  }
8444 
8445  // Empty substrings compare equal by definition.
8446  if (MaxLength == 0u)
8447  return Success(0, E);
8448 
8449  if (!String1.checkNullPointerForFoldAccess(Info, E, AK_Read) ||
8450  !String2.checkNullPointerForFoldAccess(Info, E, AK_Read) ||
8451  String1.Designator.Invalid || String2.Designator.Invalid)
8452  return false;
8453 
8454  QualType CharTy1 = String1.Designator.getType(Info.Ctx);
8455  QualType CharTy2 = String2.Designator.getType(Info.Ctx);
8456 
8457  bool IsRawByte = BuiltinOp == Builtin::BImemcmp ||
8458  BuiltinOp == Builtin::BI__builtin_memcmp;
8459 
8460  assert(IsRawByte ||
8461  (Info.Ctx.hasSameUnqualifiedType(
8462  CharTy1, E->getArg(0)->getType()->getPointeeType()) &&
8463  Info.Ctx.hasSameUnqualifiedType(CharTy1, CharTy2)));
8464 
8465  const auto &ReadCurElems = [&](APValue &Char1, APValue &Char2) {
8466  return handleLValueToRValueConversion(Info, E, CharTy1, String1, Char1) &&
8467  handleLValueToRValueConversion(Info, E, CharTy2, String2, Char2) &&
8468  Char1.isInt() && Char2.isInt();
8469  };
8470  const auto &AdvanceElems = [&] {
8471  return HandleLValueArrayAdjustment(Info, E, String1, CharTy1, 1) &&
8472  HandleLValueArrayAdjustment(Info, E, String2, CharTy2, 1);
8473  };
8474 
8475  if (IsRawByte) {
8476  uint64_t BytesRemaining = MaxLength;
8477  // Pointers to const void may point to objects of incomplete type.
8478  if (CharTy1->isIncompleteType()) {
8479  Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy1;
8480  return false;
8481  }
8482  if (CharTy2->isIncompleteType()) {
8483  Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy2;
8484  return false;
8485  }
8486  uint64_t CharTy1Width{Info.Ctx.getTypeSize(CharTy1)};
8487  CharUnits CharTy1Size = Info.Ctx.toCharUnitsFromBits(CharTy1Width);
8488  // Give up on comparing between elements with disparate widths.
8489  if (CharTy1Size != Info.Ctx.getTypeSizeInChars(CharTy2))
8490  return false;
8491  uint64_t BytesPerElement = CharTy1Size.getQuantity();
8492  assert(BytesRemaining && "BytesRemaining should not be zero: the "
8493  "following loop considers at least one element");
8494  while (true) {
8495  APValue Char1, Char2;
8496  if (!ReadCurElems(Char1, Char2))
8497  return false;
8498  // We have compatible in-memory widths, but a possible type and
8499  // (for `bool`) internal representation mismatch.
8500  // Assuming two's complement representation, including 0 for `false` and
8501  // 1 for `true`, we can check an appropriate number of elements for
8502  // equality even if they are not byte-sized.
8503  APSInt Char1InMem = Char1.getInt().extOrTrunc(CharTy1Width);
8504  APSInt Char2InMem = Char2.getInt().extOrTrunc(CharTy1Width);
8505  if (Char1InMem.ne(Char2InMem)) {
8506  // If the elements are byte-sized, then we can produce a three-way
8507  // comparison result in a straightforward manner.
8508  if (BytesPerElement == 1u) {
8509  // memcmp always compares unsigned chars.
8510  return Success(Char1InMem.ult(Char2InMem) ? -1 : 1, E);
8511  }
8512  // The result is byte-order sensitive, and we have multibyte elements.
8513  // FIXME: We can compare the remaining bytes in the correct order.
8514  return false;
8515  }
8516  if (!AdvanceElems())
8517  return false;
8518  if (BytesRemaining <= BytesPerElement)
8519  break;
8520  BytesRemaining -= BytesPerElement;
8521  }
8522  // Enough elements are equal to account for the memcmp limit.
8523  return Success(0, E);
8524  }
8525 
8526  bool StopAtNull = (BuiltinOp != Builtin::BImemcmp &&
8527  BuiltinOp != Builtin::BIwmemcmp &&
8528  BuiltinOp != Builtin::BI__builtin_memcmp &&
8529  BuiltinOp != Builtin::BI__builtin_wmemcmp);
8530  bool IsWide = BuiltinOp == Builtin::BIwcscmp ||
8531  BuiltinOp == Builtin::BIwcsncmp ||
8532  BuiltinOp == Builtin::BIwmemcmp ||
8533  BuiltinOp == Builtin::BI__builtin_wcscmp ||
8534  BuiltinOp == Builtin::BI__builtin_wcsncmp ||
8535  BuiltinOp == Builtin::BI__builtin_wmemcmp;
8536 
8537  for (; MaxLength; --MaxLength) {
8538  APValue Char1, Char2;
8539  if (!ReadCurElems(Char1, Char2))
8540  return false;
8541  if (Char1.getInt() != Char2.getInt()) {
8542  if (IsWide) // wmemcmp compares with wchar_t signedness.
8543  return Success(Char1.getInt() < Char2.getInt() ? -1 : 1, E);
8544  // memcmp always compares unsigned chars.
8545  return Success(Char1.getInt().ult(Char2.getInt()) ? -1 : 1, E);
8546  }
8547  if (StopAtNull && !Char1.getInt())
8548  return Success(0, E);
8549  assert(!(StopAtNull && !Char2.getInt()));
8550  if (!AdvanceElems())
8551  return false;
8552  }
8553  // We hit the strncmp / memcmp limit.
8554  return Success(0, E);
8555  }
8556 
8557  case Builtin::BI__atomic_always_lock_free:
8558  case Builtin::BI__atomic_is_lock_free:
8559  case Builtin::BI__c11_atomic_is_lock_free: {
8560  APSInt SizeVal;
8561  if (!EvaluateInteger(E->getArg(0), SizeVal, Info))
8562  return false;
8563 
8564  // For __atomic_is_lock_free(sizeof(_Atomic(T))), if the size is a power
8565  // of two less than the maximum inline atomic width, we know it is
8566  // lock-free. If the size isn't a power of two, or greater than the
8567  // maximum alignment where we promote atomics, we know it is not lock-free
8568  // (at least not in the sense of atomic_is_lock_free). Otherwise,
8569  // the answer can only be determined at runtime; for example, 16-byte
8570  // atomics have lock-free implementations on some, but not all,
8571  // x86-64 processors.
8572 
8573  // Check power-of-two.
8574  CharUnits Size = CharUnits::fromQuantity(SizeVal.getZExtValue());
8575  if (Size.isPowerOfTwo()) {
8576  // Check against inlining width.
8577  unsigned InlineWidthBits =
8578  Info.Ctx.getTargetInfo().getMaxAtomicInlineWidth();
8579  if (Size <= Info.Ctx.toCharUnitsFromBits(InlineWidthBits)) {
8580  if (BuiltinOp == Builtin::BI__c11_atomic_is_lock_free ||
8581  Size == CharUnits::One() ||
8582  E->getArg(1)->isNullPointerConstant(Info.Ctx,
8584  // OK, we will inline appropriately-aligned operations of this size,
8585  // and _Atomic(T) is appropriately-aligned.
8586  return Success(1, E);
8587 
8588  QualType PointeeType = E->getArg(1)->IgnoreImpCasts()->getType()->
8589  castAs<PointerType>()->getPointeeType();
8590  if (!PointeeType->isIncompleteType() &&
8591  Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) {
8592  // OK, we will inline operations on this object.
8593  return Success(1, E);
8594  }
8595  }
8596  }
8597 
8598  return BuiltinOp == Builtin::BI__atomic_always_lock_free ?
8599  Success(0, E) : Error(E);
8600  }
8601  case Builtin::BIomp_is_initial_device:
8602  // We can decide statically which value the runtime would return if called.
8603  return Success(Info.getLangOpts().OpenMPIsDevice ? 0 : 1, E);
8604  case Builtin::BI__builtin_add_overflow:
8605  case Builtin::BI__builtin_sub_overflow:
8606  case Builtin::BI__builtin_mul_overflow:
8607  case Builtin::BI__builtin_sadd_overflow:
8608  case Builtin::BI__builtin_uadd_overflow:
8609  case Builtin::BI__builtin_uaddl_overflow:
8610  case Builtin::BI__builtin_uaddll_overflow:
8611  case Builtin::BI__builtin_usub_overflow:
8612  case Builtin::BI__builtin_usubl_overflow:
8613  case Builtin::BI__builtin_usubll_overflow:
8614  case Builtin::BI__builtin_umul_overflow:
8615  case Builtin::BI__builtin_umull_overflow:
8616  case Builtin::BI__builtin_umulll_overflow:
8617  case Builtin::BI__builtin_saddl_overflow:
8618  case Builtin::BI__builtin_saddll_overflow:
8619  case Builtin::BI__builtin_ssub_overflow:
8620  case Builtin::BI__builtin_ssubl_overflow:
8621  case Builtin::BI__builtin_ssubll_overflow:
8622  case Builtin::BI__builtin_smul_overflow:
8623  case Builtin::BI__builtin_smull_overflow:
8624  case Builtin::BI__builtin_smulll_overflow: {
8625  LValue ResultLValue;
8626  APSInt LHS, RHS;
8627 
8628  QualType ResultType = E->getArg(2)->getType()->getPointeeType();
8629  if (!EvaluateInteger(E->getArg(0), LHS, Info) ||
8630  !EvaluateInteger(E->getArg(1), RHS, Info) ||
8631  !EvaluatePointer(E->getArg(2), ResultLValue, Info))
8632  return false;
8633 
8634  APSInt Result;
8635  bool DidOverflow = false;
8636 
8637  // If the types don't have to match, enlarge all 3 to the largest of them.
8638  if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
8639  BuiltinOp == Builtin::BI__builtin_sub_overflow ||
8640  BuiltinOp == Builtin::BI__builtin_mul_overflow) {
8641  bool IsSigned = LHS.isSigned() || RHS.isSigned() ||
8642  ResultType->isSignedIntegerOrEnumerationType();
8643  bool AllSigned = LHS.isSigned() && RHS.isSigned() &&
8644  ResultType->isSignedIntegerOrEnumerationType();
8645  uint64_t LHSSize = LHS.getBitWidth();
8646  uint64_t RHSSize = RHS.getBitWidth();
8647  uint64_t ResultSize = Info.Ctx.getTypeSize(ResultType);
8648  uint64_t MaxBits = std::max(std::max(LHSSize, RHSSize), ResultSize);
8649 
8650  // Add an additional bit if the signedness isn't uniformly agreed to. We
8651  // could do this ONLY if there is a signed and an unsigned that both have
8652  // MaxBits, but the code to check that is pretty nasty. The issue will be
8653  // caught in the shrink-to-result later anyway.
8654  if (IsSigned && !AllSigned)
8655  ++MaxBits;
8656 
8657  LHS = APSInt(IsSigned ? LHS.sextOrSelf(MaxBits) : LHS.zextOrSelf(MaxBits),
8658  !IsSigned);
8659  RHS = APSInt(IsSigned ? RHS.sextOrSelf(MaxBits) : RHS.zextOrSelf(MaxBits),
8660  !IsSigned);
8661  Result = APSInt(MaxBits, !IsSigned);
8662  }
8663 
8664  // Find largest int.
8665  switch (BuiltinOp) {
8666  default:
8667  llvm_unreachable("Invalid value for BuiltinOp");
8668  case Builtin::BI__builtin_add_overflow:
8669  case Builtin::BI__builtin_sadd_overflow:
8670  case Builtin::BI__builtin_saddl_overflow:
8671  case Builtin::BI__builtin_saddll_overflow:
8672  case Builtin::BI__builtin_uadd_overflow:
8673  case Builtin::BI__builtin_uaddl_overflow:
8674  case Builtin::BI__builtin_uaddll_overflow:
8675  Result = LHS.isSigned() ? LHS.sadd_ov(RHS, DidOverflow)
8676  : LHS.uadd_ov(RHS, DidOverflow);
8677  break;
8678  case Builtin::BI__builtin_sub_overflow:
8679  case Builtin::BI__builtin_ssub_overflow:
8680  case Builtin::BI__builtin_ssubl_overflow:
8681  case Builtin::BI__builtin_ssubll_overflow:
8682  case Builtin::BI__builtin_usub_overflow:
8683  case Builtin::BI__builtin_usubl_overflow:
8684  case Builtin::BI__builtin_usubll_overflow:
8685  Result = LHS.isSigned() ? LHS.ssub_ov(RHS, DidOverflow)
8686  : LHS.usub_ov(RHS, DidOverflow);
8687  break;
8688  case Builtin::BI__builtin_mul_overflow:
8689  case Builtin::BI__builtin_smul_overflow:
8690  case Builtin::BI__builtin_smull_overflow:
8691  case Builtin::BI__builtin_smulll_overflow:
8692  case Builtin::BI__builtin_umul_overflow:
8693  case Builtin::BI__builtin_umull_overflow:
8694  case Builtin::BI__builtin_umulll_overflow:
8695  Result = LHS.isSigned() ? LHS.smul_ov(RHS, DidOverflow)
8696  : LHS.umul_ov(RHS, DidOverflow);
8697  break;
8698  }
8699 
8700  // In the case where multiple sizes are allowed, truncate and see if
8701  // the values are the same.
8702  if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
8703  BuiltinOp == Builtin::BI__builtin_sub_overflow ||
8704  BuiltinOp == Builtin::BI__builtin_mul_overflow) {
8705  // APSInt doesn't have a TruncOrSelf, so we use extOrTrunc instead,
8706  // since it will give us the behavior of a TruncOrSelf in the case where
8707  // its parameter <= its size. We previously set Result to be at least the
8708  // type-size of the result, so getTypeSize(ResultType) <= Result.BitWidth
8709  // will work exactly like TruncOrSelf.
8710  APSInt Temp = Result.extOrTrunc(Info.Ctx.getTypeSize(ResultType));
8711  Temp.setIsSigned(ResultType->isSignedIntegerOrEnumerationType());
8712 
8713  if (!APSInt::isSameValue(Temp, Result))
8714  DidOverflow = true;
8715  Result = Temp;
8716  }
8717 
8718  APValue APV{Result};
8719  if (!handleAssignment(Info, E, ResultLValue, ResultType, APV))
8720  return false;
8721  return Success(DidOverflow, E);
8722  }
8723  }
8724 }
8725 
8726 /// Determine whether this is a pointer past the end of the complete
8727 /// object referred to by the lvalue.
8729  const LValue &LV) {
8730  // A null pointer can be viewed as being "past the end" but we don't
8731  // choose to look at it that way here.
8732  if (!LV.getLValueBase())
8733  return false;
8734 
8735  // If the designator is valid and refers to a subobject, we're not pointing
8736  // past the end.
8737  if (!LV.getLValueDesignator().Invalid &&
8738  !LV.getLValueDesignator().isOnePastTheEnd())
8739  return false;
8740 
8741  // A pointer to an incomplete type might be past-the-end if the type's size is
8742  // zero. We cannot tell because the type is incomplete.
8743  QualType Ty = getType(LV.getLValueBase());
8744  if (Ty->isIncompleteType())
8745  return true;
8746 
8747  // We're a past-the-end pointer if we point to the byte after the object,
8748  // no matter what our type or path is.
8749  auto Size = Ctx.getTypeSizeInChars(Ty);
8750  return LV.getLValueOffset() == Size;
8751 }
8752 
8753 namespace {
8754 
8755 /// Data recursive integer evaluator of certain binary operators.
8756 ///
8757 /// We use a data recursive algorithm for binary operators so that we are able
8758 /// to handle extreme cases of chained binary operators without causing stack
8759 /// overflow.
8760 class DataRecursiveIntBinOpEvaluator {
8761  struct EvalResult {
8762  APValue Val;
8763  bool Failed;
8764 
8765  EvalResult() : Failed(false) { }
8766 
8767  void swap(EvalResult &RHS) {
8768  Val.swap(RHS.Val);
8769  Failed = RHS.Failed;
8770  RHS.Failed = false;
8771  }
8772  };
8773 
8774  struct Job {
8775  const Expr *E;
8776  EvalResult LHSResult; // meaningful only for binary operator expression.
8777  enum { AnyExprKind, BinOpKind, BinOpVisitedLHSKind } Kind;
8778 
8779  Job() = default;
8780  Job(Job &&) = default;
8781 
8782  void startSpeculativeEval(EvalInfo &Info) {
8783  SpecEvalRAII = SpeculativeEvaluationRAII(Info);
8784  }
8785 
8786  private:
8787  SpeculativeEvaluationRAII SpecEvalRAII;
8788  };
8789 
8790  SmallVector<Job, 16> Queue;
8791 
8792  IntExprEvaluator &IntEval;
8793  EvalInfo &Info;
8794  APValue &FinalResult;
8795 
8796 public:
8797  DataRecursiveIntBinOpEvaluator(IntExprEvaluator &IntEval, APValue &Result)
8798  : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { }
8799 
8800  /// True if \param E is a binary operator that we are going to handle
8801  /// data recursively.
8802  /// We handle binary operators that are comma, logical, or that have operands
8803  /// with integral or enumeration type.
8804  static bool shouldEnqueue(const BinaryOperator *E) {
8805  return E->getOpcode() == BO_Comma || E->isLogicalOp() ||
8806  (E->isRValue() && E->getType()->isIntegralOrEnumerationType() &&
8809  }
8810 
8811  bool Traverse(const BinaryOperator *E) {
8812  enqueue(E);
8813  EvalResult PrevResult;
8814  while (!Queue.empty())
8815  process(PrevResult);
8816 
8817  if (PrevResult.Failed) return false;
8818 
8819  FinalResult.swap(PrevResult.Val);
8820  return true;
8821  }
8822 
8823 private:
8824  bool Success(uint64_t Value, const Expr *E, APValue &Result) {
8825  return IntEval.Success(Value, E, Result);
8826  }
8827  bool Success(const APSInt &Value, const Expr *E, APValue &Result) {
8828  return IntEval.Success(Value, E, Result);
8829  }
8830  bool Error(const Expr *E) {
8831  return IntEval.Error(E);
8832  }
8833  bool Error(const Expr *E, diag::kind D) {
8834  return IntEval.Error(E, D);
8835  }
8836 
8837  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
8838  return Info.CCEDiag(E, D);
8839  }
8840 
8841  // Returns true if visiting the RHS is necessary, false otherwise.
8842  bool VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
8843  bool &SuppressRHSDiags);
8844 
8845  bool VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
8846  const BinaryOperator *E, APValue &Result);
8847 
8848  void EvaluateExpr(const Expr *E, EvalResult &Result) {
8849  Result.Failed = !Evaluate(Result.Val, Info, E);
8850  if (Result.Failed)
8851  Result.Val = APValue();
8852  }
8853 
8854  void process(EvalResult &Result);
8855 
8856  void enqueue(const Expr *E) {
8857  E = E->IgnoreParens();
8858  Queue.resize(Queue.size()+1);
8859  Queue.back().E = E;
8860  Queue.back().Kind = Job::AnyExprKind;
8861  }
8862 };
8863 
8864 }
8865 
8866 bool DataRecursiveIntBinOpEvaluator::
8867  VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
8868  bool &SuppressRHSDiags) {
8869  if (E->getOpcode() == BO_Comma) {
8870  // Ignore LHS but note if we could not evaluate it.
8871  if (LHSResult.Failed)
8872  return Info.noteSideEffect();
8873  return true;
8874  }
8875 
8876  if (E->isLogicalOp()) {
8877  bool LHSAsBool;
8878  if (!LHSResult.Failed && HandleConversionToBool(LHSResult.Val, LHSAsBool)) {
8879  // We were able to evaluate the LHS, see if we can get away with not
8880  // evaluating the RHS: 0 && X -> 0, 1 || X -> 1
8881  if (LHSAsBool == (E->getOpcode() == BO_LOr)) {
8882  Success(LHSAsBool, E, LHSResult.Val);
8883  return false; // Ignore RHS
8884  }
8885  } else {
8886  LHSResult.Failed = true;
8887 
8888  // Since we weren't able to evaluate the left hand side, it
8889  // might have had side effects.
8890  if (!Info.noteSideEffect())
8891  return false;
8892 
8893  // We can't evaluate the LHS; however, sometimes the result
8894  // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
8895  // Don't ignore RHS and suppress diagnostics from this arm.
8896  SuppressRHSDiags = true;
8897  }
8898 
8899  return true;
8900  }
8901 
8902  assert(E->getLHS()->getType()->isIntegralOrEnumerationType() &&
8904 
8905  if (LHSResult.Failed && !Info.noteFailure())
8906  return false; // Ignore RHS;
8907 
8908  return true;
8909 }
8910 
8911 static void addOrSubLValueAsInteger(APValue &LVal, const APSInt &Index,
8912  bool IsSub) {
8913  // Compute the new offset in the appropriate width, wrapping at 64 bits.
8914  // FIXME: When compiling for a 32-bit target, we should use 32-bit
8915  // offsets.
8916  assert(!LVal.hasLValuePath() && "have designator for integer lvalue");
8917  CharUnits &Offset = LVal.getLValueOffset();
8918  uint64_t Offset64 = Offset.getQuantity();
8919  uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
8920  Offset = CharUnits::fromQuantity(IsSub ? Offset64 - Index64
8921  : Offset64 + Index64);
8922 }
8923 
8924 bool DataRecursiveIntBinOpEvaluator::
8925  VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
8926  const BinaryOperator *E, APValue &Result) {
8927  if (E->getOpcode() == BO_Comma) {
8928  if (RHSResult.Failed)
8929  return false;
8930  Result = RHSResult.Val;
8931  return true;
8932  }
8933 
8934  if (E->isLogicalOp()) {
8935  bool lhsResult, rhsResult;
8936  bool LHSIsOK = HandleConversionToBool(LHSResult.Val, lhsResult);
8937  bool RHSIsOK = HandleConversionToBool(RHSResult.Val, rhsResult);
8938 
8939  if (LHSIsOK) {
8940  if (RHSIsOK) {
8941  if (E->getOpcode() == BO_LOr)
8942  return Success(lhsResult || rhsResult, E, Result);
8943  else
8944  return Success(lhsResult && rhsResult, E, Result);
8945  }
8946  } else {
8947  if (RHSIsOK) {
8948  // We can't evaluate the LHS; however, sometimes the result
8949  // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
8950  if (rhsResult == (E->getOpcode() == BO_LOr))
8951  return Success(rhsResult, E, Result);
8952  }
8953  }
8954 
8955  return false;
8956  }
8957 
8958  assert(E->getLHS()->getType()->isIntegralOrEnumerationType() &&
8960 
8961  if (LHSResult.Failed || RHSResult.Failed)
8962  return false;
8963 
8964  const APValue &LHSVal = LHSResult.Val;
8965  const APValue &RHSVal = RHSResult.Val;
8966 
8967  // Handle cases like (unsigned long)&a + 4.
8968  if (E->isAdditiveOp() && LHSVal.isLValue() && RHSVal.isInt()) {
8969  Result = LHSVal;
8970  addOrSubLValueAsInteger(Result, RHSVal.getInt(), E->getOpcode() == BO_Sub);
8971  return true;
8972  }
8973 
8974  // Handle cases like 4 + (unsigned long)&a
8975  if (E->getOpcode() == BO_Add &&
8976  RHSVal.isLValue() && LHSVal.isInt()) {
8977  Result = RHSVal;
8978  addOrSubLValueAsInteger(Result, LHSVal.getInt(), /*IsSub*/false);
8979  return true;
8980  }
8981 
8982  if (E->getOpcode() == BO_Sub && LHSVal.isLValue() && RHSVal.isLValue()) {
8983  // Handle (intptr_t)&&A - (intptr_t)&&B.
8984  if (!LHSVal.getLValueOffset().isZero() ||
8985  !RHSVal.getLValueOffset().isZero())
8986  return false;
8987  const Expr *LHSExpr = LHSVal.getLValueBase().dyn_cast<const Expr*>();
8988  const Expr *RHSExpr = RHSVal.getLValueBase().dyn_cast<const Expr*>();
8989  if (!LHSExpr || !RHSExpr)
8990  return false;
8991  const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
8992  const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
8993  if (!LHSAddrExpr || !RHSAddrExpr)
8994  return false;
8995  // Make sure both labels come from the same function.
8996  if (LHSAddrExpr->getLabel()->getDeclContext() !=
8997  RHSAddrExpr->getLabel()->getDeclContext())
8998  return false;
8999  Result = APValue(LHSAddrExpr, RHSAddrExpr);
9000  return true;
9001  }
9002 
9003  // All the remaining cases expect both operands to be an integer
9004  if (!LHSVal.isInt() || !RHSVal.isInt())
9005  return Error(E);
9006 
9007  // Set up the width and signedness manually, in case it can't be deduced
9008  // from the operation we're performing.
9009  // FIXME: Don't do this in the cases where we can deduce it.
9010  APSInt Value(Info.Ctx.getIntWidth(E->getType()),
9012  if (!handleIntIntBinOp(Info, E, LHSVal.getInt(), E->getOpcode(),
9013  RHSVal.getInt(), Value))
9014  return false;
9015  return Success(Value, E, Result);
9016 }
9017 
9018 void DataRecursiveIntBinOpEvaluator::process(EvalResult &Result) {
9019  Job &job = Queue.back();
9020 
9021  switch (job.Kind) {
9022  case Job::AnyExprKind: {
9023  if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(job.E)) {
9024  if (shouldEnqueue(Bop)) {
9025  job.Kind = Job::BinOpKind;
9026  enqueue(Bop->getLHS());
9027  return;
9028  }
9029  }
9030 
9031  EvaluateExpr(job.E, Result);
9032  Queue.pop_back();
9033  return;
9034  }
9035 
9036  case Job::BinOpKind: {
9037  const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
9038  bool SuppressRHSDiags = false;
9039  if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) {
9040  Queue.pop_back();
9041  return;
9042  }
9043  if (SuppressRHSDiags)
9044  job.startSpeculativeEval(Info);
9045  job.LHSResult.swap(Result);
9046  job.Kind = Job::BinOpVisitedLHSKind;
9047  enqueue(Bop->getRHS());
9048  return;
9049  }
9050 
9051  case Job::BinOpVisitedLHSKind: {
9052  const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
9053  EvalResult RHS;
9054  RHS.swap(Result);
9055  Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val);
9056  Queue.pop_back();
9057  return;
9058  }
9059  }
9060 
9061  llvm_unreachable("Invalid Job::Kind!");
9062 }
9063 
9064 namespace {
9065 /// Used when we determine that we should fail, but can keep evaluating prior to
9066 /// noting that we had a failure.
9067 class DelayedNoteFailureRAII {
9068  EvalInfo &Info;
9069  bool NoteFailure;
9070 
9071 public:
9072  DelayedNoteFailureRAII(EvalInfo &Info, bool NoteFailure = true)
9073  : Info(Info), NoteFailure(NoteFailure) {}
9074  ~DelayedNoteFailureRAII() {
9075  if (NoteFailure) {
9076  bool ContinueAfterFailure = Info.noteFailure();
9077  (void)ContinueAfterFailure;
9078  assert(ContinueAfterFailure &&
9079  "Shouldn't have kept evaluating on failure.");
9080  }
9081  }
9082 };
9083 }
9084 
9085 template <class SuccessCB, class AfterCB>
9086 static bool
9088  SuccessCB &&Success, AfterCB &&DoAfter) {
9089  assert(E->isComparisonOp() && "expected comparison operator");
9090  assert((E->getOpcode() == BO_Cmp ||
9092  "unsupported binary expression evaluation");
9093  auto Error = [&](const Expr *E) {
9094  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
9095  return false;
9096  };
9097 
9098  using CCR = ComparisonCategoryResult;
9099  bool IsRelational = E->isRelationalOp();
9100  bool IsEquality = E->isEqualityOp();
9101  if (E->getOpcode() == BO_Cmp) {
9102  const ComparisonCategoryInfo &CmpInfo =
9103  Info.Ctx.CompCategories.getInfoForType(E->getType());
9104  IsRelational = CmpInfo.isOrdered();
9105  IsEquality = CmpInfo.isEquality();
9106  }
9107 
9108  QualType LHSTy = E->getLHS()->getType();
9109  QualType RHSTy = E->getRHS()->getType();
9110 
9111  if (LHSTy->isIntegralOrEnumerationType() &&
9112  RHSTy->isIntegralOrEnumerationType()) {
9113  APSInt LHS, RHS;
9114  bool LHSOK = EvaluateInteger(E->getLHS(), LHS, Info);
9115  if (!LHSOK && !Info.noteFailure())
9116  return false;
9117  if (!EvaluateInteger(E->getRHS(), RHS, Info) || !LHSOK)
9118  return false;
9119  if (LHS < RHS)
9120  return Success(CCR::Less, E);
9121  if (LHS > RHS)
9122  return Success(CCR::Greater, E);
9123  return Success(CCR::Equal, E);
9124  }
9125 
9126  if (LHSTy->isAnyComplexType() || RHSTy->isAnyComplexType()) {
9127  ComplexValue LHS, RHS;
9128  bool LHSOK;
9129  if (E->isAssignmentOp()) {
9130  LValue LV;
9131  EvaluateLValue(E->getLHS(), LV, Info);
9132  LHSOK = false;
9133  } else if (LHSTy->isRealFloatingType()) {
9134  LHSOK = EvaluateFloat(E->getLHS(), LHS.FloatReal, Info);
9135  if (LHSOK) {
9136  LHS.makeComplexFloat();
9137  LHS.FloatImag = APFloat(LHS.FloatReal.getSemantics());
9138  }
9139  } else {
9140  LHSOK = EvaluateComplex(E->getLHS(), LHS, Info);
9141  }
9142  if (!LHSOK && !Info.noteFailure())
9143  return false;
9144 
9145  if (E->getRHS()->getType()->isRealFloatingType()) {
9146  if (!EvaluateFloat(E->getRHS(), RHS.FloatReal, Info) || !LHSOK)
9147  return false;
9148  RHS.makeComplexFloat();
9149  RHS.FloatImag = APFloat(RHS.FloatReal.getSemantics());
9150  } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
9151  return false;
9152 
9153  if (LHS.isComplexFloat()) {
9154  APFloat::cmpResult CR_r =
9155  LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal());
9156  APFloat::cmpResult CR_i =
9157  LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag());
9158  bool IsEqual = CR_r == APFloat::cmpEqual && CR_i == APFloat::cmpEqual;
9159  return Success(IsEqual ? CCR::Equal : CCR::Nonequal, E);
9160  } else {
9161  assert(IsEquality && "invalid complex comparison");
9162  bool IsEqual = LHS.getComplexIntReal() == RHS.getComplexIntReal() &&
9163  LHS.getComplexIntImag() == RHS.getComplexIntImag();
9164  return Success(IsEqual ? CCR::Equal : CCR::Nonequal, E);
9165  }
9166  }
9167 
9168  if (LHSTy->isRealFloatingType() &&
9169  RHSTy->isRealFloatingType()) {
9170  APFloat RHS(0.0), LHS(0.0);
9171 
9172  bool LHSOK = EvaluateFloat(E->getRHS(), RHS, Info);
9173  if (!LHSOK && !Info.noteFailure())
9174  return false;
9175 
9176  if (!EvaluateFloat(E->getLHS(), LHS, Info) || !LHSOK)
9177  return false;
9178 
9179  assert(E->isComparisonOp() && "Invalid binary operator!");
9180  auto GetCmpRes = [&]() {
9181  switch (LHS.compare(RHS)) {
9182  case APFloat::cmpEqual:
9183  return CCR::Equal;
9184  case APFloat::cmpLessThan:
9185  return CCR::Less;
9186  case APFloat::cmpGreaterThan:
9187  return CCR::Greater;
9188  case APFloat::cmpUnordered:
9189  return CCR::Unordered;
9190  }
9191  llvm_unreachable("Unrecognised APFloat::cmpResult enum");
9192  };
9193  return Success(GetCmpRes(), E);
9194  }
9195 
9196  if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
9197  LValue LHSValue, RHSValue;
9198 
9199  bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info);
9200  if (!LHSOK && !Info.noteFailure())
9201  return false;
9202 
9203  if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK)
9204  return false;
9205 
9206  // Reject differing bases from the normal codepath; we special-case
9207  // comparisons to null.
9208  if (!HasSameBase(LHSValue, RHSValue)) {
9209  // Inequalities and subtractions between unrelated pointers have
9210  // unspecified or undefined behavior.
9211  if (!IsEquality)
9212  return Error(E);
9213  // A constant address may compare equal to the address of a symbol.
9214  // The one exception is that address of an object cannot compare equal
9215  // to a null pointer constant.
9216  if ((!LHSValue.Base && !LHSValue.Offset.isZero()) ||
9217  (!RHSValue.Base && !RHSValue.Offset.isZero()))
9218  return Error(E);
9219  // It's implementation-defined whether distinct literals will have
9220  // distinct addresses. In clang, the result of such a comparison is
9221  // unspecified, so it is not a constant expression. However, we do know
9222  // that the address of a literal will be non-null.
9223  if ((IsLiteralLValue(LHSValue) || IsLiteralLValue(RHSValue)) &&
9224  LHSValue.Base && RHSValue.Base)
9225  return Error(E);
9226  // We can't tell whether weak symbols will end up pointing to the same
9227  // object.
9228  if (IsWeakLValue(LHSValue) || IsWeakLValue(RHSValue))
9229  return Error(E);
9230  // We can't compare the address of the start of one object with the
9231  // past-the-end address of another object, per C++ DR1652.
9232  if ((LHSValue.Base && LHSValue.Offset.isZero() &&
9233  isOnePastTheEndOfCompleteObject(Info.Ctx, RHSValue)) ||
9234  (RHSValue.Base && RHSValue.Offset.isZero() &&
9235  isOnePastTheEndOfCompleteObject(Info.Ctx, LHSValue)))
9236  return Error(E);
9237  // We can't tell whether an object is at the same address as another
9238  // zero sized object.
9239  if ((RHSValue.Base && isZeroSized(LHSValue)) ||
9240  (LHSValue.Base && isZeroSized(RHSValue)))
9241  return Error(E);
9242  return Success(CCR::Nonequal, E);
9243  }
9244 
9245  const CharUnits &LHSOffset = LHSValue.getLValueOffset();
9246  const CharUnits &RHSOffset = RHSValue.getLValueOffset();
9247 
9248  SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
9249  SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
9250 
9251  // C++11 [expr.rel]p3:
9252  // Pointers to void (after pointer conversions) can be compared, with a
9253  // result defined as follows: If both pointers represent the same
9254  // address or are both the null pointer value, the result is true if the
9255  // operator is <= or >= and false otherwise; otherwise the result is
9256  // unspecified.
9257  // We interpret this as applying to pointers to *cv* void.
9258  if (LHSTy->isVoidPointerType() && LHSOffset != RHSOffset && IsRelational)
9259  Info.CCEDiag(E, diag::note_constexpr_void_comparison);
9260 
9261  // C++11 [expr.rel]p2:
9262  // - If two pointers point to non-static data members of the same object,
9263  // or to subobjects or array elements fo such members, recursively, the
9264  // pointer to the later declared member compares greater provided the
9265  // two members have the same access control and provided their class is
9266  // not a union.
9267  // [...]
9268  // - Otherwise pointer comparisons are unspecified.
9269  if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && IsRelational) {
9270  bool WasArrayIndex;
9271  unsigned Mismatch = FindDesignatorMismatch(
9272  getType(LHSValue.Base), LHSDesignator, RHSDesignator, WasArrayIndex);
9273  // At the point where the designators diverge, the comparison has a
9274  // specified value if:
9275  // - we are comparing array indices
9276  // - we are comparing fields of a union, or fields with the same access
9277  // Otherwise, the result is unspecified and thus the comparison is not a
9278  // constant expression.
9279  if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() &&
9280  Mismatch < RHSDesignator.Entries.size()) {
9281  const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]);
9282  const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]);
9283  if (!LF && !RF)
9284  Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes);
9285  else if (!LF)
9286  Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
9287  << getAsBaseClass(LHSDesignator.Entries[Mismatch])
9288  << RF->getParent() << RF;
9289  else if (!RF)
9290  Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
9291  << getAsBaseClass(RHSDesignator.Entries[Mismatch])
9292  << LF->getParent() << LF;
9293  else if (!LF->getParent()->isUnion() &&
9294  LF->getAccess() != RF->getAccess())
9295  Info.CCEDiag(E,
9296  diag::note_constexpr_pointer_comparison_differing_access)
9297  << LF << LF->getAccess() << RF << RF->getAccess()
9298  << LF->getParent();
9299  }
9300  }
9301 
9302  // The comparison here must be unsigned, and performed with the same
9303  // width as the pointer.
9304  unsigned PtrSize = Info.Ctx.getTypeSize(LHSTy);
9305  uint64_t CompareLHS = LHSOffset.getQuantity();
9306  uint64_t CompareRHS = RHSOffset.getQuantity();
9307  assert(PtrSize <= 64 && "Unexpected pointer width");
9308  uint64_t Mask = ~0ULL >> (64 - PtrSize);
9309  CompareLHS &= Mask;
9310  CompareRHS &= Mask;
9311 
9312  // If there is a base and this is a relational operator, we can only
9313  // compare pointers within the object in question; otherwise, the result
9314  // depends on where the object is located in memory.
9315  if (!LHSValue.Base.isNull() && IsRelational) {
9316  QualType BaseTy = getType(LHSValue.Base);
9317  if (BaseTy->isIncompleteType())
9318  return Error(E);
9319  CharUnits Size = Info.Ctx.getTypeSizeInChars(BaseTy);
9320  uint64_t OffsetLimit = Size.getQuantity();
9321  if (CompareLHS > OffsetLimit || CompareRHS > OffsetLimit)
9322  return Error(E);
9323  }
9324 
9325  if (CompareLHS < CompareRHS)
9326  return Success(CCR::Less, E);
9327  if (CompareLHS > CompareRHS)
9328  return Success(CCR::Greater, E);
9329  return Success(CCR::Equal, E);
9330  }
9331 
9332  if (LHSTy->isMemberPointerType()) {
9333  assert(IsEquality && "unexpected member pointer operation");
9334  assert(RHSTy->isMemberPointerType() && "invalid comparison");
9335 
9336  MemberPtr LHSValue, RHSValue;
9337 
9338  bool LHSOK = EvaluateMemberPointer(E->getLHS(), LHSValue, Info);
9339  if (!LHSOK && !Info.noteFailure())
9340  return false;
9341 
9342  if (!EvaluateMemberPointer(E->getRHS(), RHSValue, Info) || !LHSOK)
9343  return false;
9344 
9345  // C++11 [expr.eq]p2:
9346  // If both operands are null, they compare equal. Otherwise if only one is
9347  // null, they compare unequal.
9348  if (!LHSValue.getDecl() || !RHSValue.getDecl()) {
9349  bool Equal = !LHSValue.getDecl() && !RHSValue.getDecl();
9350  return Success(Equal ? CCR::Equal : CCR::Nonequal, E);
9351  }
9352 
9353  // Otherwise if either is a pointer to a virtual member function, the
9354  // result is unspecified.
9355  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl()))
9356  if (MD->isVirtual())
9357  Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
9358  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl()))
9359  if (MD->isVirtual())
9360  Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
9361 
9362  // Otherwise they compare equal if and only if they would refer to the
9363  // same member of the same most derived object or the same subobject if
9364  // they were dereferenced with a hypothetical object of the associated
9365  // class type.
9366  bool Equal = LHSValue == RHSValue;
9367  return Success(Equal ? CCR::Equal : CCR::Nonequal, E);
9368  }
9369 
9370  if (LHSTy->isNullPtrType()) {
9371  assert(E->isComparisonOp() && "unexpected nullptr operation");
9372  assert(RHSTy->isNullPtrType() && "missing pointer conversion");
9373  // C++11 [expr.rel]p4, [expr.eq]p3: If two operands of type std::nullptr_t
9374  // are compared, the result is true of the operator is <=, >= or ==, and
9375  // false otherwise.
9376  return Success(CCR::Equal, E);
9377  }
9378 
9379  return DoAfter();
9380 }
9381 
9382 bool RecordExprEvaluator::VisitBinCmp(const BinaryOperator *E) {
9383  if (!CheckLiteralType(Info, E))
9384  return false;
9385 
9386  auto OnSuccess = [&](ComparisonCategoryResult ResKind,
9387  const BinaryOperator *E) {
9388  // Evaluation succeeded. Lookup the information for the comparison category
9389  // type and fetch the VarDecl for the result.
9390  const ComparisonCategoryInfo &CmpInfo =
9391  Info.Ctx.CompCategories.getInfoForType(E->getType());
9392  const VarDecl *VD =
9393  CmpInfo.getValueInfo(CmpInfo.makeWeakResult(ResKind))->VD;
9394  // Check and evaluate the result as a constant expression.
9395  LValue LV;
9396  LV.set(VD);
9397  if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
9398  return false;
9399  return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result);
9400  };
9401  return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
9402  return ExprEvaluatorBaseTy::VisitBinCmp(E);
9403  });
9404 }
9405 
9406 bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
9407  // We don't call noteFailure immediately because the assignment happens after
9408  // we evaluate LHS and RHS.
9409  if (!Info.keepEvaluatingAfterFailure() && E->isAssignmentOp())
9410  return Error(E);
9411 
9412  DelayedNoteFailureRAII MaybeNoteFailureLater(Info, E->isAssignmentOp());
9413  if (DataRecursiveIntBinOpEvaluator::shouldEnqueue(E))
9414  return DataRecursiveIntBinOpEvaluator(*this, Result).Traverse(E);
9415 
9416  assert((!E->getLHS()->getType()->isIntegralOrEnumerationType() ||
9418  "DataRecursiveIntBinOpEvaluator should have handled integral types");
9419 
9420  if (E->isComparisonOp()) {
9421  // Evaluate builtin binary comparisons by evaluating them as C++2a three-way
9422  // comparisons and then translating the result.
9423  auto OnSuccess = [&](ComparisonCategoryResult ResKind,
9424  const BinaryOperator *E) {
9425  using CCR = ComparisonCategoryResult;
9426  bool IsEqual = ResKind == CCR::Equal,
9427  IsLess = ResKind == CCR::Less,
9428  IsGreater = ResKind == CCR::Greater;
9429  auto Op = E->getOpcode();
9430  switch (Op) {
9431  default:
9432  llvm_unreachable("unsupported binary operator");
9433  case BO_EQ:
9434  case BO_NE:
9435  return Success(IsEqual == (Op == BO_EQ), E);
9436  case BO_LT: return Success(IsLess, E);
9437  case BO_GT: return Success(IsGreater, E);
9438  case BO_LE: return Success(IsEqual || IsLess, E);
9439  case BO_GE: return Success(IsEqual || IsGreater, E);
9440  }
9441  };
9442  return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
9443  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
9444  });
9445  }
9446 
9447  QualType LHSTy = E->getLHS()->getType();
9448  QualType RHSTy = E->getRHS()->getType();
9449 
9450  if (LHSTy->isPointerType() && RHSTy->isPointerType() &&
9451  E->getOpcode() == BO_Sub) {
9452  LValue LHSValue, RHSValue;
9453 
9454  bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info);
9455  if (!LHSOK && !Info.noteFailure())
9456  return false;
9457 
9458  if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK)
9459  return false;
9460 
9461  // Reject differing bases from the normal codepath; we special-case
9462  // comparisons to null.
9463  if (!HasSameBase(LHSValue, RHSValue)) {
9464  // Handle &&A - &&B.
9465  if (!LHSValue.Offset.isZero() || !RHSValue.Offset.isZero())
9466  return Error(E);
9467  const Expr *LHSExpr = LHSValue.Base.dyn_cast<const Expr *>();
9468  const Expr *RHSExpr = RHSValue.Base.dyn_cast<const Expr *>();
9469  if (!LHSExpr || !RHSExpr)
9470  return Error(E);
9471  const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
9472  const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
9473  if (!LHSAddrExpr || !RHSAddrExpr)
9474  return Error(E);
9475  // Make sure both labels come from the same function.
9476  if (LHSAddrExpr->getLabel()->getDeclContext() !=
9477  RHSAddrExpr->getLabel()->getDeclContext())
9478  return Error(E);
9479  return Success(APValue(LHSAddrExpr, RHSAddrExpr), E);
9480  }
9481  const CharUnits &LHSOffset = LHSValue.getLValueOffset();
9482  const CharUnits &RHSOffset = RHSValue.getLValueOffset();
9483 
9484  SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
9485  SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
9486 
9487  // C++11 [expr.add]p6:
9488  // Unless both pointers point to elements of the same array object, or
9489  // one past the last element of the array object, the behavior is
9490  // undefined.
9491  if (!LHSDesignator.Invalid && !RHSDesignator.Invalid &&
9492  !AreElementsOfSameArray(getType(LHSValue.Base), LHSDesignator,
9493  RHSDesignator))
9494  Info.CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array);
9495 
9496  QualType Type = E->getLHS()->getType();
9497  QualType ElementType = Type->getAs<PointerType>()->getPointeeType();
9498 
9499  CharUnits ElementSize;
9500  if (!HandleSizeof(Info, E->getExprLoc(), ElementType, ElementSize))
9501  return false;
9502 
9503  // As an extension, a type may have zero size (empty struct or union in
9504  // C, array of zero length). Pointer subtraction in such cases has
9505  // undefined behavior, so is not constant.
9506  if (ElementSize.isZero()) {
9507  Info.FFDiag(E, diag::note_constexpr_pointer_subtraction_zero_size)
9508  << ElementType;
9509  return false;
9510  }
9511 
9512  // FIXME: LLVM and GCC both compute LHSOffset - RHSOffset at runtime,
9513  // and produce incorrect results when it overflows. Such behavior
9514  // appears to be non-conforming, but is common, so perhaps we should
9515  // assume the standard intended for such cases to be undefined behavior
9516  // and check for them.
9517 
9518  // Compute (LHSOffset - RHSOffset) / Size carefully, checking for
9519  // overflow in the final conversion to ptrdiff_t.
9520  APSInt LHS(llvm::APInt(65, (int64_t)LHSOffset.getQuantity(), true), false);
9521  APSInt RHS(llvm::APInt(65, (int64_t)RHSOffset.getQuantity(), true), false);
9522  APSInt ElemSize(llvm::APInt(65, (int64_t)ElementSize.getQuantity(), true),
9523  false);
9524  APSInt TrueResult = (LHS - RHS) / ElemSize;
9525  APSInt Result = TrueResult.trunc(Info.Ctx.getIntWidth(E->getType()));
9526 
9527  if (Result.extend(65) != TrueResult &&
9528  !HandleOverflow(Info, E, TrueResult, E->getType()))
9529  return false;
9530  return Success(Result, E);
9531  }
9532 
9533  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
9534 }
9535 
9536 /// VisitUnaryExprOrTypeTraitExpr - Evaluate a sizeof, alignof or vec_step with
9537 /// a result as the expression's type.
9538 bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr(
9539  const UnaryExprOrTypeTraitExpr *E) {
9540  switch(E->getKind()) {
9541  case UETT_PreferredAlignOf:
9542  case UETT_AlignOf: {
9543  if (E->isArgumentType())
9544  return Success(GetAlignOfType(Info, E->getArgumentType(), E->getKind()),
9545  E);
9546  else
9547  return Success(GetAlignOfExpr(Info, E->getArgumentExpr(), E->getKind()),
9548  E);
9549  }
9550 
9551  case UETT_VecStep: {
9552  QualType Ty = E->getTypeOfArgument();
9553 
9554  if (Ty->isVectorType()) {
9555  unsigned n = Ty->castAs<VectorType>()->getNumElements();
9556 
9557  // The vec_step built-in functions that take a 3-component
9558  // vector return 4. (OpenCL 1.1 spec 6.11.12)
9559  if (n == 3)
9560  n = 4;
9561 
9562  return Success(n, E);
9563  } else
9564  return Success(1, E);
9565  }
9566 
9567  case UETT_SizeOf: {
9568  QualType SrcTy = E->getTypeOfArgument();
9569  // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
9570  // the result is the size of the referenced type."
9571  if (const ReferenceType *Ref = SrcTy->getAs<ReferenceType>())
9572  SrcTy = Ref->getPointeeType();
9573 
9574  CharUnits Sizeof;
9575  if (!HandleSizeof(Info, E->getExprLoc(), SrcTy, Sizeof))
9576  return false;
9577  return Success(Sizeof, E);
9578  }
9580  assert(E->isArgumentType());
9581  return Success(
9582  Info.Ctx.toCharUnitsFromBits(
9583  Info.Ctx.getOpenMPDefaultSimdAlign(E->getArgumentType()))
9584  .getQuantity(),
9585  E);
9586  }
9587 
9588  llvm_unreachable("unknown expr/type trait");
9589 }
9590 
9591 bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *OOE) {
9592  CharUnits Result;
9593  unsigned n = OOE->getNumComponents();
9594  if (n == 0)
9595  return Error(OOE);
9596  QualType CurrentType = OOE->getTypeSourceInfo()->getType();
9597  for (unsigned i = 0; i != n; ++i) {
9598  OffsetOfNode ON = OOE->getComponent(i);
9599  switch (ON.getKind()) {
9600  case OffsetOfNode::Array: {
9601  const Expr *Idx = OOE->getIndexExpr(ON.getArrayExprIndex());
9602  APSInt IdxResult;
9603  if (!EvaluateInteger(Idx, IdxResult, Info))
9604  return false;
9605  const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType);
9606  if (!AT)
9607  return Error(OOE);
9608  CurrentType = AT->getElementType();
9609  CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType);
9610  Result += IdxResult.getSExtValue() * ElementSize;
9611  break;
9612  }
9613 
9614  case OffsetOfNode::Field: {
9615  FieldDecl *MemberDecl = ON.getField();
9616  const RecordType *RT = CurrentType->getAs<RecordType>();
9617  if (!RT)
9618  return Error(OOE);
9619  RecordDecl *RD = RT->getDecl();
9620  if (RD->isInvalidDecl()) return false;
9621  const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
9622  unsigned i = MemberDecl->getFieldIndex();
9623  assert(i < RL.getFieldCount() && "offsetof field in wrong type");
9624  Result += Info.Ctx.toCharUnitsFromBits(RL.getFieldOffset(i));
9625  CurrentType = MemberDecl->getType().getNonReferenceType();
9626  break;
9627  }
9628 
9630  llvm_unreachable("dependent __builtin_offsetof");
9631 
9632  case OffsetOfNode::Base: {
9633  CXXBaseSpecifier *BaseSpec = ON.getBase();
9634  if (BaseSpec->isVirtual())
9635  return Error(OOE);
9636 
9637  // Find the layout of the class whose base we are looking into.
9638  const RecordType *RT = CurrentType->getAs<RecordType>();
9639  if (!RT)
9640  return Error(OOE);
9641  RecordDecl *RD = RT->getDecl();
9642  if (RD->isInvalidDecl()) return false;
9643  const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
9644 
9645  // Find the base class itself.
9646  CurrentType = BaseSpec->getType();
9647  const RecordType *BaseRT = CurrentType->getAs<RecordType>();
9648  if (!BaseRT)
9649  return Error(OOE);
9650 
9651  // Add the offset to the base.
9652  Result += RL.getBaseClassOffset(cast<CXXRecordDecl>(BaseRT->getDecl()));
9653  break;
9654  }
9655  }
9656  }
9657  return Success(Result, OOE);
9658 }
9659 
9660 bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
9661  switch (E->getOpcode()) {
9662  default:
9663  // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
9664  // See C99 6.6p3.
9665  return Error(E);
9666  case UO_Extension:
9667  // FIXME: Should extension allow i-c-e extension expressions in its scope?
9668  // If so, we could clear the diagnostic ID.
9669  return Visit(E->getSubExpr());
9670  case UO_Plus:
9671  // The result is just the value.
9672  return Visit(E->getSubExpr());
9673  case UO_Minus: {
9674  if (!Visit(E->getSubExpr()))
9675  return false;
9676  if (!Result.isInt()) return Error(E);
9677  const APSInt &Value = Result.getInt();
9678  if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow() &&
9679  !HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1),
9680  E->getType()))
9681  return false;
9682  return Success(-Value, E);
9683  }
9684  case UO_Not: {
9685  if (!Visit(E->getSubExpr()))
9686  return false;
9687  if (!Result.isInt()) return Error(E);
9688  return Success(~Result.getInt(), E);
9689  }
9690  case UO_LNot: {
9691  bool bres;
9692  if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
9693  return false;
9694  return Success(!bres, E);
9695  }
9696  }
9697 }
9698 
9699 /// HandleCast - This is used to evaluate implicit or explicit casts where the
9700 /// result type is integer.
9701 bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
9702  const Expr *SubExpr = E->getSubExpr();
9703  QualType DestType = E->getType();
9704  QualType SrcType = SubExpr->getType();
9705 
9706  switch (E->getCastKind()) {
9707  case CK_BaseToDerived:
9708  case CK_DerivedToBase:
9709  case CK_UncheckedDerivedToBase:
9710  case CK_Dynamic:
9711  case CK_ToUnion:
9712  case CK_ArrayToPointerDecay:
9713  case CK_FunctionToPointerDecay:
9714  case CK_NullToPointer:
9715  case CK_NullToMemberPointer:
9716  case CK_BaseToDerivedMemberPointer:
9717  case CK_DerivedToBaseMemberPointer:
9718  case CK_ReinterpretMemberPointer:
9719  case CK_ConstructorConversion:
9720  case CK_IntegralToPointer:
9721  case CK_ToVoid:
9722  case CK_VectorSplat:
9723  case CK_IntegralToFloating:
9724  case CK_FloatingCast:
9725  case CK_CPointerToObjCPointerCast:
9726  case CK_BlockPointerToObjCPointerCast:
9727  case CK_AnyPointerToBlockPointerCast:
9728  case CK_ObjCObjectLValueCast:
9729  case CK_FloatingRealToComplex:
9730  case CK_FloatingComplexToReal:
9731  case CK_FloatingComplexCast:
9732  case CK_FloatingComplexToIntegralComplex:
9733  case CK_IntegralRealToComplex:
9734  case CK_IntegralComplexCast:
9735  case CK_IntegralComplexToFloatingComplex:
9736  case CK_BuiltinFnToFnPtr:
9737  case CK_ZeroToOCLOpaqueType:
9738  case CK_NonAtomicToAtomic:
9739  case CK_AddressSpaceConversion:
9740  case CK_IntToOCLSampler:
9741  case CK_FixedPointCast:
9742  llvm_unreachable("invalid cast kind for integral value");
9743 
9744  case CK_BitCast:
9745  case CK_Dependent:
9746  case CK_LValueBitCast:
9747  case CK_ARCProduceObject:
9748  case CK_ARCConsumeObject:
9749  case CK_ARCReclaimReturnedObject:
9750  case CK_ARCExtendBlockObject:
9751  case CK_CopyAndAutoreleaseBlockObject:
9752  return Error(E);
9753 
9754  case CK_UserDefinedConversion:
9755  case CK_LValueToRValue:
9756  case CK_AtomicToNonAtomic:
9757  case CK_NoOp:
9758  return ExprEvaluatorBaseTy::VisitCastExpr(E);
9759 
9760  case CK_MemberPointerToBoolean:
9761  case CK_PointerToBoolean:
9762  case CK_IntegralToBoolean:
9763  case CK_FloatingToBoolean:
9764  case CK_BooleanToSignedIntegral:
9765  case CK_FloatingComplexToBoolean:
9766  case CK_IntegralComplexToBoolean: {
9767  bool BoolResult;
9768  if (!EvaluateAsBooleanCondition(SubExpr, BoolResult, Info))
9769  return false;
9770  uint64_t IntResult = BoolResult;
9771  if (BoolResult && E->getCastKind() == CK_BooleanToSignedIntegral)
9772  IntResult = (uint64_t)-1;
9773  return Success(IntResult, E);
9774  }
9775 
9776  case CK_FixedPointToBoolean: {
9777  // Unsigned padding does not affect this.
9778  APValue Val;
9779  if (!Evaluate(Val, Info, SubExpr))
9780  return false;
9781  return Success(Val.getInt().getBoolValue(), E);
9782  }
9783 
9784  case CK_IntegralCast: {
9785  if (!Visit(SubExpr))
9786  return false;
9787 
9788  if (!Result.isInt()) {
9789  // Allow casts of address-of-label differences if they are no-ops
9790  // or narrowing. (The narrowing case isn't actually guaranteed to
9791  // be constant-evaluatable except in some narrow cases which are hard
9792  // to detect here. We let it through on the assumption the user knows
9793  // what they are doing.)
9794  if (Result.isAddrLabelDiff())
9795  return Info.Ctx.getTypeSize(DestType) <= Info.Ctx.getTypeSize(SrcType);
9796  // Only allow casts of lvalues if they are lossless.
9797  return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
9798  }
9799 
9800  return Success(HandleIntToIntCast(Info, E, DestType, SrcType,
9801  Result.getInt()), E);
9802  }
9803 
9804  case CK_PointerToIntegral: {
9805  CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
9806 
9807  LValue LV;
9808  if (!EvaluatePointer(SubExpr, LV, Info))
9809  return false;
9810 
9811  if (LV.getLValueBase()) {
9812  // Only allow based lvalue casts if they are lossless.
9813  // FIXME: Allow a larger integer size than the pointer size, and allow
9814  // narrowing back down to pointer width in subsequent integral casts.
9815  // FIXME: Check integer type's active bits, not its type size.
9816  if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(SrcType))
9817  return Error(E);
9818 
9819  LV.Designator.setInvalid();
9820  LV.moveInto(Result);
9821  return true;
9822  }
9823 
9824  uint64_t V;
9825  if (LV.isNullPointer())
9826  V = Info.Ctx.getTargetNullPointerValue(SrcType);
9827  else
9828  V = LV.getLValueOffset().getQuantity();
9829 
9830  APSInt AsInt = Info.Ctx.MakeIntValue(V, SrcType);
9831  return Success(HandleIntToIntCast(Info, E, DestType, SrcType, AsInt), E);
9832  }
9833 
9834  case CK_IntegralComplexToReal: {
9835  ComplexValue C;
9836  if (!EvaluateComplex(SubExpr, C, Info))
9837  return false;
9838  return Success(C.getComplexIntReal(), E);
9839  }
9840 
9841  case CK_FloatingToIntegral: {
9842  APFloat F(0.0);
9843  if (!EvaluateFloat(SubExpr, F, Info))
9844  return false;
9845 
9846  APSInt Value;
9847  if (!HandleFloatToIntCast(Info, E, SrcType, F, DestType, Value))
9848  return false;
9849  return Success(Value, E);
9850  }
9851  }
9852 
9853  llvm_unreachable("unknown cast resulting in integral value");
9854 }
9855 
9856 bool IntExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
9857  if (E->getSubExpr()->getType()->isAnyComplexType()) {
9858  ComplexValue LV;
9859  if (!EvaluateComplex(E->getSubExpr(), LV, Info))
9860  return false;
9861  if (!LV.isComplexInt())
9862  return Error(E);
9863  return Success(LV.getComplexIntReal(), E);
9864  }
9865 
9866  return Visit(E->getSubExpr());
9867 }
9868 
9869 bool IntExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
9870  if (E->getSubExpr()->getType()->isComplexIntegerType()) {
9871  ComplexValue LV;
9872  if (!EvaluateComplex(E->getSubExpr(), LV, Info))
9873  return false;
9874  if (!LV.isComplexInt())
9875  return Error(E);
9876  return Success(LV.getComplexIntImag(), E);
9877  }
9878 
9879  VisitIgnoredValue(E->getSubExpr());
9880  return Success(0, E);
9881 }
9882 
9883 bool IntExprEvaluator::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
9884  return Success(E->getPackLength(), E);
9885 }
9886 
9887 bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
9888  return Success(E->getValue(), E);
9889 }
9890 
9891 bool FixedPointExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
9892  switch (E->getOpcode()) {
9893  default:
9894  // Invalid unary operators
9895  return Error(E);
9896  case UO_Plus:
9897  // The result is just the value.
9898  return Visit(E->getSubExpr());
9899  case UO_Minus: {
9900  if (!Visit(E->getSubExpr())) return false;
9901  if (!Result.isInt()) return Error(E);
9902  const APSInt &Value = Result.getInt();
9903  if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow()) {
9904  SmallString<64> S;
9905  FixedPointValueToString(S, Value,
9906  Info.Ctx.getTypeInfo(E->getType()).Width);
9907  Info.CCEDiag(E, diag::note_constexpr_overflow) << S << E->getType();
9908  if (Info.noteUndefinedBehavior()) return false;
9909  }
9910  return Success(-Value, E);
9911  }
9912  case UO_LNot: {
9913  bool bres;
9914  if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
9915  return false;
9916  return Success(!bres, E);
9917  }
9918  }
9919 }
9920 
9921 //===----------------------------------------------------------------------===//
9922 // Float Evaluation
9923 //===----------------------------------------------------------------------===//
9924 
9925 namespace {
9926 class FloatExprEvaluator
9927  : public ExprEvaluatorBase<FloatExprEvaluator> {
9928  APFloat &Result;
9929 public:
9930  FloatExprEvaluator(EvalInfo &info, APFloat &result)
9931  : ExprEvaluatorBaseTy(info), Result(result) {}
9932 
9933  bool Success(const APValue &V, const Expr *e) {
9934  Result = V.getFloat();
9935  return true;
9936  }
9937 
9938  bool ZeroInitialization(const Expr *E) {
9939  Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
9940  return true;
9941  }
9942 
9943  bool VisitCallExpr(const CallExpr *E);
9944 
9945  bool VisitUnaryOperator(const UnaryOperator *E);
9946  bool VisitBinaryOperator(const BinaryOperator *E);
9947  bool VisitFloatingLiteral(const FloatingLiteral *E);
9948  bool VisitCastExpr(const CastExpr *E);
9949 
9950  bool VisitUnaryReal(const UnaryOperator *E);
9951  bool VisitUnaryImag(const UnaryOperator *E);
9952 
9953  // FIXME: Missing: array subscript of vector, member of vector
9954 };
9955 } // end anonymous namespace
9956 
9957 static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
9958  assert(E->isRValue() && E->getType()->isRealFloatingType());
9959  return FloatExprEvaluator(Info, Result).Visit(E);
9960 }
9961 
9962 static bool TryEvaluateBuiltinNaN(const ASTContext &Context,
9963  QualType ResultTy,
9964  const Expr *Arg,
9965  bool SNaN,
9966  llvm::APFloat &Result) {
9967  const StringLiteral *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
9968  if (!S) return false;
9969 
9970  const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(ResultTy);
9971 
9972  llvm::APInt fill;
9973 
9974  // Treat empty strings as if they were zero.
9975  if (S->getString().empty())
9976  fill = llvm::APInt(32, 0);
9977  else if (S->getString().getAsInteger(0, fill))
9978  return false;
9979 
9980  if (Context.getTargetInfo().isNan2008()) {
9981  if (SNaN)
9982  Result = llvm::APFloat::getSNaN(Sem, false, &fill);
9983  else
9984  Result = llvm::APFloat::getQNaN(Sem, false, &fill);
9985  } else {
9986  // Prior to IEEE 754-2008, architectures were allowed to choose whether
9987  // the first bit of their significand was set for qNaN or sNaN. MIPS chose
9988  // a different encoding to what became a standard in 2008, and for pre-
9989  // 2008 revisions, MIPS interpreted sNaN-2008 as qNan and qNaN-2008 as
9990  // sNaN. This is now known as "legacy NaN" encoding.
9991  if (SNaN)
9992  Result = llvm::APFloat::getQNaN(Sem, false, &fill);
9993  else
9994  Result = llvm::APFloat::getSNaN(Sem, false, &fill);
9995  }
9996 
9997  return true;
9998 }
9999 
10000 bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) {
10001  switch (E->getBuiltinCallee()) {
10002  default:
10003  return ExprEvaluatorBaseTy::VisitCallExpr(E);
10004 
10005  case Builtin::BI__builtin_huge_val:
10006  case Builtin::BI__builtin_huge_valf:
10007  case Builtin::BI__builtin_huge_vall:
10008  case Builtin::BI__builtin_huge_valf128:
10009  case Builtin::BI__builtin_inf:
10010  case Builtin::BI__builtin_inff:
10011  case Builtin::BI__builtin_infl:
10012  case Builtin::BI__builtin_inff128: {
10013  const llvm::fltSemantics &Sem =
10014  Info.Ctx.getFloatTypeSemantics(E->getType());
10015  Result = llvm::APFloat::getInf(Sem);
10016  return true;
10017  }
10018 
10019  case Builtin::BI__builtin_nans:
10020  case Builtin::BI__builtin_nansf:
10021  case Builtin::BI__builtin_nansl:
10022  case Builtin::BI__builtin_nansf128:
10023  if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
10024  true, Result))
10025  return Error(E);
10026  return true;
10027 
10028  case Builtin::BI__builtin_nan:
10029  case Builtin::BI__builtin_nanf:
10030  case Builtin::BI__builtin_nanl:
10031  case Builtin::BI__builtin_nanf128:
10032  // If this is __builtin_nan() turn this into a nan, otherwise we
10033  // can't constant fold it.
10034  if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
10035  false, Result))
10036  return Error(E);
10037  return true;
10038 
10039  case Builtin::BI__builtin_fabs:
10040  case Builtin::BI__builtin_fabsf:
10041  case Builtin::BI__builtin_fabsl:
10042  case Builtin::BI__builtin_fabsf128:
10043  if (!EvaluateFloat(E->getArg(0), Result, Info))
10044  return false;
10045 
10046  if (Result.isNegative())
10047  Result.changeSign();
10048  return true;
10049 
10050  // FIXME: Builtin::BI__builtin_powi
10051  // FIXME: Builtin::BI__builtin_powif
10052  // FIXME: Builtin::BI__builtin_powil
10053 
10054  case Builtin::BI__builtin_copysign:
10055  case Builtin::BI__builtin_copysignf:
10056  case Builtin::BI__builtin_copysignl:
10057  case Builtin::BI__builtin_copysignf128: {
10058  APFloat RHS(0.);
10059  if (!EvaluateFloat(E->getArg(0), Result, Info) ||
10060  !EvaluateFloat(E->getArg(1), RHS, Info))
10061  return false;
10062  Result.copySign(RHS);
10063  return true;
10064  }
10065  }
10066 }
10067 
10068 bool FloatExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
10069  if (E->getSubExpr()->getType()->isAnyComplexType()) {
10070  ComplexValue CV;
10071  if (!EvaluateComplex(E->getSubExpr(), CV, Info))
10072  return false;
10073  Result = CV.FloatReal;
10074  return true;
10075  }
10076 
10077  return Visit(E->getSubExpr());
10078 }
10079 
10080 bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
10081  if (E->getSubExpr()->getType()->isAnyComplexType()) {
10082  ComplexValue CV;
10083  if (!EvaluateComplex(E->getSubExpr(), CV, Info))
10084  return false;
10085  Result = CV.FloatImag;
10086  return true;
10087  }
10088 
10089  VisitIgnoredValue(E->getSubExpr());
10090  const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType());
10091  Result = llvm::APFloat::getZero(Sem);
10092  return true;
10093 }
10094 
10095 bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
10096  switch (E->getOpcode()) {
10097  default: return Error(E);
10098  case UO_Plus:
10099  return EvaluateFloat(E->getSubExpr(), Result, Info);
10100  case UO_Minus:
10101  if (!EvaluateFloat(E->getSubExpr(), Result, Info))
10102  return false;
10103  Result.changeSign();
10104  return true;
10105  }
10106 }
10107 
10108 bool FloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
10109  if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
10110  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
10111 
10112  APFloat RHS(0.0);
10113  bool LHSOK = EvaluateFloat(E->getLHS(), Result, Info);
10114  if (!LHSOK && !Info.noteFailure())
10115  return false;
10116  return EvaluateFloat(E->getRHS(), RHS, Info) && LHSOK &&
10117  handleFloatFloatBinOp(Info, E, Result, E->getOpcode(), RHS);
10118 }
10119 
10120 bool FloatExprEvaluator::VisitFloatingLiteral(const FloatingLiteral *E) {
10121  Result = E->getValue();
10122  return true;
10123 }
10124 
10125 bool FloatExprEvaluator::VisitCastExpr(const CastExpr *E) {
10126  const Expr* SubExpr = E->getSubExpr();
10127 
10128  switch (E->getCastKind()) {
10129  default:
10130  return ExprEvaluatorBaseTy::VisitCastExpr(E);
10131 
10132  case CK_IntegralToFloating: {
10133  APSInt IntResult;
10134  return EvaluateInteger(SubExpr, IntResult, Info) &&
10135  HandleIntToFloatCast(Info, E, SubExpr->getType(), IntResult,
10136  E->getType(), Result);
10137  }
10138 
10139  case CK_FloatingCast: {
10140  if (!Visit(SubExpr))
10141  return false;
10142  return HandleFloatToFloatCast(Info, E, SubExpr->getType(), E->getType(),
10143  Result);
10144  }
10145 
10146  case CK_FloatingComplexToReal: {
10147  ComplexValue V;
10148  if (!EvaluateComplex(SubExpr, V, Info))
10149  return false;
10150  Result = V.getComplexFloatReal();
10151  return true;
10152  }
10153  }
10154 }
10155 
10156 //===----------------------------------------------------------------------===//
10157 // Complex Evaluation (for float and integer)
10158 //===----------------------------------------------------------------------===//
10159 
10160 namespace {
10161 class ComplexExprEvaluator
10162  : public ExprEvaluatorBase<ComplexExprEvaluator> {
10163  ComplexValue &Result;
10164 
10165 public:
10166  ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result)
10167  : ExprEvaluatorBaseTy(info), Result(Result) {}
10168 
10169  bool Success(const APValue &V, const Expr *e) {
10170  Result.setFrom(V);
10171  return true;
10172  }
10173 
10174  bool ZeroInitialization(const Expr *E);
10175 
10176  //===--------------------------------------------------------------------===//
10177  // Visitor Methods
10178  //===--------------------------------------------------------------------===//
10179 
10180  bool VisitImaginaryLiteral(const ImaginaryLiteral *E);
10181  bool VisitCastExpr(const CastExpr *E);
10182  bool VisitBinaryOperator(const BinaryOperator *E);
10183  bool VisitUnaryOperator(const UnaryOperator *E);
10184  bool VisitInitListExpr(const InitListExpr *E);
10185 };
10186 } // end anonymous namespace
10187 
10188 static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
10189  EvalInfo &Info) {
10190  assert(E->isRValue() && E->getType()->isAnyComplexType());
10191  return ComplexExprEvaluator(Info, Result).Visit(E);
10192 }
10193 
10194 bool ComplexExprEvaluator::ZeroInitialization(const Expr *E) {
10195  QualType ElemTy = E->getType()->castAs<ComplexType>()->getElementType();
10196  if (ElemTy->isRealFloatingType()) {
10197  Result.makeComplexFloat();
10198  APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy));
10199  Result.FloatReal = Zero;
10200  Result.FloatImag = Zero;
10201  } else {
10202  Result.makeComplexInt();
10203  APSInt Zero = Info.Ctx.MakeIntValue(0, ElemTy);
10204  Result.IntReal = Zero;
10205  Result.IntImag = Zero;
10206  }
10207  return true;
10208 }
10209 
10210 bool ComplexExprEvaluator::VisitImaginaryLiteral(const ImaginaryLiteral *E) {
10211  const Expr* SubExpr = E->getSubExpr();
10212 
10213  if (SubExpr->getType()->isRealFloatingType()) {
10214  Result.makeComplexFloat();
10215  APFloat &Imag = Result.FloatImag;
10216  if (!EvaluateFloat(SubExpr, Imag, Info))
10217  return false;
10218 
10219  Result.FloatReal = APFloat(Imag.getSemantics());
10220  return true;
10221  } else {
10222  assert(SubExpr->getType()->isIntegerType() &&
10223  "Unexpected imaginary literal.");
10224 
10225  Result.makeComplexInt();
10226  APSInt &Imag = Result.IntImag;
10227  if (!EvaluateInteger(SubExpr, Imag, Info))
10228  return false;
10229 
10230  Result.IntReal = APSInt(Imag.getBitWidth(), !Imag.isSigned());
10231  return true;
10232  }
10233 }
10234 
10235 bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
10236 
10237  switch (E->getCastKind()) {
10238  case CK_BitCast:
10239  case CK_BaseToDerived:
10240  case CK_DerivedToBase:
10241  case CK_UncheckedDerivedToBase:
10242  case CK_Dynamic:
10243  case CK_ToUnion:
10244  case CK_ArrayToPointerDecay:
10245  case CK_FunctionToPointerDecay:
10246  case CK_NullToPointer:
10247  case CK_NullToMemberPointer:
10248  case CK_BaseToDerivedMemberPointer:
10249  case CK_DerivedToBaseMemberPointer:
10250  case CK_MemberPointerToBoolean:
10251  case CK_ReinterpretMemberPointer:
10252  case CK_ConstructorConversion:
10253  case CK_IntegralToPointer:
10254  case CK_PointerToIntegral:
10255  case CK_PointerToBoolean:
10256  case CK_ToVoid:
10257  case CK_VectorSplat:
10258  case CK_IntegralCast:
10259  case CK_BooleanToSignedIntegral:
10260  case CK_IntegralToBoolean:
10261  case CK_IntegralToFloating:
10262  case CK_FloatingToIntegral:
10263  case CK_FloatingToBoolean:
10264  case CK_FloatingCast:
10265  case CK_CPointerToObjCPointerCast:
10266  case CK_BlockPointerToObjCPointerCast:
10267  case CK_AnyPointerToBlockPointerCast:
10268  case CK_ObjCObjectLValueCast:
10269  case CK_FloatingComplexToReal:
10270  case CK_FloatingComplexToBoolean:
10271  case CK_IntegralComplexToReal:
10272  case CK_IntegralComplexToBoolean:
10273  case CK_ARCProduceObject:
10274  case CK_ARCConsumeObject:
10275  case CK_ARCReclaimReturnedObject:
10276  case CK_ARCExtendBlockObject:
10277  case CK_CopyAndAutoreleaseBlockObject:
10278  case CK_BuiltinFnToFnPtr:
10279  case CK_ZeroToOCLOpaqueType:
10280  case CK_NonAtomicToAtomic:
10281  case CK_AddressSpaceConversion:
10282  case CK_IntToOCLSampler:
10283  case CK_FixedPointCast:
10284  case CK_FixedPointToBoolean:
10285  llvm_unreachable("invalid cast kind for complex value");
10286 
10287  case CK_LValueToRValue:
10288  case CK_AtomicToNonAtomic:
10289  case CK_NoOp:
10290  return ExprEvaluatorBaseTy::VisitCastExpr(E);
10291 
10292  case CK_Dependent:
10293  case CK_LValueBitCast:
10294  case CK_UserDefinedConversion:
10295  return Error(E);
10296 
10297  case CK_FloatingRealToComplex: {
10298  APFloat &Real = Result.FloatReal;
10299  if (!EvaluateFloat(E->getSubExpr(), Real, Info))
10300  return false;
10301 
10302  Result.makeComplexFloat();
10303  Result.FloatImag = APFloat(Real.getSemantics());
10304  return true;
10305  }
10306 
10307  case CK_FloatingComplexCast: {
10308  if (!Visit(E->getSubExpr()))
10309  return false;
10310 
10311  QualType To = E->getType()->getAs<ComplexType>()->getElementType();
10312  QualType From
10313  = E->getSubExpr()->getType()->getAs<ComplexType>()->getElementType();
10314 
10315  return HandleFloatToFloatCast(Info, E, From, To, Result.FloatReal) &&
10316  HandleFloatToFloatCast(Info, E, From, To, Result.FloatImag);
10317  }
10318 
10319  case CK_FloatingComplexToIntegralComplex: {
10320  if (!Visit(E->getSubExpr()))
10321  return false;
10322 
10323  QualType To = E->getType()->getAs<ComplexType>()->getElementType();
10324  QualType From
10325  = E->getSubExpr()->getType()->getAs<ComplexType>()->getElementType();
10326  Result.makeComplexInt();
10327  return HandleFloatToIntCast(Info, E, From, Result.FloatReal,
10328  To, Result.IntReal) &&
10329  HandleFloatToIntCast(Info, E, From, Result.FloatImag,
10330  To, Result.IntImag);
10331  }
10332 
10333  case CK_IntegralRealToComplex: {
10334  APSInt &Real = Result.IntReal;
10335  if (!EvaluateInteger(E->getSubExpr(), Real, Info))
10336  return false;
10337 
10338  Result.makeComplexInt();
10339  Result.IntImag = APSInt(Real.getBitWidth(), !Real.isSigned());
10340  return true;
10341  }
10342 
10343  case CK_IntegralComplexCast: {
10344  if (!Visit(E->getSubExpr()))
10345  return false;
10346 
10347  QualType To = E->getType()->getAs<ComplexType>()->getElementType();
10348  QualType From
10349  = E->getSubExpr()->getType()->getAs<ComplexType>()->getElementType();
10350 
10351  Result.IntReal = HandleIntToIntCast(Info, E, To, From, Result.IntReal);
10352  Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag);
10353  return true;
10354  }
10355 
10356  case CK_IntegralComplexToFloatingComplex: {
10357  if (!Visit(E->getSubExpr()))
10358  return false;
10359 
10360  QualType To = E->getType()->castAs<ComplexType>()->getElementType();
10361  QualType From
10362  = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
10363  Result.makeComplexFloat();
10364  return HandleIntToFloatCast(Info, E, From, Result.IntReal,
10365  To, Result.FloatReal) &&
10366  HandleIntToFloatCast(Info, E, From, Result.IntImag,
10367  To, Result.FloatImag);
10368  }
10369  }
10370 
10371  llvm_unreachable("unknown cast resulting in complex value");
10372 }
10373 
10374 bool ComplexExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
10375  if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
10376  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
10377 
10378  // Track whether the LHS or RHS is real at the type system level. When this is
10379  // the case we can simplify our evaluation strategy.
10380  bool LHSReal = false, RHSReal = false;
10381 
10382  bool LHSOK;
10383  if (E->getLHS()->getType()->isRealFloatingType()) {
10384  LHSReal = true;
10385  APFloat &Real = Result.FloatReal;
10386  LHSOK = EvaluateFloat(E->getLHS(), Real, Info);
10387  if (LHSOK) {
10388  Result.makeComplexFloat();
10389  Result.FloatImag = APFloat(Real.getSemantics());
10390  }
10391  } else {
10392  LHSOK = Visit(E->getLHS());
10393  }
10394  if (!LHSOK && !Info.noteFailure())
10395  return false;
10396 
10397  ComplexValue RHS;
10398  if (E->getRHS()->getType()->isRealFloatingType()) {
10399  RHSReal = true;
10400  APFloat &Real = RHS.FloatReal;
10401  if (!EvaluateFloat(E->getRHS(), Real, Info) || !LHSOK)
10402  return false;
10403  RHS.makeComplexFloat();
10404  RHS.FloatImag = APFloat(Real.getSemantics());
10405  } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
10406  return false;
10407 
10408  assert(!(LHSReal && RHSReal) &&
10409  "Cannot have both operands of a complex operation be real.");
10410  switch (E->getOpcode()) {
10411  default: return Error(E);
10412  case BO_Add:
10413  if (Result.isComplexFloat()) {
10414  Result.getComplexFloatReal().add(RHS.getComplexFloatReal(),
10415  APFloat::rmNearestTiesToEven);
10416  if (LHSReal)
10417  Result.getComplexFloatImag() = RHS.getComplexFloatImag();
10418  else if (!RHSReal)
10419  Result.getComplexFloatImag().add(RHS.getComplexFloatImag(),
10420  APFloat::rmNearestTiesToEven);
10421  } else {
10422  Result.getComplexIntReal() += RHS.getComplexIntReal();
10423  Result.getComplexIntImag() += RHS.getComplexIntImag();
10424  }
10425  break;
10426  case BO_Sub:
10427  if (Result.isComplexFloat()) {
10428  Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(),
10429  APFloat::rmNearestTiesToEven);
10430  if (LHSReal) {
10431  Result.getComplexFloatImag() = RHS.getComplexFloatImag();
10432  Result.getComplexFloatImag().changeSign();
10433  } else if (!RHSReal) {
10434  Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(),
10435  APFloat::rmNearestTiesToEven);
10436  }
10437  } else {
10438  Result.getComplexIntReal() -= RHS.getComplexIntReal();
10439  Result.getComplexIntImag() -= RHS.getComplexIntImag();
10440  }
10441  break;
10442  case BO_Mul:
10443  if (Result.isComplexFloat()) {
10444  // This is an implementation of complex multiplication according to the
10445  // constraints laid out in C11 Annex G. The implementation uses the
10446  // following naming scheme:
10447  // (a + ib) * (c + id)
10448  ComplexValue LHS = Result;
10449  APFloat &A = LHS.getComplexFloatReal();
10450  APFloat &B = LHS.getComplexFloatImag();
10451  APFloat &C = RHS.getComplexFloatReal();
10452  APFloat &D = RHS.getComplexFloatImag();
10453  APFloat &ResR = Result.getComplexFloatReal();
10454  APFloat &ResI = Result.getComplexFloatImag();
10455  if (LHSReal) {
10456  assert(!RHSReal && "Cannot have two real operands for a complex op!");
10457  ResR = A * C;
10458  ResI = A * D;
10459  } else if (RHSReal) {
10460  ResR = C * A;
10461  ResI = C * B;
10462  } else {
10463  // In the fully general case, we need to handle NaNs and infinities
10464  // robustly.
10465  APFloat AC = A * C;
10466  APFloat BD = B * D;
10467  APFloat AD = A * D;
10468  APFloat BC = B * C;
10469  ResR = AC - BD;
10470  ResI = AD + BC;
10471  if (ResR.isNaN() && ResI.isNaN()) {
10472  bool Recalc = false;
10473  if (A.isInfinity() || B.isInfinity()) {
10474  A = APFloat::copySign(
10475  APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
10476  B = APFloat::copySign(
10477  APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
10478  if (C.isNaN())
10479  C = APFloat::copySign(APFloat(C.getSemantics()), C);
10480  if (D.isNaN())
10481  D = APFloat::copySign(APFloat(D.getSemantics()), D);
10482  Recalc = true;
10483  }
10484  if (C.isInfinity() || D.isInfinity()) {
10485  C = APFloat::copySign(
10486  APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
10487  D = APFloat::copySign(
10488  APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
10489  if (A.isNaN())
10490  A = APFloat::copySign(APFloat(A.getSemantics()), A);
10491  if (B.isNaN())
10492  B = APFloat::copySign(APFloat(B.getSemantics()), B);
10493  Recalc = true;
10494  }
10495  if (!Recalc && (AC.isInfinity() || BD.isInfinity() ||
10496  AD.isInfinity() || BC.isInfinity())) {
10497  if (A.isNaN())
10498  A = APFloat::copySign(APFloat(A.getSemantics()), A);
10499  if (B.isNaN())
10500  B = APFloat::copySign(APFloat(B.getSemantics()), B);
10501  if (C.isNaN())
10502  C = APFloat::copySign(APFloat(C.getSemantics()), C);
10503  if (D.isNaN())
10504  D = APFloat::copySign(APFloat(D.getSemantics()), D);
10505  Recalc = true;
10506  }
10507  if (Recalc) {
10508  ResR = APFloat::getInf(A.getSemantics()) * (A * C - B * D);
10509  ResI = APFloat::getInf(A.getSemantics()) * (A * D + B * C);
10510  }
10511  }
10512  }
10513  } else {
10514  ComplexValue LHS = Result;
10515  Result.getComplexIntReal() =
10516  (LHS.getComplexIntReal() * RHS.getComplexIntReal() -
10517  LHS.getComplexIntImag() * RHS.getComplexIntImag());
10518  Result.getComplexIntImag() =
10519  (LHS.getComplexIntReal() * RHS.getComplexIntImag() +
10520  LHS.getComplexIntImag() * RHS.getComplexIntReal());
10521  }
10522  break;
10523  case BO_Div:
10524  if (Result.isComplexFloat()) {
10525  // This is an implementation of complex division according to the
10526  // constraints laid out in C11 Annex G. The implementation uses the
10527  // following naming scheme:
10528  // (a + ib) / (c + id)
10529  ComplexValue LHS = Result;
10530  APFloat &A = LHS.getComplexFloatReal();
10531  APFloat &B = LHS.getComplexFloatImag();
10532  APFloat &C = RHS.getComplexFloatReal();
10533  APFloat &D = RHS.getComplexFloatImag();
10534  APFloat &ResR = Result.getComplexFloatReal();
10535  APFloat &ResI = Result.getComplexFloatImag();
10536  if (RHSReal) {
10537  ResR = A / C;
10538  ResI = B / C;
10539  } else {
10540  if (LHSReal) {
10541  // No real optimizations we can do here, stub out with zero.
10542  B = APFloat::getZero(A.getSemantics());
10543  }
10544  int DenomLogB = 0;
10545  APFloat MaxCD = maxnum(abs(C), abs(D));
10546  if (MaxCD.isFinite()) {
10547  DenomLogB = ilogb(MaxCD);
10548  C = scalbn(C, -DenomLogB, APFloat::rmNearestTiesToEven);
10549  D = scalbn(D, -DenomLogB, APFloat::rmNearestTiesToEven);
10550  }
10551  APFloat Denom = C * C + D * D;
10552  ResR = scalbn((A * C + B * D) / Denom, -DenomLogB,
10553  APFloat::rmNearestTiesToEven);
10554  ResI = scalbn((B * C - A * D) / Denom, -DenomLogB,
10555  APFloat::rmNearestTiesToEven);
10556  if (ResR.isNaN() && ResI.isNaN()) {
10557  if (Denom.isPosZero() && (!A.isNaN() || !B.isNaN())) {
10558  ResR = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * A;
10559  ResI = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * B;
10560  } else if ((A.isInfinity() || B.isInfinity()) && C.isFinite() &&
10561  D.isFinite()) {
10562  A = APFloat::copySign(
10563  APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
10564  B = APFloat::copySign(
10565  APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
10566  ResR = APFloat::getInf(ResR.getSemantics()) * (A * C + B * D);
10567  ResI = APFloat::getInf(ResI.getSemantics()) * (B * C - A * D);
10568  } else if (MaxCD.isInfinity() && A.isFinite() && B.isFinite()) {
10569  C = APFloat::copySign(
10570  APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
10571  D = APFloat::copySign(
10572  APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
10573  ResR = APFloat::getZero(ResR.getSemantics()) * (A * C + B * D);
10574  ResI = APFloat::getZero(ResI.getSemantics()) * (B * C - A * D);
10575  }
10576  }
10577  }
10578  } else {
10579  if (RHS.getComplexIntReal() == 0 && RHS.getComplexIntImag() == 0)
10580  return Error(E, diag::note_expr_divide_by_zero);
10581 
10582  ComplexValue LHS = Result;
10583  APSInt Den = RHS.getComplexIntReal() * RHS.getComplexIntReal() +
10584  RHS.getComplexIntImag() * RHS.getComplexIntImag();
10585  Result.getComplexIntReal() =
10586  (LHS.getComplexIntReal() * RHS.getComplexIntReal() +
10587  LHS.getComplexIntImag() * RHS.getComplexIntImag()) / Den;
10588  Result.getComplexIntImag() =
10589  (LHS.getComplexIntImag() * RHS.getComplexIntReal() -
10590  LHS.getComplexIntReal() * RHS.getComplexIntImag()) / Den;
10591  }
10592  break;
10593  }
10594 
10595  return true;
10596 }
10597 
10598 bool ComplexExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
10599  // Get the operand value into 'Result'.
10600  if (!Visit(E->getSubExpr()))
10601  return false;
10602 
10603  switch (E->getOpcode()) {
10604  default:
10605  return Error(E);
10606  case UO_Extension:
10607  return true;
10608  case UO_Plus:
10609  // The result is always just the subexpr.
10610  return true;
10611  case UO_Minus:
10612  if (Result.isComplexFloat()) {
10613  Result.getComplexFloatReal().changeSign();
10614  Result.getComplexFloatImag().changeSign();
10615  }
10616  else {
10617  Result.getComplexIntReal() = -Result.getComplexIntReal();
10618  Result.getComplexIntImag() = -Result.getComplexIntImag();
10619  }
10620  return true;
10621  case UO_Not:
10622  if (Result.isComplexFloat())
10623  Result.getComplexFloatImag().changeSign();
10624  else
10625  Result.getComplexIntImag() = -Result.getComplexIntImag();
10626  return true;
10627  }
10628 }
10629 
10630 bool ComplexExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
10631  if (E->getNumInits() == 2) {
10632  if (E->getType()->isComplexType()) {
10633  Result.makeComplexFloat();
10634  if (!EvaluateFloat(E->getInit(0), Result.FloatReal, Info))
10635  return false;
10636  if (!EvaluateFloat(E->getInit(1), Result.FloatImag, Info))
10637  return false;
10638  } else {
10639  Result.makeComplexInt();
10640  if (!EvaluateInteger(E->getInit(0), Result.IntReal, Info))
10641  return false;
10642  if (!EvaluateInteger(E->getInit(1), Result.IntImag, Info))
10643  return false;
10644  }
10645  return true;
10646  }
10647  return ExprEvaluatorBaseTy::VisitInitListExpr(E);
10648 }
10649 
10650 //===----------------------------------------------------------------------===//
10651 // Atomic expression evaluation, essentially just handling the NonAtomicToAtomic
10652 // implicit conversion.
10653 //===----------------------------------------------------------------------===//
10654 
10655 namespace {
10656 class AtomicExprEvaluator :
10657  public ExprEvaluatorBase<AtomicExprEvaluator> {
10658  const LValue *This;
10659  APValue &Result;
10660 public:
10661  AtomicExprEvaluator(EvalInfo &Info, const LValue *This, APValue &Result)
10662  : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
10663 
10664  bool Success(const APValue &V, const Expr *E) {
10665  Result = V;
10666  return true;
10667  }
10668 
10669  bool ZeroInitialization(const Expr *E) {
10671  E->getType()->castAs<AtomicType>()->getValueType());
10672  // For atomic-qualified class (and array) types in C++, initialize the
10673  // _Atomic-wrapped subobject directly, in-place.
10674  return This ? EvaluateInPlace(Result, Info, *This, &VIE)
10675  : Evaluate(Result, Info, &VIE);
10676  }
10677 
10678  bool VisitCastExpr(const CastExpr *E) {
10679  switch (E->getCastKind()) {
10680  default:
10681  return ExprEvaluatorBaseTy::VisitCastExpr(E);
10682  case CK_NonAtomicToAtomic:
10683  return This ? EvaluateInPlace(Result, Info, *This, E->getSubExpr())
10684  : Evaluate(Result, Info, E->getSubExpr());
10685  }
10686  }
10687 };
10688 } // end anonymous namespace
10689 
10690 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
10691  EvalInfo &Info) {
10692  assert(E->isRValue() && E->getType()->isAtomicType());
10693  return AtomicExprEvaluator(Info, This, Result).Visit(E);
10694 }
10695 
10696 //===----------------------------------------------------------------------===//
10697 // Void expression evaluation, primarily for a cast to void on the LHS of a
10698 // comma operator
10699 //===----------------------------------------------------------------------===//
10700 
10701 namespace {
10702 class VoidExprEvaluator
10703  : public ExprEvaluatorBase<VoidExprEvaluator> {
10704 public:
10705  VoidExprEvaluator(EvalInfo &Info) : ExprEvaluatorBaseTy(Info) {}
10706 
10707  bool Success(const APValue &V, const Expr *e) { return true; }
10708 
10709  bool ZeroInitialization(const Expr *E) { return true; }
10710 
10711  bool VisitCastExpr(const CastExpr *E) {
10712  switch (E->getCastKind()) {
10713  default:
10714  return ExprEvaluatorBaseTy::VisitCastExpr(E);
10715  case CK_ToVoid:
10716  VisitIgnoredValue(E->getSubExpr());
10717  return true;
10718  }
10719  }
10720 
10721  bool VisitCallExpr(const CallExpr *E) {
10722  switch (E->getBuiltinCallee()) {
10723  default:
10724  return ExprEvaluatorBaseTy::VisitCallExpr(E);
10725  case Builtin::BI__assume:
10726  case Builtin::BI__builtin_assume:
10727  // The argument is not evaluated!
10728  return true;
10729  }
10730  }
10731 };
10732 } // end anonymous namespace
10733 
10734 static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
10735  assert(E->isRValue() && E->getType()->isVoidType());
10736  return VoidExprEvaluator(Info).Visit(E);
10737 }
10738 
10739 //===----------------------------------------------------------------------===//
10740 // Top level Expr::EvaluateAsRValue method.
10741 //===----------------------------------------------------------------------===//
10742 
10743 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
10744  // In C, function designators are not lvalues, but we evaluate them as if they
10745  // are.
10746  QualType T = E->getType();
10747  if (E->isGLValue() || T->isFunctionType()) {
10748  LValue LV;
10749  if (!EvaluateLValue(E, LV, Info))
10750  return false;
10751  LV.moveInto(Result);
10752  } else if (T->isVectorType()) {
10753  if (!EvaluateVector(E, Result, Info))
10754  return false;
10755  } else if (T->isIntegralOrEnumerationType()) {
10756  if (!IntExprEvaluator(Info, Result).Visit(E))
10757  return false;
10758  } else if (T->hasPointerRepresentation()) {
10759  LValue LV;
10760  if (!EvaluatePointer(E, LV, Info))
10761  return false;
10762  LV.moveInto(Result);
10763  } else if (T->isRealFloatingType()) {
10764  llvm::APFloat F(0.0);
10765  if (!EvaluateFloat(E, F, Info))
10766  return false;
10767  Result = APValue(F);
10768  } else if (T->isAnyComplexType()) {
10769  ComplexValue C;
10770  if (!EvaluateComplex(E, C, Info))
10771  return false;
10772  C.moveInto(Result);
10773  } else if (T->isFixedPointType()) {
10774  if (!FixedPointExprEvaluator(Info, Result).Visit(E)) return false;
10775  } else if (T->isMemberPointerType()) {
10776  MemberPtr P;
10777  if (!EvaluateMemberPointer(E, P, Info))
10778  return false;
10779  P.moveInto(Result);
10780  return true;
10781  } else if (T->isArrayType()) {
10782  LValue LV;
10783  APValue &Value = createTemporary(E, false, LV, *Info.CurrentCall);
10784  if (!EvaluateArray(E, LV, Value, Info))
10785  return false;
10786  Result = Value;
10787  } else if (T->isRecordType()) {
10788  LValue LV;
10789  APValue &Value = createTemporary(E, false, LV, *Info.CurrentCall);
10790  if (!EvaluateRecord(E, LV, Value, Info))
10791  return false;
10792  Result = Value;
10793  } else if (T->isVoidType()) {
10794  if (!Info.getLangOpts().CPlusPlus11)
10795  Info.CCEDiag(E, diag::note_constexpr_nonliteral)
10796  << E->getType();
10797  if (!EvaluateVoid(E, Info))
10798  return false;
10799  } else if (T->isAtomicType()) {
10800  QualType Unqual = T.getAtomicUnqualifiedType();
10801  if (Unqual->isArrayType() || Unqual->isRecordType()) {
10802  LValue LV;
10803  APValue &Value = createTemporary(E, false, LV, *Info.CurrentCall);
10804  if (!EvaluateAtomic(E, &LV, Value, Info))
10805  return false;
10806  } else {
10807  if (!EvaluateAtomic(E, nullptr, Result, Info))
10808  return false;
10809  }
10810  } else if (Info.getLangOpts().CPlusPlus11) {
10811  Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();
10812  return false;
10813  } else {
10814  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
10815  return false;
10816  }
10817 
10818  return true;
10819 }
10820 
10821 /// EvaluateInPlace - Evaluate an expression in-place in an APValue. In some
10822 /// cases, the in-place evaluation is essential, since later initializers for
10823 /// an object can indirectly refer to subobjects which were initialized earlier.
10824 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This,
10825  const Expr *E, bool AllowNonLiteralTypes) {
10826  assert(!E->isValueDependent());
10827 
10828  if (!AllowNonLiteralTypes && !CheckLiteralType(Info, E, &This))
10829  return false;
10830 
10831  if (E->isRValue()) {
10832  // Evaluate arrays and record types in-place, so that later initializers can
10833  // refer to earlier-initialized members of the object.
10834  QualType T = E->getType();
10835  if (T->isArrayType())
10836  return EvaluateArray(E, This, Result, Info);
10837  else if (T->isRecordType())
10838  return EvaluateRecord(E, This, Result, Info);
10839  else if (T->isAtomicType()) {
10840  QualType Unqual = T.getAtomicUnqualifiedType();
10841  if (Unqual->isArrayType() || Unqual->isRecordType())
10842  return EvaluateAtomic(E, &This, Result, Info);
10843  }
10844  }
10845 
10846  // For any other type, in-place evaluation is unimportant.
10847  return Evaluate(Result, Info, E);
10848 }
10849 
10850 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
10851 /// lvalue-to-rvalue cast if it is an lvalue.
10852 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
10853  if (E->getType().isNull())
10854  return false;
10855 
10856  if (!CheckLiteralType(Info, E))
10857  return false;
10858 
10859  if (!::Evaluate(Result, Info, E))
10860  return false;
10861 
10862  if (E->isGLValue()) {
10863  LValue LV;
10864  LV.setFrom(Info.Ctx, Result);
10865  if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
10866  return false;
10867  }
10868 
10869  // Check this core constant expression is a constant expression.
10870  return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result);
10871 }
10872 
10873 static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result,
10874  const ASTContext &Ctx, bool &IsConst) {
10875  // Fast-path evaluations of integer literals, since we sometimes see files
10876  // containing vast quantities of these.
10877  if (const IntegerLiteral *L = dyn_cast<IntegerLiteral>(Exp)) {
10878  Result.Val = APValue(APSInt(L->getValue(),
10879  L->getType()->isUnsignedIntegerType()));
10880  IsConst = true;
10881  return true;
10882  }
10883 
10884  // This case should be rare, but we need to check it before we check on
10885  // the type below.
10886  if (Exp->getType().isNull()) {
10887  IsConst = false;
10888  return true;
10889  }
10890 
10891  // FIXME: Evaluating values of large array and record types can cause
10892  // performance problems. Only do so in C++11 for now.
10893  if (Exp->isRValue() && (Exp->getType()->isArrayType() ||
10894  Exp->getType()->isRecordType()) &&
10895  !Ctx.getLangOpts().CPlusPlus11) {
10896  IsConst = false;
10897  return true;
10898  }
10899  return false;
10900 }
10901 
10903  Expr::SideEffectsKind SEK) {
10904  return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) ||
10906 }
10907 
10908 static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result,
10909  const ASTContext &Ctx, EvalInfo &Info) {
10910  bool IsConst;
10911  if (FastEvaluateAsRValue(E, Result, Ctx, IsConst))
10912  return IsConst;
10913 
10914  return EvaluateAsRValue(Info, E, Result.Val);
10915 }
10916 
10918  const ASTContext &Ctx,
10919  Expr::SideEffectsKind AllowSideEffects,
10920  EvalInfo &Info) {
10921  if (!E->getType()->isIntegralOrEnumerationType())
10922  return false;
10923 
10924  if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info) ||
10925  !ExprResult.Val.isInt() ||
10926  hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
10927  return false;
10928 
10929  return true;
10930 }
10931 
10932 /// EvaluateAsRValue - Return true if this is a constant which we can fold using
10933 /// any crazy technique (that has nothing to do with language standards) that
10934 /// we want to. If this function returns true, it returns the folded constant
10935 /// in Result. If this expression is a glvalue, an lvalue-to-rvalue conversion
10936 /// will be applied to the result.
10938  bool InConstantContext) const {
10939  EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
10940  Info.InConstantContext = InConstantContext;
10941  return ::EvaluateAsRValue(this, Result, Ctx, Info);
10942 }
10943 
10945  const ASTContext &Ctx) const {
10946  EvalResult Scratch;
10947  return EvaluateAsRValue(Scratch, Ctx) &&
10948  HandleConversionToBool(Scratch.Val, Result);
10949 }
10950 
10951 bool Expr::EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
10952  SideEffectsKind AllowSideEffects) const {
10953  EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
10954  return ::EvaluateAsInt(this, Result, Ctx, AllowSideEffects, Info);
10955 }
10956 
10957 bool Expr::EvaluateAsFloat(APFloat &Result, const ASTContext &Ctx,
10958  SideEffectsKind AllowSideEffects) const {
10959  if (!getType()->isRealFloatingType())
10960  return false;
10961 
10963  if (!EvaluateAsRValue(ExprResult, Ctx) || !ExprResult.Val.isFloat() ||
10964  hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
10965  return false;
10966 
10967  Result = ExprResult.Val.getFloat();
10968  return true;
10969 }
10970 
10971 bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const {
10972  EvalInfo Info(Ctx, Result, EvalInfo::EM_ConstantFold);
10973 
10974  LValue LV;
10975  if (!EvaluateLValue(this, LV, Info) || Result.HasSideEffects ||
10976  !CheckLValueConstantExpression(Info, getExprLoc(),
10977  Ctx.getLValueReferenceType(getType()), LV,
10979  return false;
10980 
10981  LV.moveInto(Result.Val);
10982  return true;
10983 }
10984 
10986  const ASTContext &Ctx) const {
10987  EvalInfo::EvaluationMode EM = EvalInfo::EM_ConstantExpression;
10988  EvalInfo Info(Ctx, Result, EM);
10989  if (!::Evaluate(Result.Val, Info, this))
10990  return false;
10991 
10992  return CheckConstantExpression(Info, getExprLoc(), getType(), Result.Val,
10993  Usage);
10994 }
10995 
10997  const VarDecl *VD,
10998  SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
10999  // FIXME: Evaluating initializers for large array and record types can cause
11000  // performance problems. Only do so in C++11 for now.
11001  if (isRValue() && (getType()->isArrayType() || getType()->isRecordType()) &&
11002  !Ctx.getLangOpts().CPlusPlus11)
11003  return false;
11004 
11005  Expr::EvalStatus EStatus;
11006  EStatus.Diag = &Notes;
11007 
11008  EvalInfo InitInfo(Ctx, EStatus, VD->isConstexpr()
11009  ? EvalInfo::EM_ConstantExpression
11010  : EvalInfo::EM_ConstantFold);
11011  InitInfo.setEvaluatingDecl(VD, Value);
11012  InitInfo.InConstantContext = true;
11013 
11014  LValue LVal;
11015  LVal.set(VD);
11016 
11017  // C++11 [basic.start.init]p2:
11018  // Variables with static storage duration or thread storage duration shall be
11019  // zero-initialized before any other initialization takes place.
11020  // This behavior is not present in C.
11021  if (Ctx.getLangOpts().CPlusPlus && !VD->hasLocalStorage() &&
11022  !VD->getType()->isReferenceType()) {
11023  ImplicitValueInitExpr VIE(VD->getType());
11024  if (!EvaluateInPlace(Value, InitInfo, LVal, &VIE,
11025  /*AllowNonLiteralTypes=*/true))
11026  return false;
11027  }
11028 
11029  if (!EvaluateInPlace(Value, InitInfo, LVal, this,
11030  /*AllowNonLiteralTypes=*/true) ||
11031  EStatus.HasSideEffects)
11032  return false;
11033 
11034  return CheckConstantExpression(InitInfo, VD->getLocation(), VD->getType(),
11035  Value);
11036 }
11037 
11038 /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
11039 /// constant folded, but discard the result.
11040 bool Expr::isEvaluatable(const ASTContext &Ctx, SideEffectsKind SEK) const {
11042  return EvaluateAsRValue(Result, Ctx, /* in constant context */ true) &&
11043  !hasUnacceptableSideEffect(Result, SEK);
11044 }
11045 
11048  EvalResult EVResult;
11049  EVResult.Diag = Diag;
11050  EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects);
11051  Info.InConstantContext = true;
11052 
11053  bool Result = ::EvaluateAsRValue(this, EVResult, Ctx, Info);
11054  (void)Result;
11055  assert(Result && "Could not evaluate expression");
11056  assert(EVResult.Val.isInt() && "Expression did not evaluate to integer");
11057 
11058  return EVResult.Val.getInt();
11059 }
11060 
11063  EvalResult EVResult;
11064  EVResult.Diag = Diag;
11065  EvalInfo Info(Ctx, EVResult, EvalInfo::EM_EvaluateForOverflow);
11066  Info.InConstantContext = true;
11067 
11068  bool Result = ::EvaluateAsRValue(Info, this, EVResult.Val);
11069  (void)Result;
11070  assert(Result && "Could not evaluate expression");
11071  assert(EVResult.Val.isInt() && "Expression did not evaluate to integer");
11072 
11073  return EVResult.Val.getInt();
11074 }
11075 
11076 void Expr::EvaluateForOverflow(const ASTContext &Ctx) const {
11077  bool IsConst;
11078  EvalResult EVResult;
11079  if (!FastEvaluateAsRValue(this, EVResult, Ctx, IsConst)) {
11080  EvalInfo Info(Ctx, EVResult, EvalInfo::EM_EvaluateForOverflow);
11081  (void)::EvaluateAsRValue(Info, this, EVResult.Val);
11082  }
11083 }
11084 
11086  assert(Val.isLValue());
11087  return IsGlobalLValue(Val.getLValueBase());
11088 }
11089 
11090 
11091 /// isIntegerConstantExpr - this recursive routine will test if an expression is
11092 /// an integer constant expression.
11093 
11094 /// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
11095 /// comma, etc
11096 
11097 // CheckICE - This function does the fundamental ICE checking: the returned
11098 // ICEDiag contains an ICEKind indicating whether the expression is an ICE,
11099 // and a (possibly null) SourceLocation indicating the location of the problem.
11100 //
11101 // Note that to reduce code duplication, this helper does no evaluation
11102 // itself; the caller checks whether the expression is evaluatable, and
11103 // in the rare cases where CheckICE actually cares about the evaluated
11104 // value, it calls into Evaluate.
11105 
11106 namespace {
11107 
11108 enum ICEKind {
11109  /// This expression is an ICE.
11110  IK_ICE,
11111  /// This expression is not an ICE, but if it isn't evaluated, it's
11112  /// a legal subexpression for an ICE. This return value is used to handle
11113  /// the comma operator in C99 mode, and non-constant subexpressions.
11114  IK_ICEIfUnevaluated,
11115  /// This expression is not an ICE, and is not a legal subexpression for one.
11116  IK_NotICE
11117 };
11118 
11119 struct ICEDiag {
11120  ICEKind Kind;
11121  SourceLocation Loc;
11122 
11123  ICEDiag(ICEKind IK, SourceLocation l) : Kind(IK), Loc(l) {}
11124 };
11125 
11126 }
11127 
11128 static ICEDiag NoDiag() { return ICEDiag(IK_ICE, SourceLocation()); }
11129 
11130 static ICEDiag Worst(ICEDiag A, ICEDiag B) { return A.Kind >= B.Kind ? A : B; }
11131 
11132 static ICEDiag CheckEvalInICE(const Expr* E, const ASTContext &Ctx) {
11133  Expr::EvalResult EVResult;
11134  Expr::EvalStatus Status;
11135  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
11136 
11137  Info.InConstantContext = true;
11138  if (!::EvaluateAsRValue(E, EVResult, Ctx, Info) || EVResult.HasSideEffects ||
11139  !EVResult.Val.isInt())
11140  return ICEDiag(IK_NotICE, E->getBeginLoc());
11141 
11142  return NoDiag();
11143 }
11144 
11145 static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
11146  assert(!E->isValueDependent() && "Should not see value dependent exprs!");
11147  if (!E->getType()->isIntegralOrEnumerationType())
11148  return ICEDiag(IK_NotICE, E->getBeginLoc());
11149 
11150  switch (E->getStmtClass()) {
11151 #define ABSTRACT_STMT(Node)
11152 #define STMT(Node, Base) case Expr::Node##Class:
11153 #define EXPR(Node, Base)
11154 #include "clang/AST/StmtNodes.inc"
11155  case Expr::PredefinedExprClass:
11156  case Expr::FloatingLiteralClass:
11157  case Expr::ImaginaryLiteralClass:
11158  case Expr::StringLiteralClass:
11159  case Expr::ArraySubscriptExprClass:
11160  case Expr::OMPArraySectionExprClass:
11161  case Expr::MemberExprClass:
11162  case Expr::CompoundAssignOperatorClass:
11163  case Expr::CompoundLiteralExprClass:
11164  case Expr::ExtVectorElementExprClass:
11165  case Expr::DesignatedInitExprClass:
11166  case Expr::ArrayInitLoopExprClass:
11167  case Expr::ArrayInitIndexExprClass:
11168  case Expr::NoInitExprClass:
11169  case Expr::DesignatedInitUpdateExprClass:
11170  case Expr::ImplicitValueInitExprClass:
11171  case Expr::ParenListExprClass:
11172  case Expr::VAArgExprClass:
11173  case Expr::AddrLabelExprClass:
11174  case Expr::StmtExprClass:
11175  case Expr::CXXMemberCallExprClass:
11176  case Expr::CUDAKernelCallExprClass:
11177  case Expr::CXXDynamicCastExprClass:
11178  case Expr::CXXTypeidExprClass:
11179  case Expr::CXXUuidofExprClass:
11180  case Expr::MSPropertyRefExprClass:
11181  case Expr::MSPropertySubscriptExprClass:
11182  case Expr::CXXNullPtrLiteralExprClass:
11183  case Expr::UserDefinedLiteralClass:
11184  case Expr::CXXThisExprClass:
11185  case Expr::CXXThrowExprClass:
11186  case Expr::CXXNewExprClass:
11187  case Expr::CXXDeleteExprClass:
11188  case Expr::CXXPseudoDestructorExprClass:
11189  case Expr::UnresolvedLookupExprClass:
11190  case Expr::TypoExprClass:
11191  case Expr::DependentScopeDeclRefExprClass:
11192  case Expr::CXXConstructExprClass:
11193  case Expr::CXXInheritedCtorInitExprClass:
11194  case Expr::CXXStdInitializerListExprClass:
11195  case Expr::CXXBindTemporaryExprClass:
11196  case Expr::ExprWithCleanupsClass:
11197  case Expr::CXXTemporaryObjectExprClass:
11198  case Expr::CXXUnresolvedConstructExprClass:
11199  case Expr::CXXDependentScopeMemberExprClass:
11200  case Expr::UnresolvedMemberExprClass:
11201  case Expr::ObjCStringLiteralClass:
11202  case Expr::ObjCBoxedExprClass:
11203  case Expr::ObjCArrayLiteralClass:
11204  case Expr::ObjCDictionaryLiteralClass:
11205  case Expr::ObjCEncodeExprClass:
11206  case Expr::ObjCMessageExprClass:
11207  case Expr::ObjCSelectorExprClass:
11208  case Expr::ObjCProtocolExprClass:
11209  case Expr::ObjCIvarRefExprClass:
11210  case Expr::ObjCPropertyRefExprClass:
11211  case Expr::ObjCSubscriptRefExprClass:
11212  case Expr::ObjCIsaExprClass:
11213  case Expr::ObjCAvailabilityCheckExprClass:
11214  case Expr::ShuffleVectorExprClass:
11215  case Expr::ConvertVectorExprClass:
11216  case Expr::BlockExprClass:
11217  case Expr::NoStmtClass:
11218  case Expr::OpaqueValueExprClass:
11219  case Expr::PackExpansionExprClass:
11220  case Expr::SubstNonTypeTemplateParmPackExprClass:
11221  case Expr::FunctionParmPackExprClass:
11222  case Expr::AsTypeExprClass:
11223  case Expr::ObjCIndirectCopyRestoreExprClass:
11224  case Expr::MaterializeTemporaryExprClass:
11225  case Expr::PseudoObjectExprClass:
11226  case Expr::AtomicExprClass:
11227  case Expr::LambdaExprClass:
11228  case Expr::CXXFoldExprClass:
11229  case Expr::CoawaitExprClass:
11230  case Expr::DependentCoawaitExprClass:
11231  case Expr::CoyieldExprClass:
11232  return ICEDiag(IK_NotICE, E->getBeginLoc());
11233 
11234  case Expr::InitListExprClass: {
11235  // C++03 [dcl.init]p13: If T is a scalar type, then a declaration of the
11236  // form "T x = { a };" is equivalent to "T x = a;".
11237  // Unless we're initializing a reference, T is a scalar as it is known to be
11238  // of integral or enumeration type.
11239  if (E->isRValue())
11240  if (cast<InitListExpr>(E)->getNumInits() == 1)
11241  return CheckICE(cast<InitListExpr>(E)->getInit(0), Ctx);
11242  return ICEDiag(IK_NotICE, E->getBeginLoc());
11243  }
11244 
11245  case Expr::SizeOfPackExprClass:
11246  case Expr::GNUNullExprClass:
11247  // GCC considers the GNU __null value to be an integral constant expression.
11248  return NoDiag();
11249 
11250  case Expr::SubstNonTypeTemplateParmExprClass:
11251  return
11252  CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), Ctx);
11253 
11254  case Expr::ConstantExprClass:
11255  return CheckICE(cast<ConstantExpr>(E)->getSubExpr(), Ctx);
11256 
11257  case Expr::ParenExprClass:
11258  return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
11259  case Expr::GenericSelectionExprClass:
11260  return CheckICE(cast<GenericSelectionExpr>(E)->getResultExpr(), Ctx);
11261  case Expr::IntegerLiteralClass:
11262  case Expr::FixedPointLiteralClass:
11263  case Expr::CharacterLiteralClass:
11264  case Expr::ObjCBoolLiteralExprClass:
11265  case Expr::CXXBoolLiteralExprClass:
11266  case Expr::CXXScalarValueInitExprClass:
11267  case Expr::TypeTraitExprClass:
11268  case Expr::ArrayTypeTraitExprClass:
11269  case Expr::ExpressionTraitExprClass:
11270  case Expr::CXXNoexceptExprClass:
11271  return NoDiag();
11272  case Expr::CallExprClass:
11273  case Expr::CXXOperatorCallExprClass: {
11274  // C99 6.6/3 allows function calls within unevaluated subexpressions of
11275  // constant expressions, but they can never be ICEs because an ICE cannot
11276  // contain an operand of (pointer to) function type.
11277  const CallExpr *CE = cast<CallExpr>(E);
11278  if (CE->getBuiltinCallee())
11279  return CheckEvalInICE(E, Ctx);
11280  return ICEDiag(IK_NotICE, E->getBeginLoc());
11281  }
11282  case Expr::DeclRefExprClass: {
11283  if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
11284  return NoDiag();
11285  const ValueDecl *D = cast<DeclRefExpr>(E)->getDecl();
11286  if (Ctx.getLangOpts().CPlusPlus &&
11287  D && IsConstNonVolatile(D->getType())) {
11288  // Parameter variables are never constants. Without this check,
11289  // getAnyInitializer() can find a default argument, which leads
11290  // to chaos.
11291  if (isa<ParmVarDecl>(D))
11292  return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
11293 
11294  // C++ 7.1.5.1p2
11295  // A variable of non-volatile const-qualified integral or enumeration
11296  // type initialized by an ICE can be used in ICEs.
11297  if (const VarDecl *Dcl = dyn_cast<VarDecl>(D)) {
11298  if (!Dcl->getType()->isIntegralOrEnumerationType())
11299  return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
11300 
11301  const VarDecl *VD;
11302  // Look for a declaration of this variable that has an initializer, and
11303  // check whether it is an ICE.
11304  if (Dcl->getAnyInitializer(VD) && VD->checkInitIsICE())
11305  return NoDiag();
11306  else
11307  return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
11308  }
11309  }
11310  return ICEDiag(IK_NotICE, E->getBeginLoc());
11311  }
11312  case Expr::UnaryOperatorClass: {
11313  const UnaryOperator *Exp = cast<UnaryOperator>(E);
11314  switch (Exp->getOpcode()) {
11315  case UO_PostInc:
11316  case UO_PostDec:
11317  case UO_PreInc:
11318  case UO_PreDec:
11319  case UO_AddrOf:
11320  case UO_Deref:
11321  case UO_Coawait:
11322  // C99 6.6/3 allows increment and decrement within unevaluated
11323  // subexpressions of constant expressions, but they can never be ICEs
11324  // because an ICE cannot contain an lvalue operand.
11325  return ICEDiag(IK_NotICE, E->getBeginLoc());
11326  case UO_Extension:
11327  case UO_LNot:
11328  case UO_Plus:
11329  case UO_Minus:
11330  case UO_Not:
11331  case UO_Real:
11332  case UO_Imag:
11333  return CheckICE(Exp->getSubExpr(), Ctx);
11334  }
11335  llvm_unreachable("invalid unary operator class");
11336  }
11337  case Expr::OffsetOfExprClass: {
11338  // Note that per C99, offsetof must be an ICE. And AFAIK, using
11339  // EvaluateAsRValue matches the proposed gcc behavior for cases like
11340  // "offsetof(struct s{int x[4];}, x[1.0])". This doesn't affect
11341  // compliance: we should warn earlier for offsetof expressions with
11342  // array subscripts that aren't ICEs, and if the array subscripts
11343  // are ICEs, the value of the offsetof must be an integer constant.
11344  return CheckEvalInICE(E, Ctx);
11345  }
11346  case Expr::UnaryExprOrTypeTraitExprClass: {
11347  const UnaryExprOrTypeTraitExpr *Exp = cast<UnaryExprOrTypeTraitExpr>(E);
11348  if ((Exp->getKind() == UETT_SizeOf) &&
11350  return ICEDiag(IK_NotICE, E->getBeginLoc());
11351  return NoDiag();
11352  }
11353  case Expr::BinaryOperatorClass: {
11354  const BinaryOperator *Exp = cast<BinaryOperator>(E);
11355  switch (Exp->getOpcode()) {
11356  case BO_PtrMemD:
11357  case BO_PtrMemI:
11358  case BO_Assign:
11359  case BO_MulAssign:
11360  case BO_DivAssign:
11361  case BO_RemAssign:
11362  case BO_AddAssign:
11363  case BO_SubAssign:
11364  case BO_ShlAssign:
11365  case BO_ShrAssign:
11366  case BO_AndAssign:
11367  case BO_XorAssign:
11368  case BO_OrAssign:
11369  // C99 6.6/3 allows assignments within unevaluated subexpressions of
11370  // constant expressions, but they can never be ICEs because an ICE cannot
11371  // contain an lvalue operand.
11372  return ICEDiag(IK_NotICE, E->getBeginLoc());
11373 
11374  case BO_Mul:
11375  case BO_Div:
11376  case BO_Rem:
11377  case BO_Add:
11378  case BO_Sub:
11379  case BO_Shl:
11380  case BO_Shr:
11381  case BO_LT:
11382  case BO_GT:
11383  case BO_LE:
11384  case BO_GE:
11385  case BO_EQ:
11386  case BO_NE:
11387  case BO_And:
11388  case BO_Xor:
11389  case BO_Or:
11390  case BO_Comma:
11391  case BO_Cmp: {
11392  ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
11393  ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
11394  if (Exp->getOpcode() == BO_Div ||
11395  Exp->getOpcode() == BO_Rem) {
11396  // EvaluateAsRValue gives an error for undefined Div/Rem, so make sure
11397  // we don't evaluate one.
11398  if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) {
11399  llvm::APSInt REval = Exp->getRHS()->EvaluateKnownConstInt(Ctx);
11400  if (REval == 0)
11401  return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
11402  if (REval.isSigned() && REval.isAllOnesValue()) {
11403  llvm::APSInt LEval = Exp->getLHS()->EvaluateKnownConstInt(Ctx);
11404  if (LEval.isMinSignedValue())
11405  return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
11406  }
11407  }
11408  }
11409  if (Exp->getOpcode() == BO_Comma) {
11410  if (Ctx.getLangOpts().C99) {
11411  // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
11412  // if it isn't evaluated.
11413  if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE)
11414  return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
11415  } else {
11416  // In both C89 and C++, commas in ICEs are illegal.
11417  return ICEDiag(IK_NotICE, E->getBeginLoc());
11418  }
11419  }
11420  return Worst(LHSResult, RHSResult);
11421  }
11422  case BO_LAnd:
11423  case BO_LOr: {
11424  ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
11425  ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
11426  if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICEIfUnevaluated) {
11427  // Rare case where the RHS has a comma "side-effect"; we need
11428  // to actually check the condition to see whether the side
11429  // with the comma is evaluated.
11430  if ((Exp->getOpcode() == BO_LAnd) !=
11431  (Exp->getLHS()->EvaluateKnownConstInt(Ctx) == 0))
11432  return RHSResult;
11433  return NoDiag();
11434  }
11435 
11436  return Worst(LHSResult, RHSResult);
11437  }
11438  }
11439  llvm_unreachable("invalid binary operator kind");
11440  }
11441  case Expr::ImplicitCastExprClass:
11442  case Expr::CStyleCastExprClass:
11443  case Expr::CXXFunctionalCastExprClass:
11444  case Expr::CXXStaticCastExprClass:
11445  case Expr::CXXReinterpretCastExprClass:
11446  case Expr::CXXConstCastExprClass:
11447  case Expr::ObjCBridgedCastExprClass: {
11448  const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
11449  if (isa<ExplicitCastExpr>(E)) {
11450  if (const FloatingLiteral *FL
11451  = dyn_cast<FloatingLiteral>(SubExpr->IgnoreParenImpCasts())) {
11452  unsigned DestWidth = Ctx.getIntWidth(E->getType());
11453  bool DestSigned = E->getType()->isSignedIntegerOrEnumerationType();
11454  APSInt IgnoredVal(DestWidth, !DestSigned);
11455  bool Ignored;
11456  // If the value does not fit in the destination type, the behavior is
11457  // undefined, so we are not required to treat it as a constant
11458  // expression.
11459  if (FL->getValue().convertToInteger(IgnoredVal,
11460  llvm::APFloat::rmTowardZero,
11461  &Ignored) & APFloat::opInvalidOp)
11462  return ICEDiag(IK_NotICE, E->getBeginLoc());
11463  return NoDiag();
11464  }
11465  }
11466  switch (cast<CastExpr>(E)->getCastKind()) {
11467  case CK_LValueToRValue:
11468  case CK_AtomicToNonAtomic:
11469  case CK_NonAtomicToAtomic:
11470  case CK_NoOp:
11471  case CK_IntegralToBoolean:
11472  case CK_IntegralCast:
11473  return CheckICE(SubExpr, Ctx);
11474  default:
11475  return ICEDiag(IK_NotICE, E->getBeginLoc());
11476  }
11477  }
11478  case Expr::BinaryConditionalOperatorClass: {
11479  const BinaryConditionalOperator *Exp = cast<BinaryConditionalOperator>(E);
11480  ICEDiag CommonResult = CheckICE(Exp->getCommon(), Ctx);
11481  if (CommonResult.Kind == IK_NotICE) return CommonResult;
11482  ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
11483  if (FalseResult.Kind == IK_NotICE) return FalseResult;
11484  if (CommonResult.Kind == IK_ICEIfUnevaluated) return CommonResult;
11485  if (FalseResult.Kind == IK_ICEIfUnevaluated &&
11486  Exp->getCommon()->EvaluateKnownConstInt(Ctx) != 0) return NoDiag();
11487  return FalseResult;
11488  }
11489  case Expr::ConditionalOperatorClass: {
11490  const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
11491  // If the condition (ignoring parens) is a __builtin_constant_p call,
11492  // then only the true side is actually considered in an integer constant
11493  // expression, and it is fully evaluated. This is an important GNU
11494  // extension. See GCC PR38377 for discussion.
11495  if (const CallExpr *CallCE
11496  = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
11497  if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
11498  return CheckEvalInICE(E, Ctx);
11499  ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
11500  if (CondResult.Kind == IK_NotICE)
11501  return CondResult;
11502 
11503  ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
11504  ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
11505 
11506  if (TrueResult.Kind == IK_NotICE)
11507  return TrueResult;
11508  if (FalseResult.Kind == IK_NotICE)
11509  return FalseResult;
11510  if (CondResult.Kind == IK_ICEIfUnevaluated)
11511  return CondResult;
11512  if (TrueResult.Kind == IK_ICE && FalseResult.Kind == IK_ICE)
11513  return NoDiag();
11514  // Rare case where the diagnostics depend on which side is evaluated
11515  // Note that if we get here, CondResult is 0, and at least one of
11516  // TrueResult and FalseResult is non-zero.
11517  if (Exp->getCond()->EvaluateKnownConstInt(Ctx) == 0)
11518  return FalseResult;
11519  return TrueResult;
11520  }
11521  case Expr::CXXDefaultArgExprClass:
11522  return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
11523  case Expr::CXXDefaultInitExprClass:
11524  return CheckICE(cast<CXXDefaultInitExpr>(E)->getExpr(), Ctx);
11525  case Expr::ChooseExprClass: {
11526  return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(), Ctx);
11527  }
11528  }
11529 
11530  llvm_unreachable("Invalid StmtClass!");
11531 }
11532 
11533 /// Evaluate an expression as a C++11 integral constant expression.
11535  const Expr *E,
11536  llvm::APSInt *Value,
11537  SourceLocation *Loc) {
11539  if (Loc) *Loc = E->getExprLoc();
11540  return false;
11541  }
11542 
11543  APValue Result;
11544  if (!E->isCXX11ConstantExpr(Ctx, &Result, Loc))
11545  return false;
11546 
11547  if (!Result.isInt()) {
11548  if (Loc) *Loc = E->getExprLoc();
11549  return false;
11550  }
11551 
11552  if (Value) *Value = Result.getInt();
11553  return true;
11554 }
11555 
11557  SourceLocation *Loc) const {
11558  if (Ctx.getLangOpts().CPlusPlus11)
11559  return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, nullptr, Loc);
11560 
11561  ICEDiag D = CheckICE(this, Ctx);
11562  if (D.Kind != IK_ICE) {
11563  if (Loc) *Loc = D.Loc;
11564  return false;
11565  }
11566  return true;
11567 }
11568 
11569 bool Expr::isIntegerConstantExpr(llvm::APSInt &Value, const ASTContext &Ctx,
11570  SourceLocation *Loc, bool isEvaluated) const {
11571  if (Ctx.getLangOpts().CPlusPlus11)
11572  return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc);
11573 
11574  if (!isIntegerConstantExpr(Ctx, Loc))
11575  return false;
11576 
11577  // The only possible side-effects here are due to UB discovered in the
11578  // evaluation (for instance, INT_MAX + 1). In such a case, we are still
11579  // required to treat the expression as an ICE, so we produce the folded
11580  // value.
11582  Expr::EvalStatus Status;
11583  EvalInfo Info(Ctx, Status, EvalInfo::EM_IgnoreSideEffects);
11584  Info.InConstantContext = true;
11585 
11586  if (!::EvaluateAsInt(this, ExprResult, Ctx, SE_AllowSideEffects, Info))
11587  llvm_unreachable("ICE cannot be evaluated!");
11588 
11589  Value = ExprResult.Val.getInt();
11590  return true;
11591 }
11592 
11594  return CheckICE(this, Ctx).Kind == IK_ICE;
11595 }
11596 
11598  SourceLocation *Loc) const {
11599  // We support this checking in C++98 mode in order to diagnose compatibility
11600  // issues.
11601  assert(Ctx.getLangOpts().CPlusPlus);
11602 
11603  // Build evaluation settings.
11604  Expr::EvalStatus Status;
11606  Status.Diag = &Diags;
11607  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
11608 
11609  APValue Scratch;
11610  bool IsConstExpr = ::EvaluateAsRValue(Info, this, Result ? *Result : Scratch);
11611 
11612  if (!Diags.empty()) {
11613  IsConstExpr = false;
11614  if (Loc) *Loc = Diags[0].first;
11615  } else if (!IsConstExpr) {
11616  // FIXME: This shouldn't happen.
11617  if (Loc) *Loc = getExprLoc();
11618  }
11619 
11620  return IsConstExpr;
11621 }
11622 
11624  const FunctionDecl *Callee,
11625  ArrayRef<const Expr*> Args,
11626  const Expr *This) const {
11627  Expr::EvalStatus Status;
11628  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpressionUnevaluated);
11629 
11630  LValue ThisVal;
11631  const LValue *ThisPtr = nullptr;
11632  if (This) {
11633 #ifndef NDEBUG
11634  auto *MD = dyn_cast<CXXMethodDecl>(Callee);
11635  assert(MD && "Don't provide `this` for non-methods.");
11636  assert(!MD->isStatic() && "Don't provide `this` for static methods.");
11637 #endif
11638  if (EvaluateObjectArgument(Info, This, ThisVal))
11639  ThisPtr = &ThisVal;
11640  if (Info.EvalStatus.HasSideEffects)
11641  return false;
11642  }
11643 
11644  ArgVector ArgValues(Args.size());
11645  for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end();
11646  I != E; ++I) {
11647  if ((*I)->isValueDependent() ||
11648  !Evaluate(ArgValues[I - Args.begin()], Info, *I))
11649  // If evaluation fails, throw away the argument entirely.
11650  ArgValues[I - Args.begin()] = APValue();
11651  if (Info.EvalStatus.HasSideEffects)
11652  return false;
11653  }
11654 
11655  // Build fake call to Callee.
11656  CallStackFrame Frame(Info, Callee->getLocation(), Callee, ThisPtr,
11657  ArgValues.data());
11658  return Evaluate(Value, Info, this) && !Info.EvalStatus.HasSideEffects;
11659 }
11660 
11663  PartialDiagnosticAt> &Diags) {
11664  // FIXME: It would be useful to check constexpr function templates, but at the
11665  // moment the constant expression evaluator cannot cope with the non-rigorous
11666  // ASTs which we build for dependent expressions.
11667  if (FD->isDependentContext())
11668  return true;
11669 
11670  Expr::EvalStatus Status;
11671  Status.Diag = &Diags;
11672 
11673  EvalInfo Info(FD->getASTContext(), Status,
11674  EvalInfo::EM_PotentialConstantExpression);
11675  Info.InConstantContext = true;
11676 
11677  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
11678  const CXXRecordDecl *RD = MD ? MD->getParent()->getCanonicalDecl() : nullptr;
11679 
11680  // Fabricate an arbitrary expression on the stack and pretend that it
11681  // is a temporary being used as the 'this' pointer.
11682  LValue This;
11683  ImplicitValueInitExpr VIE(RD ? Info.Ctx.getRecordType(RD) : Info.Ctx.IntTy);
11684  This.set({&VIE, Info.CurrentCall->Index});
11685 
11686  ArrayRef<const Expr*> Args;
11687 
11688  APValue Scratch;
11689  if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
11690  // Evaluate the call as a constant initializer, to allow the construction
11691  // of objects of non-literal types.
11692  Info.setEvaluatingDecl(This.getLValueBase(), Scratch);
11693  HandleConstructorCall(&VIE, This, Args, CD, Info, Scratch);
11694  } else {
11695  SourceLocation Loc = FD->getLocation();
11696  HandleFunctionCall(Loc, FD, (MD && MD->isInstance()) ? &This : nullptr,
11697  Args, FD->getBody(), Info, Scratch, nullptr);
11698  }
11699 
11700  return Diags.empty();
11701 }
11702 
11704  const FunctionDecl *FD,
11706  PartialDiagnosticAt> &Diags) {
11707  Expr::EvalStatus Status;
11708  Status.Diag = &Diags;
11709 
11710  EvalInfo Info(FD->getASTContext(), Status,
11711  EvalInfo::EM_PotentialConstantExpressionUnevaluated);
11712 
11713  // Fabricate a call stack frame to give the arguments a plausible cover story.
11714  ArrayRef<const Expr*> Args;
11715  ArgVector ArgValues(0);
11716  bool Success = EvaluateArgs(Args, ArgValues, Info);
11717  (void)Success;
11718  assert(Success &&
11719  "Failed to set up arguments for potential constant evaluation");
11720  CallStackFrame Frame(Info, SourceLocation(), FD, nullptr, ArgValues.data());
11721 
11722  APValue ResultScratch;
11723  Evaluate(ResultScratch, Info, E);
11724  return Diags.empty();
11725 }
11726 
11727 bool Expr::tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
11728  unsigned Type) const {
11729  if (!getType()->isPointerType())
11730  return false;
11731 
11732  Expr::EvalStatus Status;
11733  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
11734  return tryEvaluateBuiltinObjectSize(this, Type, Info, Result);
11735 }
Expr * getInc()
Definition: Stmt.h:2270
const Expr * getSubExpr() const
Definition: Expr.h:890
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
Definition: Expr.h:4294
static Address castToBase(CodeGenFunction &CGF, QualType BaseTy, QualType ElTy, llvm::Type *BaseLVType, CharUnits BaseLVAlignment, llvm::Value *Addr)
static bool HandleConstructorCall(const Expr *E, const LValue &This, APValue *ArgValues, const CXXConstructorDecl *Definition, EvalInfo &Info, APValue &Result)
Evaluate a constructor call.
Defines the clang::ASTContext interface.
const BlockDecl * getBlockDecl() const
Definition: Expr.h:5196
bool path_empty() const
Definition: Expr.h:3073
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:596
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:4023
Represents a function declaration or definition.
Definition: Decl.h:1738
bool getValue() const
Definition: ExprObjC.h:94
bool getValue() const
Definition: ExprCXX.h:2473
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition: Type.h:6591
Expr ** getArgs()
Retrieve the call arguments.
Definition: Expr.h:2543
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
body_iterator body_end()
Definition: Stmt.h:1276
static bool IsGlobalLValue(APValue::LValueBase B)
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2537
A (possibly-)qualified type.
Definition: Type.h:638
uint64_t getValue() const
Definition: ExprCXX.h:2559
Static storage duration.
Definition: Specifiers.h:281
base_class_range bases()
Definition: DeclCXX.h:823
bool isArrayType() const
Definition: Type.h:6345
bool isMemberPointerType() const
Definition: Type.h:6327
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2778
static Opcode getOpForCompoundAssignment(Opcode Opc)
Definition: Expr.h:3426
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2553
bool hasCaptures() const
True if this block (or its nested blocks) captures anything of local storage from its enclosing scope...
Definition: Decl.h:3977
SourceLocation getExprLoc() const
Definition: Expr.h:3323
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:1900
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:817
static QualType getObjectType(APValue::LValueBase B)
Retrieves the "underlying object type" of the given expression, as used by __builtin_object_size.
const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr *> &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...
Definition: Expr.cpp:76
bool operator==(CanQual< T > x, CanQual< U > y)
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:193
Expr * getCond()
Definition: Stmt.h:2112
llvm::APSInt EvaluateKnownConstIntCheckOverflow(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2430
CompoundStmt * getSubStmt()
Definition: Expr.h:3822
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4238
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
Stmt - This represents one statement.
Definition: Stmt.h:66
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2540
Kind getKind() const
Definition: Type.h:2418
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1687
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:233
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2786
bool EvaluateAsInitializer(APValue &Result, const ASTContext &Ctx, const VarDecl *VD, SmallVectorImpl< PartialDiagnosticAt > &Notes) const
EvaluateAsInitializer - Evaluate an expression as if it were the initializer of the given declaration...
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1937
tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")
Clean up any erroneous/redundant code in the given Ranges in Code.
Definition: Format.cpp:2228
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:838
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:807
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2094
bool isRecordType() const
Definition: Type.h:6369
static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result, EvalInfo &Info)
Expr * getBase() const
Definition: Expr.h:2772
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
__DEVICE__ long long abs(long long __n)
llvm::APFloat getValue() const
Definition: Expr.h:1459
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition: Expr.h:4863
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2132
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:245
ConstExprUsage
Indicates how the constant expression will be used.
Definition: Expr.h:668
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic, and whose semantics are that of the sole contained initializer)?
Definition: Expr.cpp:2059
Opcode getOpcode() const
Definition: Expr.h:3327
StringRef P
static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result, Expr::SideEffectsKind SEK)
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
Definition: Decl.cpp:3797
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1844
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6245
static bool extractSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, APValue &Result)
Extract the designated sub-object of an rvalue.
bool isUninit() const
Definition: APValue.h:233
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:336
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
Definition: Decl.h:2763
The base class of the type hierarchy.
Definition: Type.h:1407
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called...
Definition: ExprCXX.h:1373
bool isVector() const
Definition: APValue.h:239
DiagnosticsEngine & getDiagnostics() const
static void addOrSubLValueAsInteger(APValue &LVal, const APSInt &Index, bool IsSub)
static bool IsConstNonVolatile(QualType T)
void * BaseOrMember
BaseOrMember - The FieldDecl or CXXRecordDecl indicating the next item in the path.
Definition: APValue.h:112
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2812
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1262
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Definition: ExprCXX.h:2514
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:414
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:690
static bool isOnePastTheEndOfCompleteObject(const ASTContext &Ctx, const LValue &LV)
Determine whether this is a pointer past the end of the complete object referred to by the lvalue...
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5983
llvm::DenseMap< Stmt *, Stmt * > MapTy
Definition: ParentMap.cpp:23
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to...
Definition: Decl.h:1210
static const ValueDecl * HandleMemberPointerAccess(EvalInfo &Info, QualType LVType, LValue &LV, const Expr *RHS, bool IncludeMember=true)
HandleMemberPointerAccess - Evaluate a member access operation and build an lvalue referring to the r...
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:26
ArrayRef< ParmVarDecl * >::const_iterator param_const_iterator
Definition: Decl.h:2271
static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result, EvalInfo &Info)
EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and produce either the intege...
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2484
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4156
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
const Expr * getResultExpr() const
The generic selection&#39;s result expression.
Definition: Expr.h:5091
GCCTypeClass
Values returned by __builtin_classify_type, chosen to match the values produced by GCC&#39;s builtin...
static bool CheckMemberPointerConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const APValue &Value, Expr::ConstExprUsage Usage)
Member pointers are constant expressions unless they point to a non-virtual dllimport member function...
QualType getElementType() const
Definition: Type.h:2847
const Expr * getSubExpr() const
Definition: Expr.h:1529
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2356
Expr * getIndexExpr(unsigned Idx)
Definition: Expr.h:2180
static bool EvaluateDecl(EvalInfo &Info, const Decl *D)
const CXXBaseSpecifier *const * path_const_iterator
Definition: Expr.h:3072
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:1884
This file provides some common utility functions for processing Lambda related AST Constructs...
Represents a variable declaration or definition.
Definition: Decl.h:813
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:268
static void negateAsSigned(APSInt &Int)
Negate an APSInt in place, converting it to a signed form if necessary, and preserving its value (by ...
static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This, const Expr *E, bool AllowNonLiteralTypes=false)
EvaluateInPlace - Evaluate an expression in-place in an APValue.
QualType getReturnType() const
Definition: Decl.h:2302
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2930
static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E)
APFloat & getComplexFloatReal()
Definition: APValue.h:284
OpaqueValueExpr * getCommonExpr() const
Get the common subexpression shared by all initializations (the source array).
Definition: Expr.h:4825
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6748
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
Definition: Type.h:6679
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type...
Definition: Type.h:6820
ArrayRef< LValuePathEntry > getLValuePath() const
Definition: APValue.cpp:623
bool field_empty() const
Definition: Decl.h:3792
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:624
static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx, const CallExpr *Call, llvm::APInt &Result)
Attempts to compute the number of bytes available at the pointer returned by a function with the allo...
bool isInvalidDecl() const
Definition: DeclBase.h:542
Stmt * getThen()
Definition: Stmt.h:1774
static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E)
Evaluate an expression to see if it had side-effects, and discard its result.
bool isAddrLabelDiff() const
Definition: APValue.h:244
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
Definition: ExprCXX.h:1483
bool isStatic() const
Definition: DeclCXX.cpp:1872
Expr * getExprOperand() const
Definition: ExprCXX.h:726
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3089
static bool isAssignmentOp(Opcode Opc)
Definition: Expr.h:3415
Represents a parameter to a function.
Definition: Decl.h:1550
static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int, CharUnits &Result)
Converts the given APInt to CharUnits, assuming the APInt is unsigned.
The collection of all-type qualifiers we support.
Definition: Type.h:141
bool isVariableArrayType() const
Definition: Type.h:6357
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Definition: ExprCXX.cpp:1196
bool isLValueOnePastTheEnd() const
Definition: APValue.cpp:608
static bool HasSameBase(const LValue &A, const LValue &B)
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:668
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:3167
Represents a struct/union/class.
Definition: Decl.h:3593
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1327
unsigned getVersion() const
Definition: APValue.h:94
Stmt * getBody()
Definition: Stmt.h:2210
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4197
static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc, QualType Type, CharUnits &Size)
Get the size of the given type in char units.
Expr * getFalseExpr() const
Definition: Expr.h:3630
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:2774
FieldDecl * getField() const
For a field offsetof node, returns the field.
Definition: Expr.h:2077
static bool TryEvaluateBuiltinNaN(const ASTContext &Context, QualType ResultTy, const Expr *Arg, bool SNaN, llvm::APFloat &Result)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
static bool EvaluateVector(const Expr *E, APValue &Result, EvalInfo &Info)
bool isFileScope() const
Definition: Expr.h:2960
Used for GCC&#39;s __alignof.
Definition: TypeTraits.h:107
field_range fields() const
Definition: Decl.h:3784
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:288
static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal)
Attempts to detect a user writing into a piece of memory that&#39;s impossible to figure out the size of ...
Represents a member of a struct/union/class.
Definition: Decl.h:2579
static bool isPtrMemOp(Opcode Opc)
predicates to categorize the respective opcodes.
Definition: Expr.h:3359
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
Definition: TypeTraits.h:97
bool isPowerOfTwo() const
isPowerOfTwo - Test whether the quantity is a power of two.
Definition: CharUnits.h:129
unsigned getCallIndex() const
Definition: APValue.h:86
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
Definition: Expr.h:2071
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:4062
bool isReferenceType() const
Definition: Type.h:6308
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2679
Stmt *const * const_body_iterator
Definition: Stmt.h:1288
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition: Expr.h:1003
unsigned getArraySize() const
Definition: APValue.h:348
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6511
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:241
Expr * getSubExpr()
Definition: Expr.h:3055
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:739
static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E, const RecordDecl *RD, const LValue &This, APValue &Result)
Perform zero-initialization on an object of non-union class type.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
unsigned getCharByteWidth() const
Definition: Expr.h:1679
ComparisonCategoryResult
An enumeration representing the possible results of a three-way comparison.
bool isFloat() const
Definition: APValue.h:235
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6644
static bool isRelationalOp(Opcode Opc)
Definition: Expr.h:3376
static bool IsWeakLValue(const LValue &Value)
bool isGLValue() const
Definition: Expr.h:252
static ICEDiag CheckEvalInICE(const Expr *E, const ASTContext &Ctx)
Describes an C or C++ initializer list.
Definition: Expr.h:4190
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:669
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const
EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boo...
static const Expr * ignorePointerCastsAndParens(const Expr *E)
A more selective version of E->IgnoreParenCasts for tryEvaluateBuiltinObjectSize. ...
BinaryOperatorKind
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2657
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Definition: Expr.h:558
ForStmt - This represents a &#39;for (init;cond;inc)&#39; stmt.
Definition: Stmt.h:2237
unsigned getLength() const
Definition: Expr.h:1678
static bool isEqualityOp(Opcode Opc)
Definition: Expr.h:3379
static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E, llvm::APInt &Res)
bool isDelegatingConstructor() const
Determine whether this constructor is a delegating constructor.
Definition: DeclCXX.h:2594
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2731
bool isElidable() const
Whether this construction is elidable.
Definition: ExprCXX.h:1340
bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsFloat - Return true if this is a constant which we can fold and convert to a floating point...
static bool refersToCompleteObject(const LValue &LVal)
Tests to see if the LValue has a user-specified designator (that isn&#39;t necessarily valid)...
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:573
static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, QualType Type, const LValue &LVal, APValue &RVal)
Perform an lvalue-to-rvalue conversion on the given glvalue.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2205
bool EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx, const FunctionDecl *Callee, ArrayRef< const Expr *> Args, const Expr *This=nullptr) const
EvaluateWithSubstitution - Evaluate an expression as if from the context of a call to the given funct...
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1794
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:2847
path_iterator path_begin()
Definition: Expr.h:3075
Stmt * getBody()
Definition: Stmt.h:2271
static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E, LValue &Result)
HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on the provided lvalue...
static bool isRecordType(QualType T)
std::string getAsString(ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:595
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3292
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6142
static bool CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc, QualType Type, const APValue &Value, Expr::ConstExprUsage Usage=Expr::EvaluateForCodeGen)
Check that this core constant expression value is a valid value for a constant expression.
Stmt * getInit()
Definition: Stmt.h:2250
bool isComplexFloat() const
Definition: APValue.h:237
CXXForRangeStmt - This represents C++0x [stmt.ranged]&#39;s ranged for statement, represented as &#39;for (ra...
Definition: StmtCXX.h:127
bool isComplexInt() const
Definition: APValue.h:236
bool isArrow() const
Definition: Expr.h:2879
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1382
void printPretty(raw_ostream &OS, ASTContext &Ctx, QualType Ty) const
Definition: APValue.cpp:386
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2595
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:51
static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal, QualType LValType, bool IsIncrement, APValue *Old)
Perform an increment or decrement on LVal.
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6072
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:728
field_iterator field_begin() const
Definition: Decl.cpp:4145
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3787
CaseStmt - Represent a case statement.
Definition: Stmt.h:1394
static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E, UnaryExprOrTypeTrait ExprKind)
Expr * getCond()
Definition: Stmt.h:2269
bool isInt() const
Definition: APValue.h:234
static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit, uint64_t Index)
Extract the value of a character from a string literal.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3003
static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType)
Find the complete object to which an LValue refers.
base_class_iterator bases_begin()
Definition: DeclCXX.h:830
Helper class for OffsetOfExpr.
Definition: Expr.h:2013
static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E, LValue &LVal, QualType EltTy, bool Imag)
Update an lvalue to refer to a component of a complex number.
static void expandArray(APValue &Array, unsigned Index)
bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const
isCXX98IntegralConstantExpr - Return true if this expression is an integral constant expression in C+...
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1649
bool isInstance() const
Definition: DeclCXX.h:2069
#define UINT_MAX
Definition: limits.h:72
bool isEquality() const
True iff the comparison category is an equality comparison.
bool computeOSLogBufferLayout(clang::ASTContext &Ctx, const clang::CallExpr *E, OSLogBufferLayout &layout)
Definition: OSLog.cpp:180
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:28
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "for" statement, if any.
Definition: Stmt.cpp:902
const ValueInfo * getValueInfo(ComparisonCategoryResult ValueKind) const
APSInt & getComplexIntReal()
Definition: APValue.h:268
A binding in a decomposition declaration.
Definition: DeclCXX.h:3795
Stmt * getBody()
Definition: Stmt.h:1958
bool hasConst() const
Definition: Type.h:258
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2533
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1073
Stmt * getInit()
Definition: Stmt.h:1830
static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, BinaryOperatorKind Opcode, APSInt RHS, APSInt &Result)
Perform the given binary integer operation.
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:870
bool isUnsignedFixedPointType() const
Return true if this is a fixed point type that is unsigned according to ISO/IEC JTC1 SC22 WG14 N1169...
Definition: Type.h:6625
Represents the this expression in C++.
Definition: ExprCXX.h:976
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, unsigned Type) const
If the current Expr is a pointer, this will try to statically determine the number of bytes available...
const Expr * getExpr() const
Get the initialization expression that will be used.
Definition: ExprCXX.h:1162
APValue & getVectorElt(unsigned I)
Definition: APValue.h:312
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1772
bool isLambdaStaticInvoker() const
Determine whether this is a lambda closure type&#39;s static member function that is used for the result ...
Definition: DeclCXX.cpp:2208
NodeId Parent
Definition: ASTDiff.cpp:192
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3587
StringRef getString() const
Definition: Expr.h:1649
static GCCTypeClass EvaluateBuiltinClassifyType(QualType T, const LangOptions &LangOpts)
EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way as GCC.
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
static bool handleCompoundAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal, QualType LValType, QualType PromotedLValType, BinaryOperatorKind Opcode, const APValue &RVal)
Perform a compound assignment of LVal <op>= RVal.
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1241
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1613
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...
static EvalStmtResult EvaluateSwitch(StmtResult &Result, EvalInfo &Info, const SwitchStmt *SS)
Evaluate a switch statement.
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:481
bool isUnion() const
Definition: APValue.h:242
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1334
bool hasLValuePath() const
Definition: APValue.cpp:618
QualType getComputationLHSType() const
Definition: Expr.h:3532
static unsigned FindDesignatorMismatch(QualType ObjType, const SubobjectDesignator &A, const SubobjectDesignator &B, bool &WasArrayIndex)
Find the position where two subobject designators diverge, or equivalently the length of the common i...
CastKind
CastKind - The kind of operation required for a conversion.
APValue & getArrayFiller()
Definition: APValue.h:336
Specifies that the expression should never be value-dependent.
Definition: Expr.h:711
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2222
static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, const VarDecl *VD, CallStackFrame *Frame, APValue *&Result, const LValue *LVal)
Try to evaluate the initializer for a variable declaration.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
ConstantExpr - An expression that occurs in a constant context.
Definition: Expr.h:904
bool HasUndefinedBehavior
Whether the evaluation hit undefined behavior.
Definition: Expr.h:549
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
CXXCtorInitializer *const * init_const_iterator
Iterates through the member/base initializer list.
Definition: DeclCXX.h:2522
unsigned Offset
Definition: Format.cpp:1631
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
unsigned getValue() const
Definition: Expr.h:1426
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Definition: Expr.cpp:3101
bool hasArrayFiller() const
Definition: APValue.h:333
capture_const_iterator captures_end() const
Definition: DeclCXX.h:1256
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1871
Expr * getCond() const
Definition: Expr.h:3621
QualType getElementType() const
Definition: Type.h:2490
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr...
Definition: Decl.cpp:4394
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
This represents one expression.
Definition: Expr.h:106
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Definition: DeclCXX.cpp:2376
DeclStmt * getEndStmt()
Definition: StmtCXX.h:158
SourceLocation End
Allow any unmodeled side effect.
Definition: Expr.h:599
static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc, unsigned Type, const LValue &LVal, CharUnits &EndOffset)
Helper for tryEvaluateBuiltinObjectSize – Given an LValue, this will determine how many bytes exist ...
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2034
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
Definition: Expr.h:2087
static bool HandleConversionToBool(const APValue &Val, bool &Result)
void EvaluateForOverflow(const ASTContext &Ctx) const
static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info)
Evaluate an expression of record type as a temporary.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1036
static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result, const ASTContext &Ctx, bool &IsConst)
unsigned getPackLength() const
Retrieve the length of the parameter pack.
Definition: ExprCXX.h:3921
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6811
static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object, LValue &This)
Build an lvalue for the object argument of a member function call.
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5182
Expr * getCallee()
Definition: Expr.h:2514
unsigned getNumInits() const
Definition: Expr.h:4220
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3475
Expr * getSubExpr() const
Get the initializer to use for each array element.
Definition: Expr.h:4830
bool isNullPtrType() const
Definition: Type.h:6569
field_iterator field_end() const
Definition: Decl.h:3787
QualType getArgumentType() const
Definition: Expr.h:2259
#define bool
Definition: stdbool.h:31
static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const LValue &LVal, Expr::ConstExprUsage Usage)
Check that this reference or pointer core constant expression is a valid value for an address or refe...
Stmt * getBody()
Definition: Stmt.h:2124
DeclContext * getDeclContext()
Definition: DeclBase.h:427
uint32_t getCodeUnit(size_t i) const
Definition: Expr.h:1664
Expr * getRHS()
Definition: Stmt.h:1495
AccessKinds
Kinds of access we can perform on an object, for diagnostics.
bool isAnyComplexType() const
Definition: Type.h:6377
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:2159
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:3844
static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info, const Stmt *S, const SwitchCase *SC=nullptr)
unsigned getFieldCount() const
getFieldCount - Get the number of fields in the layout.
Definition: RecordLayout.h:187
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
Definition: Expr.h:2532
static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result, EvalInfo &Info)
void removeLocalConst()
Definition: Type.h:6166
Defines the clang::TypeLoc interface and its subclasses.
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.h:2440
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1844
Kind getKind() const
Determine what kind of offsetof node this is.
Definition: Expr.h:2067
static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl, const Expr *Cond, bool &Result)
Evaluate a condition (either a variable declaration or an expression).
QualType getType() const
Definition: Expr.h:128
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
Definition: Decl.cpp:2141
static bool isPotentialConstantExpr(const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function&#39;s definition might be usable in a constant exp...
QualType getTypeOfArgument() const
Gets the argument type, or the type of the argument expression, whichever is appropriate.
Definition: Expr.h:2285
static bool diagnoseUnreadableFields(EvalInfo &Info, const Expr *E, QualType T)
Diagnose an attempt to read from any unreadable field within the specified type, which might be a cla...
PartialDiagnostic::StorageAllocator & getDiagAllocator()
Definition: ASTContext.h:686
APValue & getStructField(unsigned i)
Definition: APValue.h:365
static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result, const RecordDecl *TruncatedType, unsigned TruncatedElements)
Cast an lvalue referring to a base subobject to a derived class, by truncating the lvalue&#39;s path to t...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1752
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:4200
AccessKind
This enum distinguishes between different ways to access (read or write) a variable.
Definition: ThreadSafety.h:70
static bool IsStringLiteralCall(const CallExpr *E)
Should this call expression be treated as a string literal?
QualType getRecordType(const RecordDecl *Decl) const
SwitchCase * getSwitchCaseList()
Definition: Stmt.h:2015
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1896
Represents a GCC generic vector type.
Definition: Type.h:3168
bool isNullPointer() const
Definition: APValue.cpp:639
static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult, const ASTContext &Ctx, Expr::SideEffectsKind AllowSideEffects, EvalInfo &Info)
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3958
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1078
const OffsetOfNode & getComponent(unsigned Idx) const
Definition: Expr.h:2166
Allow UB that we can give a value, but not arbitrary unmodeled side effects.
Definition: Expr.h:597
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6688
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2258
Expr * getCond()
Definition: Stmt.h:1762
ValueDecl * getDecl()
Definition: Expr.h:1114
APSInt & getComplexIntImag()
Definition: APValue.h:276
The result type of a method or function.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2026
const Expr * getSubExpr() const
Definition: Expr.h:1860
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:703
bool getValue() const
Definition: ExprCXX.h:574
do v
Definition: arm_acle.h:78
static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E, const APSInt &LHS, const APSInt &RHS, unsigned BitWidth, Operation Op, APSInt &Result)
Perform the given integer operation, which is known to need at most BitWidth bits, and check for overflow in the original type (if that type was not an unsigned type).
const FieldDecl * getUnionField() const
Definition: APValue.h:376
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1...
Definition: Expr.h:1517
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:6105
DoStmt - This represents a &#39;do/while&#39; stmt.
Definition: Stmt.h:2185
bool isSignedFixedPointType() const
Return true if this is a fixed point type that is signed according to ISO/IEC JTC1 SC22 WG14 N1169...
Definition: Type.h:6611
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
Definition: Expr.cpp:1368
SideEffectsKind
Definition: Expr.h:595
bool isVoidPointerType() const
Definition: Type.cpp:469
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6131
static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc, const FunctionDecl *Declaration, const FunctionDecl *Definition, const Stmt *Body)
CheckConstexprFunction - Check that a function can be called in a constant expression.
RecordDecl * getDecl() const
Definition: Type.h:4380
static APValue & createTemporary(const KeyTy *Key, bool IsLifetimeExtended, LValue &LV, CallStackFrame &Frame)
A helper function to create a temporary and set an LValue.
APValue & getStructBase(unsigned i)
Definition: APValue.h:361
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:191
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
APValue * getEvaluatedValue() const
Return the already-evaluated value of this variable&#39;s initializer, or NULL if the value is not yet kn...
Definition: Decl.cpp:2309
bool getValue() const
Definition: ExprCXX.h:3745
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:362
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:945
static ICEDiag Worst(ICEDiag A, ICEDiag B)
APValue & getArrayInitializedElt(unsigned I)
Definition: APValue.h:325
Kind
A field in a dependent type, known only by its name.
Definition: Expr.h:2022
QualType getCanonicalType() const
Definition: Type.h:6111
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1448
static bool EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E, SuccessCB &&Success, AfterCB &&DoAfter)
static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info)
unsigned path_size() const
Definition: Expr.h:3074
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
const LValueBase getLValueBase() const
Definition: APValue.cpp:603
virtual bool isNan2008() const
Returns true if NaN encoding is IEEE 754-2008.
Definition: TargetInfo.h:948
bool isOrdered() const
True iff the comparison category is a relational comparison.
EvalStmtResult
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Definition: Expr.cpp:3438
Encodes a location in the source.
body_range body()
Definition: Stmt.h:1274
static ICEDiag NoDiag()
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6188
Expr * getSubExpr() const
Definition: Expr.h:1926
CastKind getCastKind() const
Definition: Expr.h:3049
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2287
APValue & getUnionValue()
Definition: APValue.h:380
Expr * getLHS()
Definition: Stmt.h:1483
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
static bool EvalPointerValueAsBool(const APValue &Value, bool &Result)
static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E, QualType DestType, QualType SrcType, const APSInt &Value)
Stmt * getElse()
Definition: Stmt.h:1783
QualType getElementType() const
Definition: Type.h:3203
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:1143
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3866
static bool IsLiteralLValue(const LValue &Value)
APFloat & getFloat()
Definition: APValue.h:260
void FixedPointValueToString(SmallVectorImpl< char > &Str, llvm::APSInt Val, unsigned Scale)
Definition: Type.cpp:4017
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2041
Expr * getCond()
Definition: Stmt.h:1946
static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E, APFloat &LHS, BinaryOperatorKind Opcode, const APFloat &RHS)
Perform the given binary floating-point operation, in-place, on LHS.
static bool HandleFunctionCall(SourceLocation CallLoc, const FunctionDecl *Callee, const LValue *This, ArrayRef< const Expr *> Args, const Stmt *Body, EvalInfo &Info, APValue &Result, const LValue *ResultSlot)
Evaluate a function call.
bool canOverflow() const
Returns true if the unary operator can cause an overflow.
Definition: Expr.h:1939
#define ilogb(__x)
Definition: tgmath.h:867
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2285
bool isMemberPointer() const
Definition: APValue.h:243
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
static EvalStmtResult EvaluateLoopBody(StmtResult &Result, EvalInfo &Info, const Stmt *Body, const SwitchCase *Case=nullptr)
Evaluate the body of a loop, and translate the result as appropriate.
static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD)
static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E, APValue &Value, const FieldDecl *FD)
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:1860
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2253
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
Definition: DeclCXX.cpp:1348
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
static bool isDesignatorAtObjectEnd(const ASTContext &Ctx, const LValue &LVal)
Checks to see if the given LValue&#39;s Designator is at the end of the LValue&#39;s record layout...
static const ValueDecl * GetLValueBaseDecl(const LValue &LVal)
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
Definition: Expr.h:249
bool isLValue() const
Definition: APValue.h:238
Used for C&#39;s _Alignof and C++&#39;s alignof.
Definition: TypeTraits.h:101
static bool EvaluateRecord(const Expr *E, const LValue &This, APValue &Result, EvalInfo &Info)
static bool isLogicalOp(Opcode Opc)
Definition: Expr.h:3412
Expr * getSubExpr()
Definition: ExprObjC.h:135
An expression trait intrinsic.
Definition: ExprCXX.h:2580
static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E, QualType SrcType, QualType DestType, APFloat &Result)
VarDecl * getConditionVariable()
Retrieve the variable declared in this "switch" statement, if any.
Definition: Stmt.cpp:965
bool isVectorType() const
Definition: Type.h:6381
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3806
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:117
bool isArgumentType() const
Definition: Expr.h:2258
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:4284
bool isMemberPointerToDerivedMember() const
Definition: APValue.cpp:675
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:215
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat &#39;semantics&#39; for the specified scalar floating point type.
const Expr * getInitializer() const
Definition: Expr.h:2956
Expr * getLHS() const
Definition: Expr.h:3332
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3509
CXXConstructorDecl * getConstructor() const
Definition: DeclCXX.h:2471
Represents a C11 generic selection.
Definition: Expr.h:5015
EvalStatus is a struct with detailed info about an evaluation in progress.
Definition: Expr.h:541
static bool HandleOverflow(EvalInfo &Info, const Expr *E, const T &SrcValue, QualType DestType)
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3762
static bool EvaluateVoid(const Expr *E, EvalInfo &Info)
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Definition: Expr.h:3703
static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base)
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Definition: Expr.h:3719
Dataflow Directional Tag Classes.
static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result, EvalInfo &Info)
static unsigned getBaseIndex(const CXXRecordDecl *Derived, const CXXRecordDecl *Base)
Get the base index of the given base class within an APValue representing the given derived class...
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Definition: DeclCXX.cpp:1362
VarDecl * getConditionVariable()
Retrieve the variable declared in this "while" statement, if any.
Definition: Stmt.cpp:1021
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1758
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:571
static bool isZeroSized(const LValue &Value)
bool isImplicit() const
Definition: ExprCXX.h:997
void swap(APValue &RHS)
Swaps the contents of this and the given APValue.
Definition: APValue.cpp:292
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2825
AccessSpecifier getAccess() const
Definition: DeclBase.h:462
const Expr * getInit() const
Definition: Decl.h:1220
A decomposition declaration.
Definition: DeclCXX.h:3843
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition: ExprCXX.h:404
StmtClass getStmtClass() const
Definition: Stmt.h:1029
static bool CheckLiteralType(EvalInfo &Info, const Expr *E, const LValue *This=nullptr)
Check that this core constant expression is of literal type, and if not, produce an appropriate diagn...
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2166
const Expr * getExpr() const
Definition: ExprCXX.h:1106
bool isBooleanType() const
Definition: Type.h:6657
unsigned getArrayInitializedElts() const
Definition: APValue.h:344
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2756
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1391
static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base, LValue &Result)
Attempts to evaluate the given LValueBase as the result of a call to a function with the alloc_size a...
body_iterator body_begin()
Definition: Stmt.h:1275
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:682
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:2017
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2693
llvm::APInt getValue() const
Definition: Expr.h:1292
LabelDecl * getLabel() const
Definition: Expr.h:3784
path_iterator path_end()
Definition: Expr.h:3076
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3719
SwitchStmt - This represents a &#39;switch&#39; stmt.
Definition: Stmt.h:1886
bool isStringLiteralInit() const
Definition: Expr.cpp:2045
bool isArray() const
Definition: APValue.h:240
unsigned getIntWidth(QualType T) const
bool isIncompleteArrayType() const
Definition: Type.h:6353
static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info, bool InvalidBaseOK=false)
bool HasSideEffects
Whether the evaluated expression has side effects.
Definition: Expr.h:544
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4370
Complex values, per C99 6.2.5p11.
Definition: Type.h:2477
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6.7.5p3.
Definition: Type.cpp:2021
bool body_empty() const
Definition: Stmt.h:1268
static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj, const CXXRecordDecl *Derived, const CXXRecordDecl *Base, const ASTRecordLayout *RL=nullptr)
bool checkInitIsICE() const
Determine whether the value of the initializer attached to this declaration is an integral constant e...
Definition: Decl.cpp:2330
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2312
bool EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage, const ASTContext &Ctx) const
Evaluate an expression that is required to be a constant expression.
static bool hasFields(const CXXRecordDecl *RD)
Determine if a class has any fields that might need to be copied by a trivial copy or move operation...
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
Definition: Type.cpp:1361
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6578
bool isStruct() const
Definition: APValue.h:241
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:386
T * getAttr() const
Definition: DeclBase.h:527
An implicit indirection through a C++ base class, when the field found is in a base class...
Definition: Expr.h:2025
const llvm::APInt & getSize() const
Definition: Type.h:2890
static bool modifySubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, APValue &NewVal)
Update the designated sub-object of an rvalue to the given value.
bool isAtomicType() const
Definition: Type.h:6406
static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E, QualType SrcType, const APSInt &Value, QualType DestType, APFloat &Result)
bool isFunctionType() const
Definition: Type.h:6292
Stmt * getInit()
Definition: Stmt.h:1967
Opcode getOpcode() const
Definition: Expr.h:1921
static bool isAdditiveOp(Opcode Opc)
Definition: Expr.h:3368
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1413
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2673
static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info)
decl_range decls()
Definition: Stmt.h:1186
static bool EvaluateArray(const Expr *E, const LValue &This, APValue &Result, EvalInfo &Info)
static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E, QualType Type, LValue &Result)
SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler)
Find the designated sub-object of an rvalue.
static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj, const CXXRecordDecl *DerivedDecl, const CXXBaseSpecifier *Base)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal, const FieldDecl *FD, const ASTRecordLayout *RL=nullptr)
Update LVal to refer to the given field, which must be a member of the type currently described by LV...
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2070
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2031
DeclStmt * getRangeStmt()
Definition: StmtCXX.h:154
static bool isIncrementOp(Opcode Op)
Definition: Expr.h:1955
unsigned getConstexprBacktraceLimit() const
Retrieve the maximum number of constexpr evaluation notes to emit along with a given diagnostic...
Definition: Diagnostic.h:581
static bool EvaluateArgs(ArrayRef< const Expr *> Args, ArgVector &ArgValues, EvalInfo &Info)
EvaluateArgs - Evaluate the arguments to a function call.
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1137
A template argument list.
Definition: DeclTemplate.h:210
const SwitchCase * getNextSwitchCase() const
Definition: Stmt.h:1369
bool hasMutableFields() const
Determine whether this class, or any of its class subobjects, contains a mutable field.
Definition: DeclCXX.h:1356
static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E, LValue &LVal, const IndirectFieldDecl *IFD)
Update LVal to refer to the given indirect field.
Expr * getCond()
Definition: Stmt.h:2203
VarDecl * getConditionVariable()
Retrieve the variable declared in this "if" statement, if any.
Definition: Stmt.cpp:864
ValueKind getKind() const
Definition: APValue.h:232
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2687
static bool EvaluateBuiltinConstantPForLValue(const LValue &LV)
EvaluateBuiltinConstantPForLValue - Determine the result of __builtin_constant_p when applied to the ...
ActionResult< Expr * > ExprResult
Definition: Ownership.h:267
bool hasUnaligned() const
Definition: Type.h:297
APFloat & getComplexFloatImag()
Definition: APValue.h:292
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
#define scalbn(__x, __y)
Definition: tgmath.h:1181
static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info)
Expr * getTrueExpr() const
Definition: Expr.h:3625
Represents a loop initializing the elements of an array.
Definition: Expr.h:4808
bool isVoidType() const
Definition: Type.h:6544
static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type, EvalInfo &Info, uint64_t &Size)
Tries to evaluate the __builtin_object_size for E.
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3982
static bool isReadByLvalueToRvalueConversion(QualType T)
Determine whether a type would actually be read by an lvalue-to-rvalue conversion.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3660
An index into an array.
Definition: Expr.h:2018
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6099
static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx, const Expr *E, llvm::APSInt *Value, SourceLocation *Loc)
Evaluate an expression as a C++11 integral constant expression.
WhileStmt - This represents a &#39;while&#39; stmt.
Definition: Stmt.h:2063
static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E, LValue &LVal, QualType EltTy, APSInt Adjustment)
Update a pointer value to model pointer arithmetic.
base_class_iterator bases_end()
Definition: DeclCXX.h:832
bool isRValue() const
Definition: Expr.h:250
llvm::PointerIntPair< const Decl *, 1, bool > BaseOrMemberType
Definition: APValue.h:108
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2391
static ICEDiag CheckICE(const Expr *E, const ASTContext &Ctx)
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:276
CheckSubobjectKind
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1566
Defines the clang::TargetInfo interface.
bool isComplexIntegerType() const
Definition: Type.cpp:487
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2396
bool hasVolatile() const
Definition: Type.h:263
static bool EvaluateBuiltinConstantP(ASTContext &Ctx, const Expr *Arg)
EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to GCC as we can manage...
__DEVICE__ int max(int __a, int __b)
unsigned getNumElements() const
Definition: Type.h:3204
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:82
unsigned getNumComponents() const
Definition: Expr.h:2176
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2079
bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...
static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr)
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
Definition: ExprCXX.h:1806
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1041
bool isUnion() const
Definition: Decl.h:3252
Expr * getRHS() const
Definition: Expr.h:3334
Designator - A designator in a C99 designated initializer.
Definition: Designator.h:37
SourceLocation getBeginLoc() const
Definition: Stmt.h:1383
bool isPointerType() const
Definition: Type.h:6296
__DEVICE__ int min(int __a, int __b)
static bool AreElementsOfSameArray(QualType ObjType, const SubobjectDesignator &A, const SubobjectDesignator &B)
Determine whether the given subobject designators refer to elements of the same array object...
static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info, bool InvalidBaseOK=false)
Evaluate an expression as an lvalue.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static void expandStringLiteral(EvalInfo &Info, const Expr *Lit, APValue &Result)
capture_const_iterator captures_begin() const
Definition: DeclCXX.h:1252
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:4302
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
Definition: Decl.h:1105
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExprUnevaluted - Return true if this expression might be usable in a constant expr...
DeclStmt * getLoopVarStmt()
Definition: StmtCXX.h:161
QualType getType() const
Definition: Decl.h:648
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Definition: ExprCXX.h:1410
bool isFloatingType() const
Definition: Type.cpp:1921
static CharUnits GetAlignOfType(EvalInfo &Info, QualType T, UnaryExprOrTypeTrait ExprKind)
static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E, QualType SrcType, const APFloat &Value, QualType DestType, APSInt &Result)
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:562
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Definition: Expr.h:2117
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:887
Automatic storage duration (most local variables).
Definition: Specifiers.h:279
APSInt & getInt()
Definition: APValue.h:252
bool isPotentiallyEvaluated() const
Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr...
Definition: ExprCXX.cpp:62
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
Definition: Expr.h:3700
DeclStmt * getBeginStmt()
Definition: StmtCXX.h:155
bool isFunctionPointerType() const
Definition: Type.h:6320
static bool isComparisonOp(Opcode Opc)
Definition: Expr.h:3382
Attempt to be ABI-compatible with code generated by Clang 7.0.x (SVN r338536).
const LangOptions & getLangOpts() const
Definition: ASTContext.h:707
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2872
static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal, QualType LValType, APValue &Val)
Perform an assignment of Val to LVal. Takes ownership of Val.
Defines enum values for all the target-independent builtin functions.
Declaration of a template function.
Definition: DeclTemplate.h:969
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4898
static void describeCall(CallStackFrame *Frame, raw_ostream &Out)
Produce a string describing the given constexpr call.
SourceLocation getLocation() const
Definition: DeclBase.h:418
bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result=nullptr, SourceLocation *Loc=nullptr) const
isCXX11ConstantExpr - Return true if this expression is a constant expression in C++11.
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:98
static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc, const CXXConstructorDecl *CD, bool IsValueInitialization)
CheckTrivialDefaultConstructor - Check whether a constructor is a trivial default constructor...
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2560
ComparisonCategoryResult makeWeakResult(ComparisonCategoryResult Res) const
Converts the specified result kind into the the correct result kind for this category.
CharUnits & getLValueOffset()
Definition: APValue.cpp:613
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result)
EvaluateAsRValue - Try to evaluate this expression, performing an implicit lvalue-to-rvalue cast if i...
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:291
unsigned getVectorLength() const
Definition: APValue.h:320