clang  7.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/RecordLayout.h"
43 #include "clang/AST/StmtVisitor.h"
44 #include "clang/AST/TypeLoc.h"
45 #include "clang/Basic/Builtins.h"
46 #include "clang/Basic/TargetInfo.h"
47 #include "llvm/Support/raw_ostream.h"
48 #include <cstring>
49 #include <functional>
50 
51 #define DEBUG_TYPE "exprconstant"
52 
53 using namespace clang;
54 using llvm::APSInt;
55 using llvm::APFloat;
56 
57 static bool IsGlobalLValue(APValue::LValueBase B);
58 
59 namespace {
60  struct LValue;
61  struct CallStackFrame;
62  struct EvalInfo;
63 
64  static QualType getType(APValue::LValueBase B) {
65  if (!B) return QualType();
66  if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
67  // FIXME: It's unclear where we're supposed to take the type from, and
68  // this actually matters for arrays of unknown bound. Eg:
69  //
70  // extern int arr[]; void f() { extern int arr[3]; };
71  // constexpr int *p = &arr[1]; // valid?
72  //
73  // For now, we take the array bound from the most recent declaration.
74  for (auto *Redecl = cast<ValueDecl>(D->getMostRecentDecl()); Redecl;
75  Redecl = cast_or_null<ValueDecl>(Redecl->getPreviousDecl())) {
76  QualType T = Redecl->getType();
77  if (!T->isIncompleteArrayType())
78  return T;
79  }
80  return D->getType();
81  }
82 
83  const Expr *Base = B.get<const Expr*>();
84 
85  // For a materialized temporary, the type of the temporary we materialized
86  // may not be the type of the expression.
87  if (const MaterializeTemporaryExpr *MTE =
88  dyn_cast<MaterializeTemporaryExpr>(Base)) {
91  const Expr *Temp = MTE->GetTemporaryExpr();
92  const Expr *Inner = Temp->skipRValueSubobjectAdjustments(CommaLHSs,
93  Adjustments);
94  // Keep any cv-qualifiers from the reference if we generated a temporary
95  // for it directly. Otherwise use the type after adjustment.
96  if (!Adjustments.empty())
97  return Inner->getType();
98  }
99 
100  return Base->getType();
101  }
102 
103  /// Get an LValue path entry, which is known to not be an array index, as a
104  /// field or base class.
105  static
108  Value.setFromOpaqueValue(E.BaseOrMember);
109  return Value;
110  }
111 
112  /// Get an LValue path entry, which is known to not be an array index, as a
113  /// field declaration.
114  static const FieldDecl *getAsField(APValue::LValuePathEntry E) {
115  return dyn_cast<FieldDecl>(getAsBaseOrMember(E).getPointer());
116  }
117  /// Get an LValue path entry, which is known to not be an array index, as a
118  /// base class declaration.
119  static const CXXRecordDecl *getAsBaseClass(APValue::LValuePathEntry E) {
120  return dyn_cast<CXXRecordDecl>(getAsBaseOrMember(E).getPointer());
121  }
122  /// Determine whether this LValue path entry for a base class names a virtual
123  /// base class.
124  static bool isVirtualBaseClass(APValue::LValuePathEntry E) {
125  return getAsBaseOrMember(E).getInt();
126  }
127 
128  /// Given a CallExpr, try to get the alloc_size attribute. May return null.
129  static const AllocSizeAttr *getAllocSizeAttr(const CallExpr *CE) {
130  const FunctionDecl *Callee = CE->getDirectCallee();
131  return Callee ? Callee->getAttr<AllocSizeAttr>() : nullptr;
132  }
133 
134  /// Attempts to unwrap a CallExpr (with an alloc_size attribute) from an Expr.
135  /// This will look through a single cast.
136  ///
137  /// Returns null if we couldn't unwrap a function with alloc_size.
138  static const CallExpr *tryUnwrapAllocSizeCall(const Expr *E) {
139  if (!E->getType()->isPointerType())
140  return nullptr;
141 
142  E = E->IgnoreParens();
143  // If we're doing a variable assignment from e.g. malloc(N), there will
144  // probably be a cast of some kind. In exotic cases, we might also see a
145  // top-level ExprWithCleanups. Ignore them either way.
146  if (const auto *EC = dyn_cast<ExprWithCleanups>(E))
147  E = EC->getSubExpr()->IgnoreParens();
148 
149  if (const auto *Cast = dyn_cast<CastExpr>(E))
150  E = Cast->getSubExpr()->IgnoreParens();
151 
152  if (const auto *CE = dyn_cast<CallExpr>(E))
153  return getAllocSizeAttr(CE) ? CE : nullptr;
154  return nullptr;
155  }
156 
157  /// Determines whether or not the given Base contains a call to a function
158  /// with the alloc_size attribute.
159  static bool isBaseAnAllocSizeCall(APValue::LValueBase Base) {
160  const auto *E = Base.dyn_cast<const Expr *>();
161  return E && E->getType()->isPointerType() && tryUnwrapAllocSizeCall(E);
162  }
163 
164  /// The bound to claim that an array of unknown bound has.
165  /// The value in MostDerivedArraySize is undefined in this case. So, set it
166  /// to an arbitrary value that's likely to loudly break things if it's used.
167  static const uint64_t AssumedSizeForUnsizedArray =
169 
170  /// Determines if an LValue with the given LValueBase will have an unsized
171  /// array in its designator.
172  /// Find the path length and type of the most-derived subobject in the given
173  /// path, and find the size of the containing array, if any.
174  static unsigned
175  findMostDerivedSubobject(ASTContext &Ctx, APValue::LValueBase Base,
177  uint64_t &ArraySize, QualType &Type, bool &IsArray,
178  bool &FirstEntryIsUnsizedArray) {
179  // This only accepts LValueBases from APValues, and APValues don't support
180  // arrays that lack size info.
181  assert(!isBaseAnAllocSizeCall(Base) &&
182  "Unsized arrays shouldn't appear here");
183  unsigned MostDerivedLength = 0;
184  Type = getType(Base);
185 
186  for (unsigned I = 0, N = Path.size(); I != N; ++I) {
187  if (Type->isArrayType()) {
188  const ArrayType *AT = Ctx.getAsArrayType(Type);
189  Type = AT->getElementType();
190  MostDerivedLength = I + 1;
191  IsArray = true;
192 
193  if (auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
194  ArraySize = CAT->getSize().getZExtValue();
195  } else {
196  assert(I == 0 && "unexpected unsized array designator");
197  FirstEntryIsUnsizedArray = true;
198  ArraySize = AssumedSizeForUnsizedArray;
199  }
200  } else if (Type->isAnyComplexType()) {
201  const ComplexType *CT = Type->castAs<ComplexType>();
202  Type = CT->getElementType();
203  ArraySize = 2;
204  MostDerivedLength = I + 1;
205  IsArray = true;
206  } else if (const FieldDecl *FD = getAsField(Path[I])) {
207  Type = FD->getType();
208  ArraySize = 0;
209  MostDerivedLength = I + 1;
210  IsArray = false;
211  } else {
212  // Path[I] describes a base class.
213  ArraySize = 0;
214  IsArray = false;
215  }
216  }
217  return MostDerivedLength;
218  }
219 
220  // The order of this enum is important for diagnostics.
222  CSK_Base, CSK_Derived, CSK_Field, CSK_ArrayToPointer, CSK_ArrayIndex,
223  CSK_This, CSK_Real, CSK_Imag
224  };
225 
226  /// A path from a glvalue to a subobject of that glvalue.
227  struct SubobjectDesignator {
228  /// True if the subobject was named in a manner not supported by C++11. Such
229  /// lvalues can still be folded, but they are not core constant expressions
230  /// and we cannot perform lvalue-to-rvalue conversions on them.
231  unsigned Invalid : 1;
232 
233  /// Is this a pointer one past the end of an object?
234  unsigned IsOnePastTheEnd : 1;
235 
236  /// Indicator of whether the first entry is an unsized array.
237  unsigned FirstEntryIsAnUnsizedArray : 1;
238 
239  /// Indicator of whether the most-derived object is an array element.
240  unsigned MostDerivedIsArrayElement : 1;
241 
242  /// The length of the path to the most-derived object of which this is a
243  /// subobject.
244  unsigned MostDerivedPathLength : 28;
245 
246  /// The size of the array of which the most-derived object is an element.
247  /// This will always be 0 if the most-derived object is not an array
248  /// element. 0 is not an indicator of whether or not the most-derived object
249  /// is an array, however, because 0-length arrays are allowed.
250  ///
251  /// If the current array is an unsized array, the value of this is
252  /// undefined.
253  uint64_t MostDerivedArraySize;
254 
255  /// The type of the most derived object referred to by this address.
256  QualType MostDerivedType;
257 
258  typedef APValue::LValuePathEntry PathEntry;
259 
260  /// The entries on the path from the glvalue to the designated subobject.
262 
263  SubobjectDesignator() : Invalid(true) {}
264 
265  explicit SubobjectDesignator(QualType T)
266  : Invalid(false), IsOnePastTheEnd(false),
267  FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
268  MostDerivedPathLength(0), MostDerivedArraySize(0),
269  MostDerivedType(T) {}
270 
271  SubobjectDesignator(ASTContext &Ctx, const APValue &V)
272  : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false),
273  FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
274  MostDerivedPathLength(0), MostDerivedArraySize(0) {
275  assert(V.isLValue() && "Non-LValue used to make an LValue designator?");
276  if (!Invalid) {
277  IsOnePastTheEnd = V.isLValueOnePastTheEnd();
278  ArrayRef<PathEntry> VEntries = V.getLValuePath();
279  Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());
280  if (V.getLValueBase()) {
281  bool IsArray = false;
282  bool FirstIsUnsizedArray = false;
283  MostDerivedPathLength = findMostDerivedSubobject(
284  Ctx, V.getLValueBase(), V.getLValuePath(), MostDerivedArraySize,
285  MostDerivedType, IsArray, FirstIsUnsizedArray);
286  MostDerivedIsArrayElement = IsArray;
287  FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
288  }
289  }
290  }
291 
292  void setInvalid() {
293  Invalid = true;
294  Entries.clear();
295  }
296 
297  /// Determine whether the most derived subobject is an array without a
298  /// known bound.
299  bool isMostDerivedAnUnsizedArray() const {
300  assert(!Invalid && "Calling this makes no sense on invalid designators");
301  return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;
302  }
303 
304  /// Determine what the most derived array's size is. Results in an assertion
305  /// failure if the most derived array lacks a size.
306  uint64_t getMostDerivedArraySize() const {
307  assert(!isMostDerivedAnUnsizedArray() && "Unsized array has no size");
308  return MostDerivedArraySize;
309  }
310 
311  /// Determine whether this is a one-past-the-end pointer.
312  bool isOnePastTheEnd() const {
313  assert(!Invalid);
314  if (IsOnePastTheEnd)
315  return true;
316  if (!isMostDerivedAnUnsizedArray() && MostDerivedIsArrayElement &&
317  Entries[MostDerivedPathLength - 1].ArrayIndex == MostDerivedArraySize)
318  return true;
319  return false;
320  }
321 
322  /// Check that this refers to a valid subobject.
323  bool isValidSubobject() const {
324  if (Invalid)
325  return false;
326  return !isOnePastTheEnd();
327  }
328  /// Check that this refers to a valid subobject, and if not, produce a
329  /// relevant diagnostic and set the designator as invalid.
330  bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK);
331 
332  /// Update this designator to refer to the first element within this array.
333  void addArrayUnchecked(const ConstantArrayType *CAT) {
334  PathEntry Entry;
335  Entry.ArrayIndex = 0;
336  Entries.push_back(Entry);
337 
338  // This is a most-derived object.
339  MostDerivedType = CAT->getElementType();
340  MostDerivedIsArrayElement = true;
341  MostDerivedArraySize = CAT->getSize().getZExtValue();
342  MostDerivedPathLength = Entries.size();
343  }
344  /// Update this designator to refer to the first element within the array of
345  /// elements of type T. This is an array of unknown size.
346  void addUnsizedArrayUnchecked(QualType ElemTy) {
347  PathEntry Entry;
348  Entry.ArrayIndex = 0;
349  Entries.push_back(Entry);
350 
351  MostDerivedType = ElemTy;
352  MostDerivedIsArrayElement = true;
353  // The value in MostDerivedArraySize is undefined in this case. So, set it
354  // to an arbitrary value that's likely to loudly break things if it's
355  // used.
356  MostDerivedArraySize = AssumedSizeForUnsizedArray;
357  MostDerivedPathLength = Entries.size();
358  }
359  /// Update this designator to refer to the given base or member of this
360  /// object.
361  void addDeclUnchecked(const Decl *D, bool Virtual = false) {
362  PathEntry Entry;
363  APValue::BaseOrMemberType Value(D, Virtual);
364  Entry.BaseOrMember = Value.getOpaqueValue();
365  Entries.push_back(Entry);
366 
367  // If this isn't a base class, it's a new most-derived object.
368  if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
369  MostDerivedType = FD->getType();
370  MostDerivedIsArrayElement = false;
371  MostDerivedArraySize = 0;
372  MostDerivedPathLength = Entries.size();
373  }
374  }
375  /// Update this designator to refer to the given complex component.
376  void addComplexUnchecked(QualType EltTy, bool Imag) {
377  PathEntry Entry;
378  Entry.ArrayIndex = Imag;
379  Entries.push_back(Entry);
380 
381  // This is technically a most-derived object, though in practice this
382  // is unlikely to matter.
383  MostDerivedType = EltTy;
384  MostDerivedIsArrayElement = true;
385  MostDerivedArraySize = 2;
386  MostDerivedPathLength = Entries.size();
387  }
388  void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, const Expr *E);
389  void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
390  const APSInt &N);
391  /// Add N to the address of this subobject.
392  void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
393  if (Invalid || !N) return;
394  uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
395  if (isMostDerivedAnUnsizedArray()) {
396  diagnoseUnsizedArrayPointerArithmetic(Info, E);
397  // Can't verify -- trust that the user is doing the right thing (or if
398  // not, trust that the caller will catch the bad behavior).
399  // FIXME: Should we reject if this overflows, at least?
400  Entries.back().ArrayIndex += TruncatedN;
401  return;
402  }
403 
404  // [expr.add]p4: For the purposes of these operators, a pointer to a
405  // nonarray object behaves the same as a pointer to the first element of
406  // an array of length one with the type of the object as its element type.
407  bool IsArray = MostDerivedPathLength == Entries.size() &&
408  MostDerivedIsArrayElement;
409  uint64_t ArrayIndex =
410  IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd;
411  uint64_t ArraySize =
412  IsArray ? getMostDerivedArraySize() : (uint64_t)1;
413 
414  if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
415  // Calculate the actual index in a wide enough type, so we can include
416  // it in the note.
417  N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
418  (llvm::APInt&)N += ArrayIndex;
419  assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index");
420  diagnosePointerArithmetic(Info, E, N);
421  setInvalid();
422  return;
423  }
424 
425  ArrayIndex += TruncatedN;
426  assert(ArrayIndex <= ArraySize &&
427  "bounds check succeeded for out-of-bounds index");
428 
429  if (IsArray)
430  Entries.back().ArrayIndex = ArrayIndex;
431  else
432  IsOnePastTheEnd = (ArrayIndex != 0);
433  }
434  };
435 
436  /// A stack frame in the constexpr call stack.
437  struct CallStackFrame {
438  EvalInfo &Info;
439 
440  /// Parent - The caller of this stack frame.
441  CallStackFrame *Caller;
442 
443  /// Callee - The function which was called.
444  const FunctionDecl *Callee;
445 
446  /// This - The binding for the this pointer in this call, if any.
447  const LValue *This;
448 
449  /// Arguments - Parameter bindings for this function call, indexed by
450  /// parameters' function scope indices.
451  APValue *Arguments;
452 
453  // Note that we intentionally use std::map here so that references to
454  // values are stable.
455  typedef std::pair<const void *, unsigned> MapKeyTy;
456  typedef std::map<MapKeyTy, APValue> MapTy;
457  /// Temporaries - Temporary lvalues materialized within this stack frame.
458  MapTy Temporaries;
459 
460  /// CallLoc - The location of the call expression for this call.
461  SourceLocation CallLoc;
462 
463  /// Index - The call index of this call.
464  unsigned Index;
465 
466  /// The stack of integers for tracking version numbers for temporaries.
467  SmallVector<unsigned, 2> TempVersionStack = {1};
468  unsigned CurTempVersion = TempVersionStack.back();
469 
470  unsigned getTempVersion() const { return TempVersionStack.back(); }
471 
472  void pushTempVersion() {
473  TempVersionStack.push_back(++CurTempVersion);
474  }
475 
476  void popTempVersion() {
477  TempVersionStack.pop_back();
478  }
479 
480  // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact
481  // on the overall stack usage of deeply-recursing constexpr evaluataions.
482  // (We should cache this map rather than recomputing it repeatedly.)
483  // But let's try this and see how it goes; we can look into caching the map
484  // as a later change.
485 
486  /// LambdaCaptureFields - Mapping from captured variables/this to
487  /// corresponding data members in the closure class.
488  llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
489  FieldDecl *LambdaThisCaptureField;
490 
491  CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
492  const FunctionDecl *Callee, const LValue *This,
493  APValue *Arguments);
494  ~CallStackFrame();
495 
496  // Return the temporary for Key whose version number is Version.
497  APValue *getTemporary(const void *Key, unsigned Version) {
498  MapKeyTy KV(Key, Version);
499  auto LB = Temporaries.lower_bound(KV);
500  if (LB != Temporaries.end() && LB->first == KV)
501  return &LB->second;
502  // Pair (Key,Version) wasn't found in the map. Check that no elements
503  // in the map have 'Key' as their key.
504  assert((LB == Temporaries.end() || LB->first.first != Key) &&
505  (LB == Temporaries.begin() || std::prev(LB)->first.first != Key) &&
506  "Element with key 'Key' found in map");
507  return nullptr;
508  }
509 
510  // Return the current temporary for Key in the map.
511  APValue *getCurrentTemporary(const void *Key) {
512  auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
513  if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
514  return &std::prev(UB)->second;
515  return nullptr;
516  }
517 
518  // Return the version number of the current temporary for Key.
519  unsigned getCurrentTemporaryVersion(const void *Key) const {
520  auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
521  if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
522  return std::prev(UB)->first.second;
523  return 0;
524  }
525 
526  APValue &createTemporary(const void *Key, bool IsLifetimeExtended);
527  };
528 
529  /// Temporarily override 'this'.
530  class ThisOverrideRAII {
531  public:
532  ThisOverrideRAII(CallStackFrame &Frame, const LValue *NewThis, bool Enable)
533  : Frame(Frame), OldThis(Frame.This) {
534  if (Enable)
535  Frame.This = NewThis;
536  }
537  ~ThisOverrideRAII() {
538  Frame.This = OldThis;
539  }
540  private:
541  CallStackFrame &Frame;
542  const LValue *OldThis;
543  };
544 
545  /// A partial diagnostic which we might know in advance that we are not going
546  /// to emit.
547  class OptionalDiagnostic {
549 
550  public:
551  explicit OptionalDiagnostic(PartialDiagnostic *Diag = nullptr)
552  : Diag(Diag) {}
553 
554  template<typename T>
555  OptionalDiagnostic &operator<<(const T &v) {
556  if (Diag)
557  *Diag << v;
558  return *this;
559  }
560 
561  OptionalDiagnostic &operator<<(const APSInt &I) {
562  if (Diag) {
563  SmallVector<char, 32> Buffer;
564  I.toString(Buffer);
565  *Diag << StringRef(Buffer.data(), Buffer.size());
566  }
567  return *this;
568  }
569 
570  OptionalDiagnostic &operator<<(const APFloat &F) {
571  if (Diag) {
572  // FIXME: Force the precision of the source value down so we don't
573  // print digits which are usually useless (we don't really care here if
574  // we truncate a digit by accident in edge cases). Ideally,
575  // APFloat::toString would automatically print the shortest
576  // representation which rounds to the correct value, but it's a bit
577  // tricky to implement.
578  unsigned precision =
579  llvm::APFloat::semanticsPrecision(F.getSemantics());
580  precision = (precision * 59 + 195) / 196;
581  SmallVector<char, 32> Buffer;
582  F.toString(Buffer, precision);
583  *Diag << StringRef(Buffer.data(), Buffer.size());
584  }
585  return *this;
586  }
587  };
588 
589  /// A cleanup, and a flag indicating whether it is lifetime-extended.
590  class Cleanup {
591  llvm::PointerIntPair<APValue*, 1, bool> Value;
592 
593  public:
594  Cleanup(APValue *Val, bool IsLifetimeExtended)
595  : Value(Val, IsLifetimeExtended) {}
596 
597  bool isLifetimeExtended() const { return Value.getInt(); }
598  void endLifetime() {
599  *Value.getPointer() = APValue();
600  }
601  };
602 
603  /// EvalInfo - This is a private struct used by the evaluator to capture
604  /// information about a subexpression as it is folded. It retains information
605  /// about the AST context, but also maintains information about the folded
606  /// expression.
607  ///
608  /// If an expression could be evaluated, it is still possible it is not a C
609  /// "integer constant expression" or constant expression. If not, this struct
610  /// captures information about how and why not.
611  ///
612  /// One bit of information passed *into* the request for constant folding
613  /// indicates whether the subexpression is "evaluated" or not according to C
614  /// rules. For example, the RHS of (0 && foo()) is not evaluated. We can
615  /// evaluate the expression regardless of what the RHS is, but C only allows
616  /// certain things in certain situations.
617  struct EvalInfo {
618  ASTContext &Ctx;
619 
620  /// EvalStatus - Contains information about the evaluation.
621  Expr::EvalStatus &EvalStatus;
622 
623  /// CurrentCall - The top of the constexpr call stack.
624  CallStackFrame *CurrentCall;
625 
626  /// CallStackDepth - The number of calls in the call stack right now.
627  unsigned CallStackDepth;
628 
629  /// NextCallIndex - The next call index to assign.
630  unsigned NextCallIndex;
631 
632  /// StepsLeft - The remaining number of evaluation steps we're permitted
633  /// to perform. This is essentially a limit for the number of statements
634  /// we will evaluate.
635  unsigned StepsLeft;
636 
637  /// BottomFrame - The frame in which evaluation started. This must be
638  /// initialized after CurrentCall and CallStackDepth.
639  CallStackFrame BottomFrame;
640 
641  /// A stack of values whose lifetimes end at the end of some surrounding
642  /// evaluation frame.
643  llvm::SmallVector<Cleanup, 16> CleanupStack;
644 
645  /// EvaluatingDecl - This is the declaration whose initializer is being
646  /// evaluated, if any.
647  APValue::LValueBase EvaluatingDecl;
648 
649  /// EvaluatingDeclValue - This is the value being constructed for the
650  /// declaration whose initializer is being evaluated, if any.
651  APValue *EvaluatingDeclValue;
652 
653  /// EvaluatingObject - Pair of the AST node that an lvalue represents and
654  /// the call index that that lvalue was allocated in.
655  typedef std::pair<APValue::LValueBase, std::pair<unsigned, unsigned>>
656  EvaluatingObject;
657 
658  /// EvaluatingConstructors - Set of objects that are currently being
659  /// constructed.
660  llvm::DenseSet<EvaluatingObject> EvaluatingConstructors;
661 
662  struct EvaluatingConstructorRAII {
663  EvalInfo &EI;
664  EvaluatingObject Object;
665  bool DidInsert;
666  EvaluatingConstructorRAII(EvalInfo &EI, EvaluatingObject Object)
667  : EI(EI), Object(Object) {
668  DidInsert = EI.EvaluatingConstructors.insert(Object).second;
669  }
670  ~EvaluatingConstructorRAII() {
671  if (DidInsert) EI.EvaluatingConstructors.erase(Object);
672  }
673  };
674 
675  bool isEvaluatingConstructor(APValue::LValueBase Decl, unsigned CallIndex,
676  unsigned Version) {
677  return EvaluatingConstructors.count(
678  EvaluatingObject(Decl, {CallIndex, Version}));
679  }
680 
681  /// The current array initialization index, if we're performing array
682  /// initialization.
683  uint64_t ArrayInitIndex = -1;
684 
685  /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further
686  /// notes attached to it will also be stored, otherwise they will not be.
687  bool HasActiveDiagnostic;
688 
689  /// Have we emitted a diagnostic explaining why we couldn't constant
690  /// fold (not just why it's not strictly a constant expression)?
691  bool HasFoldFailureDiagnostic;
692 
693  /// Whether or not we're currently speculatively evaluating.
694  bool IsSpeculativelyEvaluating;
695 
696  enum EvaluationMode {
697  /// Evaluate as a constant expression. Stop if we find that the expression
698  /// is not a constant expression.
699  EM_ConstantExpression,
700 
701  /// Evaluate as a potential constant expression. Keep going if we hit a
702  /// construct that we can't evaluate yet (because we don't yet know the
703  /// value of something) but stop if we hit something that could never be
704  /// a constant expression.
705  EM_PotentialConstantExpression,
706 
707  /// Fold the expression to a constant. Stop if we hit a side-effect that
708  /// we can't model.
709  EM_ConstantFold,
710 
711  /// Evaluate the expression looking for integer overflow and similar
712  /// issues. Don't worry about side-effects, and try to visit all
713  /// subexpressions.
714  EM_EvaluateForOverflow,
715 
716  /// Evaluate in any way we know how. Don't worry about side-effects that
717  /// can't be modeled.
718  EM_IgnoreSideEffects,
719 
720  /// Evaluate as a constant expression. Stop if we find that the expression
721  /// is not a constant expression. Some expressions can be retried in the
722  /// optimizer if we don't constant fold them here, but in an unevaluated
723  /// context we try to fold them immediately since the optimizer never
724  /// gets a chance to look at it.
725  EM_ConstantExpressionUnevaluated,
726 
727  /// Evaluate as a potential constant expression. Keep going if we hit a
728  /// construct that we can't evaluate yet (because we don't yet know the
729  /// value of something) but stop if we hit something that could never be
730  /// a constant expression. Some expressions can be retried in the
731  /// optimizer if we don't constant fold them here, but in an unevaluated
732  /// context we try to fold them immediately since the optimizer never
733  /// gets a chance to look at it.
734  EM_PotentialConstantExpressionUnevaluated,
735 
736  /// Evaluate as a constant expression. In certain scenarios, if:
737  /// - we find a MemberExpr with a base that can't be evaluated, or
738  /// - we find a variable initialized with a call to a function that has
739  /// the alloc_size attribute on it
740  /// then we may consider evaluation to have succeeded.
741  ///
742  /// In either case, the LValue returned shall have an invalid base; in the
743  /// former, the base will be the invalid MemberExpr, in the latter, the
744  /// base will be either the alloc_size CallExpr or a CastExpr wrapping
745  /// said CallExpr.
746  EM_OffsetFold,
747  } EvalMode;
748 
749  /// Are we checking whether the expression is a potential constant
750  /// expression?
751  bool checkingPotentialConstantExpression() const {
752  return EvalMode == EM_PotentialConstantExpression ||
753  EvalMode == EM_PotentialConstantExpressionUnevaluated;
754  }
755 
756  /// Are we checking an expression for overflow?
757  // FIXME: We should check for any kind of undefined or suspicious behavior
758  // in such constructs, not just overflow.
759  bool checkingForOverflow() { return EvalMode == EM_EvaluateForOverflow; }
760 
761  EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
762  : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
763  CallStackDepth(0), NextCallIndex(1),
764  StepsLeft(getLangOpts().ConstexprStepLimit),
765  BottomFrame(*this, SourceLocation(), nullptr, nullptr, nullptr),
766  EvaluatingDecl((const ValueDecl *)nullptr),
767  EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
768  HasFoldFailureDiagnostic(false), IsSpeculativelyEvaluating(false),
769  EvalMode(Mode) {}
770 
771  void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value) {
772  EvaluatingDecl = Base;
773  EvaluatingDeclValue = &Value;
774  EvaluatingConstructors.insert({Base, {0, 0}});
775  }
776 
777  const LangOptions &getLangOpts() const { return Ctx.getLangOpts(); }
778 
779  bool CheckCallLimit(SourceLocation Loc) {
780  // Don't perform any constexpr calls (other than the call we're checking)
781  // when checking a potential constant expression.
782  if (checkingPotentialConstantExpression() && CallStackDepth > 1)
783  return false;
784  if (NextCallIndex == 0) {
785  // NextCallIndex has wrapped around.
786  FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);
787  return false;
788  }
789  if (CallStackDepth <= getLangOpts().ConstexprCallDepth)
790  return true;
791  FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded)
792  << getLangOpts().ConstexprCallDepth;
793  return false;
794  }
795 
796  CallStackFrame *getCallFrame(unsigned CallIndex) {
797  assert(CallIndex && "no call index in getCallFrame");
798  // We will eventually hit BottomFrame, which has Index 1, so Frame can't
799  // be null in this loop.
800  CallStackFrame *Frame = CurrentCall;
801  while (Frame->Index > CallIndex)
802  Frame = Frame->Caller;
803  return (Frame->Index == CallIndex) ? Frame : nullptr;
804  }
805 
806  bool nextStep(const Stmt *S) {
807  if (!StepsLeft) {
808  FFDiag(S->getLocStart(), diag::note_constexpr_step_limit_exceeded);
809  return false;
810  }
811  --StepsLeft;
812  return true;
813  }
814 
815  private:
816  /// Add a diagnostic to the diagnostics list.
817  PartialDiagnostic &addDiag(SourceLocation Loc, diag::kind DiagId) {
818  PartialDiagnostic PD(DiagId, Ctx.getDiagAllocator());
819  EvalStatus.Diag->push_back(std::make_pair(Loc, PD));
820  return EvalStatus.Diag->back().second;
821  }
822 
823  /// Add notes containing a call stack to the current point of evaluation.
824  void addCallStack(unsigned Limit);
825 
826  private:
827  OptionalDiagnostic Diag(SourceLocation Loc, diag::kind DiagId,
828  unsigned ExtraNotes, bool IsCCEDiag) {
829 
830  if (EvalStatus.Diag) {
831  // If we have a prior diagnostic, it will be noting that the expression
832  // isn't a constant expression. This diagnostic is more important,
833  // unless we require this evaluation to produce a constant expression.
834  //
835  // FIXME: We might want to show both diagnostics to the user in
836  // EM_ConstantFold mode.
837  if (!EvalStatus.Diag->empty()) {
838  switch (EvalMode) {
839  case EM_ConstantFold:
840  case EM_IgnoreSideEffects:
841  case EM_EvaluateForOverflow:
842  if (!HasFoldFailureDiagnostic)
843  break;
844  // We've already failed to fold something. Keep that diagnostic.
845  LLVM_FALLTHROUGH;
846  case EM_ConstantExpression:
847  case EM_PotentialConstantExpression:
848  case EM_ConstantExpressionUnevaluated:
849  case EM_PotentialConstantExpressionUnevaluated:
850  case EM_OffsetFold:
851  HasActiveDiagnostic = false;
852  return OptionalDiagnostic();
853  }
854  }
855 
856  unsigned CallStackNotes = CallStackDepth - 1;
857  unsigned Limit = Ctx.getDiagnostics().getConstexprBacktraceLimit();
858  if (Limit)
859  CallStackNotes = std::min(CallStackNotes, Limit + 1);
860  if (checkingPotentialConstantExpression())
861  CallStackNotes = 0;
862 
863  HasActiveDiagnostic = true;
864  HasFoldFailureDiagnostic = !IsCCEDiag;
865  EvalStatus.Diag->clear();
866  EvalStatus.Diag->reserve(1 + ExtraNotes + CallStackNotes);
867  addDiag(Loc, DiagId);
868  if (!checkingPotentialConstantExpression())
869  addCallStack(Limit);
870  return OptionalDiagnostic(&(*EvalStatus.Diag)[0].second);
871  }
872  HasActiveDiagnostic = false;
873  return OptionalDiagnostic();
874  }
875  public:
876  // Diagnose that the evaluation could not be folded (FF => FoldFailure)
877  OptionalDiagnostic
878  FFDiag(SourceLocation Loc,
879  diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
880  unsigned ExtraNotes = 0) {
881  return Diag(Loc, DiagId, ExtraNotes, false);
882  }
883 
884  OptionalDiagnostic FFDiag(const Expr *E, diag::kind DiagId
885  = diag::note_invalid_subexpr_in_const_expr,
886  unsigned ExtraNotes = 0) {
887  if (EvalStatus.Diag)
888  return Diag(E->getExprLoc(), DiagId, ExtraNotes, /*IsCCEDiag*/false);
889  HasActiveDiagnostic = false;
890  return OptionalDiagnostic();
891  }
892 
893  /// Diagnose that the evaluation does not produce a C++11 core constant
894  /// expression.
895  ///
896  /// FIXME: Stop evaluating if we're in EM_ConstantExpression or
897  /// EM_PotentialConstantExpression mode and we produce one of these.
898  OptionalDiagnostic CCEDiag(SourceLocation Loc, diag::kind DiagId
899  = diag::note_invalid_subexpr_in_const_expr,
900  unsigned ExtraNotes = 0) {
901  // Don't override a previous diagnostic. Don't bother collecting
902  // diagnostics if we're evaluating for overflow.
903  if (!EvalStatus.Diag || !EvalStatus.Diag->empty()) {
904  HasActiveDiagnostic = false;
905  return OptionalDiagnostic();
906  }
907  return Diag(Loc, DiagId, ExtraNotes, true);
908  }
909  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind DiagId
910  = diag::note_invalid_subexpr_in_const_expr,
911  unsigned ExtraNotes = 0) {
912  return CCEDiag(E->getExprLoc(), DiagId, ExtraNotes);
913  }
914  /// Add a note to a prior diagnostic.
915  OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId) {
916  if (!HasActiveDiagnostic)
917  return OptionalDiagnostic();
918  return OptionalDiagnostic(&addDiag(Loc, DiagId));
919  }
920 
921  /// Add a stack of notes to a prior diagnostic.
922  void addNotes(ArrayRef<PartialDiagnosticAt> Diags) {
923  if (HasActiveDiagnostic) {
924  EvalStatus.Diag->insert(EvalStatus.Diag->end(),
925  Diags.begin(), Diags.end());
926  }
927  }
928 
929  /// Should we continue evaluation after encountering a side-effect that we
930  /// couldn't model?
931  bool keepEvaluatingAfterSideEffect() {
932  switch (EvalMode) {
933  case EM_PotentialConstantExpression:
934  case EM_PotentialConstantExpressionUnevaluated:
935  case EM_EvaluateForOverflow:
936  case EM_IgnoreSideEffects:
937  return true;
938 
939  case EM_ConstantExpression:
940  case EM_ConstantExpressionUnevaluated:
941  case EM_ConstantFold:
942  case EM_OffsetFold:
943  return false;
944  }
945  llvm_unreachable("Missed EvalMode case");
946  }
947 
948  /// Note that we have had a side-effect, and determine whether we should
949  /// keep evaluating.
950  bool noteSideEffect() {
951  EvalStatus.HasSideEffects = true;
952  return keepEvaluatingAfterSideEffect();
953  }
954 
955  /// Should we continue evaluation after encountering undefined behavior?
956  bool keepEvaluatingAfterUndefinedBehavior() {
957  switch (EvalMode) {
958  case EM_EvaluateForOverflow:
959  case EM_IgnoreSideEffects:
960  case EM_ConstantFold:
961  case EM_OffsetFold:
962  return true;
963 
964  case EM_PotentialConstantExpression:
965  case EM_PotentialConstantExpressionUnevaluated:
966  case EM_ConstantExpression:
967  case EM_ConstantExpressionUnevaluated:
968  return false;
969  }
970  llvm_unreachable("Missed EvalMode case");
971  }
972 
973  /// Note that we hit something that was technically undefined behavior, but
974  /// that we can evaluate past it (such as signed overflow or floating-point
975  /// division by zero.)
976  bool noteUndefinedBehavior() {
977  EvalStatus.HasUndefinedBehavior = true;
978  return keepEvaluatingAfterUndefinedBehavior();
979  }
980 
981  /// Should we continue evaluation as much as possible after encountering a
982  /// construct which can't be reduced to a value?
983  bool keepEvaluatingAfterFailure() {
984  if (!StepsLeft)
985  return false;
986 
987  switch (EvalMode) {
988  case EM_PotentialConstantExpression:
989  case EM_PotentialConstantExpressionUnevaluated:
990  case EM_EvaluateForOverflow:
991  return true;
992 
993  case EM_ConstantExpression:
994  case EM_ConstantExpressionUnevaluated:
995  case EM_ConstantFold:
996  case EM_IgnoreSideEffects:
997  case EM_OffsetFold:
998  return false;
999  }
1000  llvm_unreachable("Missed EvalMode case");
1001  }
1002 
1003  /// Notes that we failed to evaluate an expression that other expressions
1004  /// directly depend on, and determine if we should keep evaluating. This
1005  /// should only be called if we actually intend to keep evaluating.
1006  ///
1007  /// Call noteSideEffect() instead if we may be able to ignore the value that
1008  /// we failed to evaluate, e.g. if we failed to evaluate Foo() in:
1009  ///
1010  /// (Foo(), 1) // use noteSideEffect
1011  /// (Foo() || true) // use noteSideEffect
1012  /// Foo() + 1 // use noteFailure
1013  LLVM_NODISCARD bool noteFailure() {
1014  // Failure when evaluating some expression often means there is some
1015  // subexpression whose evaluation was skipped. Therefore, (because we
1016  // don't track whether we skipped an expression when unwinding after an
1017  // evaluation failure) every evaluation failure that bubbles up from a
1018  // subexpression implies that a side-effect has potentially happened. We
1019  // skip setting the HasSideEffects flag to true until we decide to
1020  // continue evaluating after that point, which happens here.
1021  bool KeepGoing = keepEvaluatingAfterFailure();
1022  EvalStatus.HasSideEffects |= KeepGoing;
1023  return KeepGoing;
1024  }
1025 
1026  class ArrayInitLoopIndex {
1027  EvalInfo &Info;
1028  uint64_t OuterIndex;
1029 
1030  public:
1031  ArrayInitLoopIndex(EvalInfo &Info)
1032  : Info(Info), OuterIndex(Info.ArrayInitIndex) {
1033  Info.ArrayInitIndex = 0;
1034  }
1035  ~ArrayInitLoopIndex() { Info.ArrayInitIndex = OuterIndex; }
1036 
1037  operator uint64_t&() { return Info.ArrayInitIndex; }
1038  };
1039  };
1040 
1041  /// Object used to treat all foldable expressions as constant expressions.
1042  struct FoldConstant {
1043  EvalInfo &Info;
1044  bool Enabled;
1045  bool HadNoPriorDiags;
1046  EvalInfo::EvaluationMode OldMode;
1047 
1048  explicit FoldConstant(EvalInfo &Info, bool Enabled)
1049  : Info(Info),
1050  Enabled(Enabled),
1051  HadNoPriorDiags(Info.EvalStatus.Diag &&
1052  Info.EvalStatus.Diag->empty() &&
1053  !Info.EvalStatus.HasSideEffects),
1054  OldMode(Info.EvalMode) {
1055  if (Enabled &&
1056  (Info.EvalMode == EvalInfo::EM_ConstantExpression ||
1057  Info.EvalMode == EvalInfo::EM_ConstantExpressionUnevaluated))
1058  Info.EvalMode = EvalInfo::EM_ConstantFold;
1059  }
1060  void keepDiagnostics() { Enabled = false; }
1061  ~FoldConstant() {
1062  if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
1063  !Info.EvalStatus.HasSideEffects)
1064  Info.EvalStatus.Diag->clear();
1065  Info.EvalMode = OldMode;
1066  }
1067  };
1068 
1069  /// RAII object used to treat the current evaluation as the correct pointer
1070  /// offset fold for the current EvalMode
1071  struct FoldOffsetRAII {
1072  EvalInfo &Info;
1073  EvalInfo::EvaluationMode OldMode;
1074  explicit FoldOffsetRAII(EvalInfo &Info)
1075  : Info(Info), OldMode(Info.EvalMode) {
1076  if (!Info.checkingPotentialConstantExpression())
1077  Info.EvalMode = EvalInfo::EM_OffsetFold;
1078  }
1079 
1080  ~FoldOffsetRAII() { Info.EvalMode = OldMode; }
1081  };
1082 
1083  /// RAII object used to optionally suppress diagnostics and side-effects from
1084  /// a speculative evaluation.
1085  class SpeculativeEvaluationRAII {
1086  EvalInfo *Info = nullptr;
1087  Expr::EvalStatus OldStatus;
1088  bool OldIsSpeculativelyEvaluating;
1089 
1090  void moveFromAndCancel(SpeculativeEvaluationRAII &&Other) {
1091  Info = Other.Info;
1092  OldStatus = Other.OldStatus;
1093  OldIsSpeculativelyEvaluating = Other.OldIsSpeculativelyEvaluating;
1094  Other.Info = nullptr;
1095  }
1096 
1097  void maybeRestoreState() {
1098  if (!Info)
1099  return;
1100 
1101  Info->EvalStatus = OldStatus;
1102  Info->IsSpeculativelyEvaluating = OldIsSpeculativelyEvaluating;
1103  }
1104 
1105  public:
1106  SpeculativeEvaluationRAII() = default;
1107 
1108  SpeculativeEvaluationRAII(
1109  EvalInfo &Info, SmallVectorImpl<PartialDiagnosticAt> *NewDiag = nullptr)
1110  : Info(&Info), OldStatus(Info.EvalStatus),
1111  OldIsSpeculativelyEvaluating(Info.IsSpeculativelyEvaluating) {
1112  Info.EvalStatus.Diag = NewDiag;
1113  Info.IsSpeculativelyEvaluating = true;
1114  }
1115 
1116  SpeculativeEvaluationRAII(const SpeculativeEvaluationRAII &Other) = delete;
1117  SpeculativeEvaluationRAII(SpeculativeEvaluationRAII &&Other) {
1118  moveFromAndCancel(std::move(Other));
1119  }
1120 
1121  SpeculativeEvaluationRAII &operator=(SpeculativeEvaluationRAII &&Other) {
1122  maybeRestoreState();
1123  moveFromAndCancel(std::move(Other));
1124  return *this;
1125  }
1126 
1127  ~SpeculativeEvaluationRAII() { maybeRestoreState(); }
1128  };
1129 
1130  /// RAII object wrapping a full-expression or block scope, and handling
1131  /// the ending of the lifetime of temporaries created within it.
1132  template<bool IsFullExpression>
1133  class ScopeRAII {
1134  EvalInfo &Info;
1135  unsigned OldStackSize;
1136  public:
1137  ScopeRAII(EvalInfo &Info)
1138  : Info(Info), OldStackSize(Info.CleanupStack.size()) {
1139  // Push a new temporary version. This is needed to distinguish between
1140  // temporaries created in different iterations of a loop.
1141  Info.CurrentCall->pushTempVersion();
1142  }
1143  ~ScopeRAII() {
1144  // Body moved to a static method to encourage the compiler to inline away
1145  // instances of this class.
1146  cleanup(Info, OldStackSize);
1147  Info.CurrentCall->popTempVersion();
1148  }
1149  private:
1150  static void cleanup(EvalInfo &Info, unsigned OldStackSize) {
1151  unsigned NewEnd = OldStackSize;
1152  for (unsigned I = OldStackSize, N = Info.CleanupStack.size();
1153  I != N; ++I) {
1154  if (IsFullExpression && Info.CleanupStack[I].isLifetimeExtended()) {
1155  // Full-expression cleanup of a lifetime-extended temporary: nothing
1156  // to do, just move this cleanup to the right place in the stack.
1157  std::swap(Info.CleanupStack[I], Info.CleanupStack[NewEnd]);
1158  ++NewEnd;
1159  } else {
1160  // End the lifetime of the object.
1161  Info.CleanupStack[I].endLifetime();
1162  }
1163  }
1164  Info.CleanupStack.erase(Info.CleanupStack.begin() + NewEnd,
1165  Info.CleanupStack.end());
1166  }
1167  };
1168  typedef ScopeRAII<false> BlockScopeRAII;
1169  typedef ScopeRAII<true> FullExpressionRAII;
1170 }
1171 
1172 bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
1173  CheckSubobjectKind CSK) {
1174  if (Invalid)
1175  return false;
1176  if (isOnePastTheEnd()) {
1177  Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
1178  << CSK;
1179  setInvalid();
1180  return false;
1181  }
1182  // Note, we do not diagnose if isMostDerivedAnUnsizedArray(), because there
1183  // must actually be at least one array element; even a VLA cannot have a
1184  // bound of zero. And if our index is nonzero, we already had a CCEDiag.
1185  return true;
1186 }
1187 
1188 void SubobjectDesignator::diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info,
1189  const Expr *E) {
1190  Info.CCEDiag(E, diag::note_constexpr_unsized_array_indexed);
1191  // Do not set the designator as invalid: we can represent this situation,
1192  // and correct handling of __builtin_object_size requires us to do so.
1193 }
1194 
1195 void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
1196  const Expr *E,
1197  const APSInt &N) {
1198  // If we're complaining, we must be able to statically determine the size of
1199  // the most derived array.
1200  if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)
1201  Info.CCEDiag(E, diag::note_constexpr_array_index)
1202  << N << /*array*/ 0
1203  << static_cast<unsigned>(getMostDerivedArraySize());
1204  else
1205  Info.CCEDiag(E, diag::note_constexpr_array_index)
1206  << N << /*non-array*/ 1;
1207  setInvalid();
1208 }
1209 
1210 CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
1211  const FunctionDecl *Callee, const LValue *This,
1212  APValue *Arguments)
1213  : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This),
1214  Arguments(Arguments), CallLoc(CallLoc), Index(Info.NextCallIndex++) {
1215  Info.CurrentCall = this;
1216  ++Info.CallStackDepth;
1217 }
1218 
1219 CallStackFrame::~CallStackFrame() {
1220  assert(Info.CurrentCall == this && "calls retired out of order");
1221  --Info.CallStackDepth;
1222  Info.CurrentCall = Caller;
1223 }
1224 
1225 APValue &CallStackFrame::createTemporary(const void *Key,
1226  bool IsLifetimeExtended) {
1227  unsigned Version = Info.CurrentCall->getTempVersion();
1228  APValue &Result = Temporaries[MapKeyTy(Key, Version)];
1229  assert(Result.isUninit() && "temporary created multiple times");
1230  Info.CleanupStack.push_back(Cleanup(&Result, IsLifetimeExtended));
1231  return Result;
1232 }
1233 
1234 static void describeCall(CallStackFrame *Frame, raw_ostream &Out);
1235 
1236 void EvalInfo::addCallStack(unsigned Limit) {
1237  // Determine which calls to skip, if any.
1238  unsigned ActiveCalls = CallStackDepth - 1;
1239  unsigned SkipStart = ActiveCalls, SkipEnd = SkipStart;
1240  if (Limit && Limit < ActiveCalls) {
1241  SkipStart = Limit / 2 + Limit % 2;
1242  SkipEnd = ActiveCalls - Limit / 2;
1243  }
1244 
1245  // Walk the call stack and add the diagnostics.
1246  unsigned CallIdx = 0;
1247  for (CallStackFrame *Frame = CurrentCall; Frame != &BottomFrame;
1248  Frame = Frame->Caller, ++CallIdx) {
1249  // Skip this call?
1250  if (CallIdx >= SkipStart && CallIdx < SkipEnd) {
1251  if (CallIdx == SkipStart) {
1252  // Note that we're skipping calls.
1253  addDiag(Frame->CallLoc, diag::note_constexpr_calls_suppressed)
1254  << unsigned(ActiveCalls - Limit);
1255  }
1256  continue;
1257  }
1258 
1259  // Use a different note for an inheriting constructor, because from the
1260  // user's perspective it's not really a function at all.
1261  if (auto *CD = dyn_cast_or_null<CXXConstructorDecl>(Frame->Callee)) {
1262  if (CD->isInheritingConstructor()) {
1263  addDiag(Frame->CallLoc, diag::note_constexpr_inherited_ctor_call_here)
1264  << CD->getParent();
1265  continue;
1266  }
1267  }
1268 
1269  SmallVector<char, 128> Buffer;
1270  llvm::raw_svector_ostream Out(Buffer);
1271  describeCall(Frame, Out);
1272  addDiag(Frame->CallLoc, diag::note_constexpr_call_here) << Out.str();
1273  }
1274 }
1275 
1276 namespace {
1277  struct ComplexValue {
1278  private:
1279  bool IsInt;
1280 
1281  public:
1282  APSInt IntReal, IntImag;
1283  APFloat FloatReal, FloatImag;
1284 
1285  ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
1286 
1287  void makeComplexFloat() { IsInt = false; }
1288  bool isComplexFloat() const { return !IsInt; }
1289  APFloat &getComplexFloatReal() { return FloatReal; }
1290  APFloat &getComplexFloatImag() { return FloatImag; }
1291 
1292  void makeComplexInt() { IsInt = true; }
1293  bool isComplexInt() const { return IsInt; }
1294  APSInt &getComplexIntReal() { return IntReal; }
1295  APSInt &getComplexIntImag() { return IntImag; }
1296 
1297  void moveInto(APValue &v) const {
1298  if (isComplexFloat())
1299  v = APValue(FloatReal, FloatImag);
1300  else
1301  v = APValue(IntReal, IntImag);
1302  }
1303  void setFrom(const APValue &v) {
1304  assert(v.isComplexFloat() || v.isComplexInt());
1305  if (v.isComplexFloat()) {
1306  makeComplexFloat();
1307  FloatReal = v.getComplexFloatReal();
1308  FloatImag = v.getComplexFloatImag();
1309  } else {
1310  makeComplexInt();
1311  IntReal = v.getComplexIntReal();
1312  IntImag = v.getComplexIntImag();
1313  }
1314  }
1315  };
1316 
1317  struct LValue {
1318  APValue::LValueBase Base;
1319  CharUnits Offset;
1320  SubobjectDesignator Designator;
1321  bool IsNullPtr : 1;
1322  bool InvalidBase : 1;
1323 
1324  const APValue::LValueBase getLValueBase() const { return Base; }
1325  CharUnits &getLValueOffset() { return Offset; }
1326  const CharUnits &getLValueOffset() const { return Offset; }
1327  SubobjectDesignator &getLValueDesignator() { return Designator; }
1328  const SubobjectDesignator &getLValueDesignator() const { return Designator;}
1329  bool isNullPointer() const { return IsNullPtr;}
1330 
1331  unsigned getLValueCallIndex() const { return Base.getCallIndex(); }
1332  unsigned getLValueVersion() const { return Base.getVersion(); }
1333 
1334  void moveInto(APValue &V) const {
1335  if (Designator.Invalid)
1336  V = APValue(Base, Offset, APValue::NoLValuePath(), IsNullPtr);
1337  else {
1338  assert(!InvalidBase && "APValues can't handle invalid LValue bases");
1339  V = APValue(Base, Offset, Designator.Entries,
1340  Designator.IsOnePastTheEnd, IsNullPtr);
1341  }
1342  }
1343  void setFrom(ASTContext &Ctx, const APValue &V) {
1344  assert(V.isLValue() && "Setting LValue from a non-LValue?");
1345  Base = V.getLValueBase();
1346  Offset = V.getLValueOffset();
1347  InvalidBase = false;
1348  Designator = SubobjectDesignator(Ctx, V);
1349  IsNullPtr = V.isNullPointer();
1350  }
1351 
1352  void set(APValue::LValueBase B, bool BInvalid = false) {
1353 #ifndef NDEBUG
1354  // We only allow a few types of invalid bases. Enforce that here.
1355  if (BInvalid) {
1356  const auto *E = B.get<const Expr *>();
1357  assert((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&
1358  "Unexpected type of invalid base");
1359  }
1360 #endif
1361 
1362  Base = B;
1363  Offset = CharUnits::fromQuantity(0);
1364  InvalidBase = BInvalid;
1365  Designator = SubobjectDesignator(getType(B));
1366  IsNullPtr = false;
1367  }
1368 
1369  void setNull(QualType PointerTy, uint64_t TargetVal) {
1370  Base = (Expr *)nullptr;
1371  Offset = CharUnits::fromQuantity(TargetVal);
1372  InvalidBase = false;
1373  Designator = SubobjectDesignator(PointerTy->getPointeeType());
1374  IsNullPtr = true;
1375  }
1376 
1377  void setInvalid(APValue::LValueBase B, unsigned I = 0) {
1378  set(B, true);
1379  }
1380 
1381  // Check that this LValue is not based on a null pointer. If it is, produce
1382  // a diagnostic and mark the designator as invalid.
1383  bool checkNullPointer(EvalInfo &Info, const Expr *E,
1384  CheckSubobjectKind CSK) {
1385  if (Designator.Invalid)
1386  return false;
1387  if (IsNullPtr) {
1388  Info.CCEDiag(E, diag::note_constexpr_null_subobject)
1389  << CSK;
1390  Designator.setInvalid();
1391  return false;
1392  }
1393  return true;
1394  }
1395 
1396  // Check this LValue refers to an object. If not, set the designator to be
1397  // invalid and emit a diagnostic.
1398  bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {
1399  return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
1400  Designator.checkSubobject(Info, E, CSK);
1401  }
1402 
1403  void addDecl(EvalInfo &Info, const Expr *E,
1404  const Decl *D, bool Virtual = false) {
1405  if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
1406  Designator.addDeclUnchecked(D, Virtual);
1407  }
1408  void addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) {
1409  if (!Designator.Entries.empty()) {
1410  Info.CCEDiag(E, diag::note_constexpr_unsupported_unsized_array);
1411  Designator.setInvalid();
1412  return;
1413  }
1414  if (checkSubobject(Info, E, CSK_ArrayToPointer)) {
1415  assert(getType(Base)->isPointerType() || getType(Base)->isArrayType());
1416  Designator.FirstEntryIsAnUnsizedArray = true;
1417  Designator.addUnsizedArrayUnchecked(ElemTy);
1418  }
1419  }
1420  void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
1421  if (checkSubobject(Info, E, CSK_ArrayToPointer))
1422  Designator.addArrayUnchecked(CAT);
1423  }
1424  void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
1425  if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
1426  Designator.addComplexUnchecked(EltTy, Imag);
1427  }
1428  void clearIsNullPointer() {
1429  IsNullPtr = false;
1430  }
1431  void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
1432  const APSInt &Index, CharUnits ElementSize) {
1433  // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB,
1434  // but we're not required to diagnose it and it's valid in C++.)
1435  if (!Index)
1436  return;
1437 
1438  // Compute the new offset in the appropriate width, wrapping at 64 bits.
1439  // FIXME: When compiling for a 32-bit target, we should use 32-bit
1440  // offsets.
1441  uint64_t Offset64 = Offset.getQuantity();
1442  uint64_t ElemSize64 = ElementSize.getQuantity();
1443  uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
1444  Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64);
1445 
1446  if (checkNullPointer(Info, E, CSK_ArrayIndex))
1447  Designator.adjustIndex(Info, E, Index);
1448  clearIsNullPointer();
1449  }
1450  void adjustOffset(CharUnits N) {
1451  Offset += N;
1452  if (N.getQuantity())
1453  clearIsNullPointer();
1454  }
1455  };
1456 
1457  struct MemberPtr {
1458  MemberPtr() {}
1459  explicit MemberPtr(const ValueDecl *Decl) :
1460  DeclAndIsDerivedMember(Decl, false), Path() {}
1461 
1462  /// The member or (direct or indirect) field referred to by this member
1463  /// pointer, or 0 if this is a null member pointer.
1464  const ValueDecl *getDecl() const {
1465  return DeclAndIsDerivedMember.getPointer();
1466  }
1467  /// Is this actually a member of some type derived from the relevant class?
1468  bool isDerivedMember() const {
1469  return DeclAndIsDerivedMember.getInt();
1470  }
1471  /// Get the class which the declaration actually lives in.
1472  const CXXRecordDecl *getContainingRecord() const {
1473  return cast<CXXRecordDecl>(
1474  DeclAndIsDerivedMember.getPointer()->getDeclContext());
1475  }
1476 
1477  void moveInto(APValue &V) const {
1478  V = APValue(getDecl(), isDerivedMember(), Path);
1479  }
1480  void setFrom(const APValue &V) {
1481  assert(V.isMemberPointer());
1482  DeclAndIsDerivedMember.setPointer(V.getMemberPointerDecl());
1483  DeclAndIsDerivedMember.setInt(V.isMemberPointerToDerivedMember());
1484  Path.clear();
1486  Path.insert(Path.end(), P.begin(), P.end());
1487  }
1488 
1489  /// DeclAndIsDerivedMember - The member declaration, and a flag indicating
1490  /// whether the member is a member of some class derived from the class type
1491  /// of the member pointer.
1492  llvm::PointerIntPair<const ValueDecl*, 1, bool> DeclAndIsDerivedMember;
1493  /// Path - The path of base/derived classes from the member declaration's
1494  /// class (exclusive) to the class type of the member pointer (inclusive).
1496 
1497  /// Perform a cast towards the class of the Decl (either up or down the
1498  /// hierarchy).
1499  bool castBack(const CXXRecordDecl *Class) {
1500  assert(!Path.empty());
1501  const CXXRecordDecl *Expected;
1502  if (Path.size() >= 2)
1503  Expected = Path[Path.size() - 2];
1504  else
1505  Expected = getContainingRecord();
1506  if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) {
1507  // C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*),
1508  // if B does not contain the original member and is not a base or
1509  // derived class of the class containing the original member, the result
1510  // of the cast is undefined.
1511  // C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to
1512  // (D::*). We consider that to be a language defect.
1513  return false;
1514  }
1515  Path.pop_back();
1516  return true;
1517  }
1518  /// Perform a base-to-derived member pointer cast.
1519  bool castToDerived(const CXXRecordDecl *Derived) {
1520  if (!getDecl())
1521  return true;
1522  if (!isDerivedMember()) {
1523  Path.push_back(Derived);
1524  return true;
1525  }
1526  if (!castBack(Derived))
1527  return false;
1528  if (Path.empty())
1529  DeclAndIsDerivedMember.setInt(false);
1530  return true;
1531  }
1532  /// Perform a derived-to-base member pointer cast.
1533  bool castToBase(const CXXRecordDecl *Base) {
1534  if (!getDecl())
1535  return true;
1536  if (Path.empty())
1537  DeclAndIsDerivedMember.setInt(true);
1538  if (isDerivedMember()) {
1539  Path.push_back(Base);
1540  return true;
1541  }
1542  return castBack(Base);
1543  }
1544  };
1545 
1546  /// Compare two member pointers, which are assumed to be of the same type.
1547  static bool operator==(const MemberPtr &LHS, const MemberPtr &RHS) {
1548  if (!LHS.getDecl() || !RHS.getDecl())
1549  return !LHS.getDecl() && !RHS.getDecl();
1550  if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl())
1551  return false;
1552  return LHS.Path == RHS.Path;
1553  }
1554 }
1555 
1556 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E);
1557 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info,
1558  const LValue &This, const Expr *E,
1559  bool AllowNonLiteralTypes = false);
1560 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
1561  bool InvalidBaseOK = false);
1562 static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info,
1563  bool InvalidBaseOK = false);
1564 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
1565  EvalInfo &Info);
1566 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info);
1567 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
1568 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
1569  EvalInfo &Info);
1570 static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
1571 static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info);
1572 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
1573  EvalInfo &Info);
1574 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result);
1575 
1576 //===----------------------------------------------------------------------===//
1577 // Misc utilities
1578 //===----------------------------------------------------------------------===//
1579 
1580 /// A helper function to create a temporary and set an LValue.
1581 template <class KeyTy>
1582 static APValue &createTemporary(const KeyTy *Key, bool IsLifetimeExtended,
1583  LValue &LV, CallStackFrame &Frame) {
1584  LV.set({Key, Frame.Info.CurrentCall->Index,
1585  Frame.Info.CurrentCall->getTempVersion()});
1586  return Frame.createTemporary(Key, IsLifetimeExtended);
1587 }
1588 
1589 /// Negate an APSInt in place, converting it to a signed form if necessary, and
1590 /// preserving its value (by extending by up to one bit as needed).
1591 static void negateAsSigned(APSInt &Int) {
1592  if (Int.isUnsigned() || Int.isMinSignedValue()) {
1593  Int = Int.extend(Int.getBitWidth() + 1);
1594  Int.setIsSigned(true);
1595  }
1596  Int = -Int;
1597 }
1598 
1599 /// Produce a string describing the given constexpr call.
1600 static void describeCall(CallStackFrame *Frame, raw_ostream &Out) {
1601  unsigned ArgIndex = 0;
1602  bool IsMemberCall = isa<CXXMethodDecl>(Frame->Callee) &&
1603  !isa<CXXConstructorDecl>(Frame->Callee) &&
1604  cast<CXXMethodDecl>(Frame->Callee)->isInstance();
1605 
1606  if (!IsMemberCall)
1607  Out << *Frame->Callee << '(';
1608 
1609  if (Frame->This && IsMemberCall) {
1610  APValue Val;
1611  Frame->This->moveInto(Val);
1612  Val.printPretty(Out, Frame->Info.Ctx,
1613  Frame->This->Designator.MostDerivedType);
1614  // FIXME: Add parens around Val if needed.
1615  Out << "->" << *Frame->Callee << '(';
1616  IsMemberCall = false;
1617  }
1618 
1619  for (FunctionDecl::param_const_iterator I = Frame->Callee->param_begin(),
1620  E = Frame->Callee->param_end(); I != E; ++I, ++ArgIndex) {
1621  if (ArgIndex > (unsigned)IsMemberCall)
1622  Out << ", ";
1623 
1624  const ParmVarDecl *Param = *I;
1625  const APValue &Arg = Frame->Arguments[ArgIndex];
1626  Arg.printPretty(Out, Frame->Info.Ctx, Param->getType());
1627 
1628  if (ArgIndex == 0 && IsMemberCall)
1629  Out << "->" << *Frame->Callee << '(';
1630  }
1631 
1632  Out << ')';
1633 }
1634 
1635 /// Evaluate an expression to see if it had side-effects, and discard its
1636 /// result.
1637 /// \return \c true if the caller should keep evaluating.
1638 static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
1639  APValue Scratch;
1640  if (!Evaluate(Scratch, Info, E))
1641  // We don't need the value, but we might have skipped a side effect here.
1642  return Info.noteSideEffect();
1643  return true;
1644 }
1645 
1646 /// Should this call expression be treated as a string literal?
1647 static bool IsStringLiteralCall(const CallExpr *E) {
1648  unsigned Builtin = E->getBuiltinCallee();
1649  return (Builtin == Builtin::BI__builtin___CFStringMakeConstantString ||
1650  Builtin == Builtin::BI__builtin___NSStringMakeConstantString);
1651 }
1652 
1654  // C++11 [expr.const]p3 An address constant expression is a prvalue core
1655  // constant expression of pointer type that evaluates to...
1656 
1657  // ... a null pointer value, or a prvalue core constant expression of type
1658  // std::nullptr_t.
1659  if (!B) return true;
1660 
1661  if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
1662  // ... the address of an object with static storage duration,
1663  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1664  return VD->hasGlobalStorage();
1665  // ... the address of a function,
1666  return isa<FunctionDecl>(D);
1667  }
1668 
1669  const Expr *E = B.get<const Expr*>();
1670  switch (E->getStmtClass()) {
1671  default:
1672  return false;
1673  case Expr::CompoundLiteralExprClass: {
1674  const CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
1675  return CLE->isFileScope() && CLE->isLValue();
1676  }
1677  case Expr::MaterializeTemporaryExprClass:
1678  // A materialized temporary might have been lifetime-extended to static
1679  // storage duration.
1680  return cast<MaterializeTemporaryExpr>(E)->getStorageDuration() == SD_Static;
1681  // A string literal has static storage duration.
1682  case Expr::StringLiteralClass:
1683  case Expr::PredefinedExprClass:
1684  case Expr::ObjCStringLiteralClass:
1685  case Expr::ObjCEncodeExprClass:
1686  case Expr::CXXTypeidExprClass:
1687  case Expr::CXXUuidofExprClass:
1688  return true;
1689  case Expr::CallExprClass:
1690  return IsStringLiteralCall(cast<CallExpr>(E));
1691  // For GCC compatibility, &&label has static storage duration.
1692  case Expr::AddrLabelExprClass:
1693  return true;
1694  // A Block literal expression may be used as the initialization value for
1695  // Block variables at global or local static scope.
1696  case Expr::BlockExprClass:
1697  return !cast<BlockExpr>(E)->getBlockDecl()->hasCaptures();
1698  case Expr::ImplicitValueInitExprClass:
1699  // FIXME:
1700  // We can never form an lvalue with an implicit value initialization as its
1701  // base through expression evaluation, so these only appear in one case: the
1702  // implicit variable declaration we invent when checking whether a constexpr
1703  // constructor can produce a constant expression. We must assume that such
1704  // an expression might be a global lvalue.
1705  return true;
1706  }
1707 }
1708 
1709 static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) {
1710  assert(Base && "no location for a null lvalue");
1711  const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1712  if (VD)
1713  Info.Note(VD->getLocation(), diag::note_declared_at);
1714  else
1715  Info.Note(Base.get<const Expr*>()->getExprLoc(),
1716  diag::note_constexpr_temporary_here);
1717 }
1718 
1719 /// Check that this reference or pointer core constant expression is a valid
1720 /// value for an address or reference constant expression. Return true if we
1721 /// can fold this expression, whether or not it's a constant expression.
1722 static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
1723  QualType Type, const LValue &LVal,
1724  Expr::ConstExprUsage Usage) {
1725  bool IsReferenceType = Type->isReferenceType();
1726 
1727  APValue::LValueBase Base = LVal.getLValueBase();
1728  const SubobjectDesignator &Designator = LVal.getLValueDesignator();
1729 
1730  // Check that the object is a global. Note that the fake 'this' object we
1731  // manufacture when checking potential constant expressions is conservatively
1732  // assumed to be global here.
1733  if (!IsGlobalLValue(Base)) {
1734  if (Info.getLangOpts().CPlusPlus11) {
1735  const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1736  Info.FFDiag(Loc, diag::note_constexpr_non_global, 1)
1737  << IsReferenceType << !Designator.Entries.empty()
1738  << !!VD << VD;
1739  NoteLValueLocation(Info, Base);
1740  } else {
1741  Info.FFDiag(Loc);
1742  }
1743  // Don't allow references to temporaries to escape.
1744  return false;
1745  }
1746  assert((Info.checkingPotentialConstantExpression() ||
1747  LVal.getLValueCallIndex() == 0) &&
1748  "have call index for global lvalue");
1749 
1750  if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
1751  if (const VarDecl *Var = dyn_cast<const VarDecl>(VD)) {
1752  // Check if this is a thread-local variable.
1753  if (Var->getTLSKind())
1754  return false;
1755 
1756  // A dllimport variable never acts like a constant.
1757  if (Usage == Expr::EvaluateForCodeGen && Var->hasAttr<DLLImportAttr>())
1758  return false;
1759  }
1760  if (const auto *FD = dyn_cast<const FunctionDecl>(VD)) {
1761  // __declspec(dllimport) must be handled very carefully:
1762  // We must never initialize an expression with the thunk in C++.
1763  // Doing otherwise would allow the same id-expression to yield
1764  // different addresses for the same function in different translation
1765  // units. However, this means that we must dynamically initialize the
1766  // expression with the contents of the import address table at runtime.
1767  //
1768  // The C language has no notion of ODR; furthermore, it has no notion of
1769  // dynamic initialization. This means that we are permitted to
1770  // perform initialization with the address of the thunk.
1771  if (Info.getLangOpts().CPlusPlus && Usage == Expr::EvaluateForCodeGen &&
1772  FD->hasAttr<DLLImportAttr>())
1773  return false;
1774  }
1775  }
1776 
1777  // Allow address constant expressions to be past-the-end pointers. This is
1778  // an extension: the standard requires them to point to an object.
1779  if (!IsReferenceType)
1780  return true;
1781 
1782  // A reference constant expression must refer to an object.
1783  if (!Base) {
1784  // FIXME: diagnostic
1785  Info.CCEDiag(Loc);
1786  return true;
1787  }
1788 
1789  // Does this refer one past the end of some object?
1790  if (!Designator.Invalid && Designator.isOnePastTheEnd()) {
1791  const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1792  Info.FFDiag(Loc, diag::note_constexpr_past_end, 1)
1793  << !Designator.Entries.empty() << !!VD << VD;
1794  NoteLValueLocation(Info, Base);
1795  }
1796 
1797  return true;
1798 }
1799 
1800 /// Member pointers are constant expressions unless they point to a
1801 /// non-virtual dllimport member function.
1802 static bool CheckMemberPointerConstantExpression(EvalInfo &Info,
1803  SourceLocation Loc,
1804  QualType Type,
1805  const APValue &Value,
1806  Expr::ConstExprUsage Usage) {
1807  const ValueDecl *Member = Value.getMemberPointerDecl();
1808  const auto *FD = dyn_cast_or_null<CXXMethodDecl>(Member);
1809  if (!FD)
1810  return true;
1811  return Usage == Expr::EvaluateForMangling || FD->isVirtual() ||
1812  !FD->hasAttr<DLLImportAttr>();
1813 }
1814 
1815 /// Check that this core constant expression is of literal type, and if not,
1816 /// produce an appropriate diagnostic.
1817 static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
1818  const LValue *This = nullptr) {
1819  if (!E->isRValue() || E->getType()->isLiteralType(Info.Ctx))
1820  return true;
1821 
1822  // C++1y: A constant initializer for an object o [...] may also invoke
1823  // constexpr constructors for o and its subobjects even if those objects
1824  // are of non-literal class types.
1825  //
1826  // C++11 missed this detail for aggregates, so classes like this:
1827  // struct foo_t { union { int i; volatile int j; } u; };
1828  // are not (obviously) initializable like so:
1829  // __attribute__((__require_constant_initialization__))
1830  // static const foo_t x = {{0}};
1831  // because "i" is a subobject with non-literal initialization (due to the
1832  // volatile member of the union). See:
1833  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1677
1834  // Therefore, we use the C++1y behavior.
1835  if (This && Info.EvaluatingDecl == This->getLValueBase())
1836  return true;
1837 
1838  // Prvalue constant expressions must be of literal types.
1839  if (Info.getLangOpts().CPlusPlus11)
1840  Info.FFDiag(E, diag::note_constexpr_nonliteral)
1841  << E->getType();
1842  else
1843  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
1844  return false;
1845 }
1846 
1847 /// Check that this core constant expression value is a valid value for a
1848 /// constant expression. If not, report an appropriate diagnostic. Does not
1849 /// check that the expression is of literal type.
1850 static bool
1851 CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc, QualType Type,
1852  const APValue &Value,
1854  if (Value.isUninit()) {
1855  Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized)
1856  << true << Type;
1857  return false;
1858  }
1859 
1860  // We allow _Atomic(T) to be initialized from anything that T can be
1861  // initialized from.
1862  if (const AtomicType *AT = Type->getAs<AtomicType>())
1863  Type = AT->getValueType();
1864 
1865  // Core issue 1454: For a literal constant expression of array or class type,
1866  // each subobject of its value shall have been initialized by a constant
1867  // expression.
1868  if (Value.isArray()) {
1869  QualType EltTy = Type->castAsArrayTypeUnsafe()->getElementType();
1870  for (unsigned I = 0, N = Value.getArrayInitializedElts(); I != N; ++I) {
1871  if (!CheckConstantExpression(Info, DiagLoc, EltTy,
1872  Value.getArrayInitializedElt(I), Usage))
1873  return false;
1874  }
1875  if (!Value.hasArrayFiller())
1876  return true;
1877  return CheckConstantExpression(Info, DiagLoc, EltTy, Value.getArrayFiller(),
1878  Usage);
1879  }
1880  if (Value.isUnion() && Value.getUnionField()) {
1881  return CheckConstantExpression(Info, DiagLoc,
1882  Value.getUnionField()->getType(),
1883  Value.getUnionValue(), Usage);
1884  }
1885  if (Value.isStruct()) {
1886  RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
1887  if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
1888  unsigned BaseIndex = 0;
1889  for (const CXXBaseSpecifier &BS : CD->bases()) {
1890  if (!CheckConstantExpression(Info, DiagLoc, BS.getType(),
1891  Value.getStructBase(BaseIndex), Usage))
1892  return false;
1893  ++BaseIndex;
1894  }
1895  }
1896  for (const auto *I : RD->fields()) {
1897  if (I->isUnnamedBitfield())
1898  continue;
1899 
1900  if (!CheckConstantExpression(Info, DiagLoc, I->getType(),
1901  Value.getStructField(I->getFieldIndex()),
1902  Usage))
1903  return false;
1904  }
1905  }
1906 
1907  if (Value.isLValue()) {
1908  LValue LVal;
1909  LVal.setFrom(Info.Ctx, Value);
1910  return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal, Usage);
1911  }
1912 
1913  if (Value.isMemberPointer())
1914  return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value, Usage);
1915 
1916  // Everything else is fine.
1917  return true;
1918 }
1919 
1920 static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) {
1921  return LVal.Base.dyn_cast<const ValueDecl*>();
1922 }
1923 
1924 static bool IsLiteralLValue(const LValue &Value) {
1925  if (Value.getLValueCallIndex())
1926  return false;
1927  const Expr *E = Value.Base.dyn_cast<const Expr*>();
1928  return E && !isa<MaterializeTemporaryExpr>(E);
1929 }
1930 
1931 static bool IsWeakLValue(const LValue &Value) {
1932  const ValueDecl *Decl = GetLValueBaseDecl(Value);
1933  return Decl && Decl->isWeak();
1934 }
1935 
1936 static bool isZeroSized(const LValue &Value) {
1937  const ValueDecl *Decl = GetLValueBaseDecl(Value);
1938  if (Decl && isa<VarDecl>(Decl)) {
1939  QualType Ty = Decl->getType();
1940  if (Ty->isArrayType())
1941  return Ty->isIncompleteType() ||
1942  Decl->getASTContext().getTypeSize(Ty) == 0;
1943  }
1944  return false;
1945 }
1946 
1947 static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) {
1948  // A null base expression indicates a null pointer. These are always
1949  // evaluatable, and they are false unless the offset is zero.
1950  if (!Value.getLValueBase()) {
1951  Result = !Value.getLValueOffset().isZero();
1952  return true;
1953  }
1954 
1955  // We have a non-null base. These are generally known to be true, but if it's
1956  // a weak declaration it can be null at runtime.
1957  Result = true;
1958  const ValueDecl *Decl = Value.getLValueBase().dyn_cast<const ValueDecl*>();
1959  return !Decl || !Decl->isWeak();
1960 }
1961 
1962 static bool HandleConversionToBool(const APValue &Val, bool &Result) {
1963  switch (Val.getKind()) {
1965  return false;
1966  case APValue::Int:
1967  Result = Val.getInt().getBoolValue();
1968  return true;
1969  case APValue::Float:
1970  Result = !Val.getFloat().isZero();
1971  return true;
1972  case APValue::ComplexInt:
1973  Result = Val.getComplexIntReal().getBoolValue() ||
1974  Val.getComplexIntImag().getBoolValue();
1975  return true;
1976  case APValue::ComplexFloat:
1977  Result = !Val.getComplexFloatReal().isZero() ||
1978  !Val.getComplexFloatImag().isZero();
1979  return true;
1980  case APValue::LValue:
1981  return EvalPointerValueAsBool(Val, Result);
1983  Result = Val.getMemberPointerDecl();
1984  return true;
1985  case APValue::Vector:
1986  case APValue::Array:
1987  case APValue::Struct:
1988  case APValue::Union:
1990  return false;
1991  }
1992 
1993  llvm_unreachable("unknown APValue kind");
1994 }
1995 
1996 static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
1997  EvalInfo &Info) {
1998  assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition");
1999  APValue Val;
2000  if (!Evaluate(Val, Info, E))
2001  return false;
2002  return HandleConversionToBool(Val, Result);
2003 }
2004 
2005 template<typename T>
2006 static bool HandleOverflow(EvalInfo &Info, const Expr *E,
2007  const T &SrcValue, QualType DestType) {
2008  Info.CCEDiag(E, diag::note_constexpr_overflow)
2009  << SrcValue << DestType;
2010  return Info.noteUndefinedBehavior();
2011 }
2012 
2013 static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
2014  QualType SrcType, const APFloat &Value,
2015  QualType DestType, APSInt &Result) {
2016  unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
2017  // Determine whether we are converting to unsigned or signed.
2018  bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
2019 
2020  Result = APSInt(DestWidth, !DestSigned);
2021  bool ignored;
2022  if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
2023  & APFloat::opInvalidOp)
2024  return HandleOverflow(Info, E, Value, DestType);
2025  return true;
2026 }
2027 
2028 static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E,
2029  QualType SrcType, QualType DestType,
2030  APFloat &Result) {
2031  APFloat Value = Result;
2032  bool ignored;
2033  if (Result.convert(Info.Ctx.getFloatTypeSemantics(DestType),
2034  APFloat::rmNearestTiesToEven, &ignored)
2035  & APFloat::opOverflow)
2036  return HandleOverflow(Info, E, Value, DestType);
2037  return true;
2038 }
2039 
2040 static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E,
2041  QualType DestType, QualType SrcType,
2042  const APSInt &Value) {
2043  unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
2044  APSInt Result = Value;
2045  // Figure out if this is a truncate, extend or noop cast.
2046  // If the input is signed, do a sign extend, noop, or truncate.
2047  Result = Result.extOrTrunc(DestWidth);
2048  Result.setIsUnsigned(DestType->isUnsignedIntegerOrEnumerationType());
2049  return Result;
2050 }
2051 
2052 static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E,
2053  QualType SrcType, const APSInt &Value,
2054  QualType DestType, APFloat &Result) {
2055  Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
2056  if (Result.convertFromAPInt(Value, Value.isSigned(),
2057  APFloat::rmNearestTiesToEven)
2058  & APFloat::opOverflow)
2059  return HandleOverflow(Info, E, Value, DestType);
2060  return true;
2061 }
2062 
2063 static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E,
2064  APValue &Value, const FieldDecl *FD) {
2065  assert(FD->isBitField() && "truncateBitfieldValue on non-bitfield");
2066 
2067  if (!Value.isInt()) {
2068  // Trying to store a pointer-cast-to-integer into a bitfield.
2069  // FIXME: In this case, we should provide the diagnostic for casting
2070  // a pointer to an integer.
2071  assert(Value.isLValue() && "integral value neither int nor lvalue?");
2072  Info.FFDiag(E);
2073  return false;
2074  }
2075 
2076  APSInt &Int = Value.getInt();
2077  unsigned OldBitWidth = Int.getBitWidth();
2078  unsigned NewBitWidth = FD->getBitWidthValue(Info.Ctx);
2079  if (NewBitWidth < OldBitWidth)
2080  Int = Int.trunc(NewBitWidth).extend(OldBitWidth);
2081  return true;
2082 }
2083 
2084 static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E,
2085  llvm::APInt &Res) {
2086  APValue SVal;
2087  if (!Evaluate(SVal, Info, E))
2088  return false;
2089  if (SVal.isInt()) {
2090  Res = SVal.getInt();
2091  return true;
2092  }
2093  if (SVal.isFloat()) {
2094  Res = SVal.getFloat().bitcastToAPInt();
2095  return true;
2096  }
2097  if (SVal.isVector()) {
2098  QualType VecTy = E->getType();
2099  unsigned VecSize = Info.Ctx.getTypeSize(VecTy);
2100  QualType EltTy = VecTy->castAs<VectorType>()->getElementType();
2101  unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
2102  bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
2103  Res = llvm::APInt::getNullValue(VecSize);
2104  for (unsigned i = 0; i < SVal.getVectorLength(); i++) {
2105  APValue &Elt = SVal.getVectorElt(i);
2106  llvm::APInt EltAsInt;
2107  if (Elt.isInt()) {
2108  EltAsInt = Elt.getInt();
2109  } else if (Elt.isFloat()) {
2110  EltAsInt = Elt.getFloat().bitcastToAPInt();
2111  } else {
2112  // Don't try to handle vectors of anything other than int or float
2113  // (not sure if it's possible to hit this case).
2114  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2115  return false;
2116  }
2117  unsigned BaseEltSize = EltAsInt.getBitWidth();
2118  if (BigEndian)
2119  Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i*EltSize+BaseEltSize);
2120  else
2121  Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i*EltSize);
2122  }
2123  return true;
2124  }
2125  // Give up if the input isn't an int, float, or vector. For example, we
2126  // reject "(v4i16)(intptr_t)&a".
2127  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2128  return false;
2129 }
2130 
2131 /// Perform the given integer operation, which is known to need at most BitWidth
2132 /// bits, and check for overflow in the original type (if that type was not an
2133 /// unsigned type).
2134 template<typename Operation>
2135 static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E,
2136  const APSInt &LHS, const APSInt &RHS,
2137  unsigned BitWidth, Operation Op,
2138  APSInt &Result) {
2139  if (LHS.isUnsigned()) {
2140  Result = Op(LHS, RHS);
2141  return true;
2142  }
2143 
2144  APSInt Value(Op(LHS.extend(BitWidth), RHS.extend(BitWidth)), false);
2145  Result = Value.trunc(LHS.getBitWidth());
2146  if (Result.extend(BitWidth) != Value) {
2147  if (Info.checkingForOverflow())
2148  Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
2149  diag::warn_integer_constant_overflow)
2150  << Result.toString(10) << E->getType();
2151  else
2152  return HandleOverflow(Info, E, Value, E->getType());
2153  }
2154  return true;
2155 }
2156 
2157 /// Perform the given binary integer operation.
2158 static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS,
2159  BinaryOperatorKind Opcode, APSInt RHS,
2160  APSInt &Result) {
2161  switch (Opcode) {
2162  default:
2163  Info.FFDiag(E);
2164  return false;
2165  case BO_Mul:
2166  return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() * 2,
2167  std::multiplies<APSInt>(), Result);
2168  case BO_Add:
2169  return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2170  std::plus<APSInt>(), Result);
2171  case BO_Sub:
2172  return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2173  std::minus<APSInt>(), Result);
2174  case BO_And: Result = LHS & RHS; return true;
2175  case BO_Xor: Result = LHS ^ RHS; return true;
2176  case BO_Or: Result = LHS | RHS; return true;
2177  case BO_Div:
2178  case BO_Rem:
2179  if (RHS == 0) {
2180  Info.FFDiag(E, diag::note_expr_divide_by_zero);
2181  return false;
2182  }
2183  Result = (Opcode == BO_Rem ? LHS % RHS : LHS / RHS);
2184  // Check for overflow case: INT_MIN / -1 or INT_MIN % -1. APSInt supports
2185  // this operation and gives the two's complement result.
2186  if (RHS.isNegative() && RHS.isAllOnesValue() &&
2187  LHS.isSigned() && LHS.isMinSignedValue())
2188  return HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1),
2189  E->getType());
2190  return true;
2191  case BO_Shl: {
2192  if (Info.getLangOpts().OpenCL)
2193  // OpenCL 6.3j: shift values are effectively % word size of LHS.
2194  RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2195  static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2196  RHS.isUnsigned());
2197  else if (RHS.isSigned() && RHS.isNegative()) {
2198  // During constant-folding, a negative shift is an opposite shift. Such
2199  // a shift is not a constant expression.
2200  Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2201  RHS = -RHS;
2202  goto shift_right;
2203  }
2204  shift_left:
2205  // C++11 [expr.shift]p1: Shift width must be less than the bit width of
2206  // the shifted type.
2207  unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2208  if (SA != RHS) {
2209  Info.CCEDiag(E, diag::note_constexpr_large_shift)
2210  << RHS << E->getType() << LHS.getBitWidth();
2211  } else if (LHS.isSigned()) {
2212  // C++11 [expr.shift]p2: A signed left shift must have a non-negative
2213  // operand, and must not overflow the corresponding unsigned type.
2214  if (LHS.isNegative())
2215  Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
2216  else if (LHS.countLeadingZeros() < SA)
2217  Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
2218  }
2219  Result = LHS << SA;
2220  return true;
2221  }
2222  case BO_Shr: {
2223  if (Info.getLangOpts().OpenCL)
2224  // OpenCL 6.3j: shift values are effectively % word size of LHS.
2225  RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2226  static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2227  RHS.isUnsigned());
2228  else if (RHS.isSigned() && RHS.isNegative()) {
2229  // During constant-folding, a negative shift is an opposite shift. Such a
2230  // shift is not a constant expression.
2231  Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2232  RHS = -RHS;
2233  goto shift_left;
2234  }
2235  shift_right:
2236  // C++11 [expr.shift]p1: Shift width must be less than the bit width of the
2237  // shifted type.
2238  unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2239  if (SA != RHS)
2240  Info.CCEDiag(E, diag::note_constexpr_large_shift)
2241  << RHS << E->getType() << LHS.getBitWidth();
2242  Result = LHS >> SA;
2243  return true;
2244  }
2245 
2246  case BO_LT: Result = LHS < RHS; return true;
2247  case BO_GT: Result = LHS > RHS; return true;
2248  case BO_LE: Result = LHS <= RHS; return true;
2249  case BO_GE: Result = LHS >= RHS; return true;
2250  case BO_EQ: Result = LHS == RHS; return true;
2251  case BO_NE: Result = LHS != RHS; return true;
2252  case BO_Cmp:
2253  llvm_unreachable("BO_Cmp should be handled elsewhere");
2254  }
2255 }
2256 
2257 /// Perform the given binary floating-point operation, in-place, on LHS.
2258 static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E,
2259  APFloat &LHS, BinaryOperatorKind Opcode,
2260  const APFloat &RHS) {
2261  switch (Opcode) {
2262  default:
2263  Info.FFDiag(E);
2264  return false;
2265  case BO_Mul:
2266  LHS.multiply(RHS, APFloat::rmNearestTiesToEven);
2267  break;
2268  case BO_Add:
2269  LHS.add(RHS, APFloat::rmNearestTiesToEven);
2270  break;
2271  case BO_Sub:
2272  LHS.subtract(RHS, APFloat::rmNearestTiesToEven);
2273  break;
2274  case BO_Div:
2275  LHS.divide(RHS, APFloat::rmNearestTiesToEven);
2276  break;
2277  }
2278 
2279  if (LHS.isInfinity() || LHS.isNaN()) {
2280  Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();
2281  return Info.noteUndefinedBehavior();
2282  }
2283  return true;
2284 }
2285 
2286 /// Cast an lvalue referring to a base subobject to a derived class, by
2287 /// truncating the lvalue's path to the given length.
2288 static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
2289  const RecordDecl *TruncatedType,
2290  unsigned TruncatedElements) {
2291  SubobjectDesignator &D = Result.Designator;
2292 
2293  // Check we actually point to a derived class object.
2294  if (TruncatedElements == D.Entries.size())
2295  return true;
2296  assert(TruncatedElements >= D.MostDerivedPathLength &&
2297  "not casting to a derived class");
2298  if (!Result.checkSubobject(Info, E, CSK_Derived))
2299  return false;
2300 
2301  // Truncate the path to the subobject, and remove any derived-to-base offsets.
2302  const RecordDecl *RD = TruncatedType;
2303  for (unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) {
2304  if (RD->isInvalidDecl()) return false;
2305  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
2306  const CXXRecordDecl *Base = getAsBaseClass(D.Entries[I]);
2307  if (isVirtualBaseClass(D.Entries[I]))
2308  Result.Offset -= Layout.getVBaseClassOffset(Base);
2309  else
2310  Result.Offset -= Layout.getBaseClassOffset(Base);
2311  RD = Base;
2312  }
2313  D.Entries.resize(TruncatedElements);
2314  return true;
2315 }
2316 
2317 static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2318  const CXXRecordDecl *Derived,
2319  const CXXRecordDecl *Base,
2320  const ASTRecordLayout *RL = nullptr) {
2321  if (!RL) {
2322  if (Derived->isInvalidDecl()) return false;
2323  RL = &Info.Ctx.getASTRecordLayout(Derived);
2324  }
2325 
2326  Obj.getLValueOffset() += RL->getBaseClassOffset(Base);
2327  Obj.addDecl(Info, E, Base, /*Virtual*/ false);
2328  return true;
2329 }
2330 
2331 static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2332  const CXXRecordDecl *DerivedDecl,
2333  const CXXBaseSpecifier *Base) {
2334  const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl();
2335 
2336  if (!Base->isVirtual())
2337  return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl);
2338 
2339  SubobjectDesignator &D = Obj.Designator;
2340  if (D.Invalid)
2341  return false;
2342 
2343  // Extract most-derived object and corresponding type.
2344  DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl();
2345  if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength))
2346  return false;
2347 
2348  // Find the virtual base class.
2349  if (DerivedDecl->isInvalidDecl()) return false;
2350  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
2351  Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl);
2352  Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
2353  return true;
2354 }
2355 
2356 static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E,
2357  QualType Type, LValue &Result) {
2358  for (CastExpr::path_const_iterator PathI = E->path_begin(),
2359  PathE = E->path_end();
2360  PathI != PathE; ++PathI) {
2361  if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(),
2362  *PathI))
2363  return false;
2364  Type = (*PathI)->getType();
2365  }
2366  return true;
2367 }
2368 
2369 /// Update LVal to refer to the given field, which must be a member of the type
2370 /// currently described by LVal.
2371 static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal,
2372  const FieldDecl *FD,
2373  const ASTRecordLayout *RL = nullptr) {
2374  if (!RL) {
2375  if (FD->getParent()->isInvalidDecl()) return false;
2376  RL = &Info.Ctx.getASTRecordLayout(FD->getParent());
2377  }
2378 
2379  unsigned I = FD->getFieldIndex();
2380  LVal.adjustOffset(Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I)));
2381  LVal.addDecl(Info, E, FD);
2382  return true;
2383 }
2384 
2385 /// Update LVal to refer to the given indirect field.
2386 static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E,
2387  LValue &LVal,
2388  const IndirectFieldDecl *IFD) {
2389  for (const auto *C : IFD->chain())
2390  if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(C)))
2391  return false;
2392  return true;
2393 }
2394 
2395 /// Get the size of the given type in char units.
2396 static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc,
2397  QualType Type, CharUnits &Size) {
2398  // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc
2399  // extension.
2400  if (Type->isVoidType() || Type->isFunctionType()) {
2401  Size = CharUnits::One();
2402  return true;
2403  }
2404 
2405  if (Type->isDependentType()) {
2406  Info.FFDiag(Loc);
2407  return false;
2408  }
2409 
2410  if (!Type->isConstantSizeType()) {
2411  // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
2412  // FIXME: Better diagnostic.
2413  Info.FFDiag(Loc);
2414  return false;
2415  }
2416 
2417  Size = Info.Ctx.getTypeSizeInChars(Type);
2418  return true;
2419 }
2420 
2421 /// Update a pointer value to model pointer arithmetic.
2422 /// \param Info - Information about the ongoing evaluation.
2423 /// \param E - The expression being evaluated, for diagnostic purposes.
2424 /// \param LVal - The pointer value to be updated.
2425 /// \param EltTy - The pointee type represented by LVal.
2426 /// \param Adjustment - The adjustment, in objects of type EltTy, to add.
2427 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2428  LValue &LVal, QualType EltTy,
2429  APSInt Adjustment) {
2430  CharUnits SizeOfPointee;
2431  if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfPointee))
2432  return false;
2433 
2434  LVal.adjustOffsetAndIndex(Info, E, Adjustment, SizeOfPointee);
2435  return true;
2436 }
2437 
2438 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2439  LValue &LVal, QualType EltTy,
2440  int64_t Adjustment) {
2441  return HandleLValueArrayAdjustment(Info, E, LVal, EltTy,
2442  APSInt::get(Adjustment));
2443 }
2444 
2445 /// Update an lvalue to refer to a component of a complex number.
2446 /// \param Info - Information about the ongoing evaluation.
2447 /// \param LVal - The lvalue to be updated.
2448 /// \param EltTy - The complex number's component type.
2449 /// \param Imag - False for the real component, true for the imaginary.
2450 static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E,
2451  LValue &LVal, QualType EltTy,
2452  bool Imag) {
2453  if (Imag) {
2454  CharUnits SizeOfComponent;
2455  if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent))
2456  return false;
2457  LVal.Offset += SizeOfComponent;
2458  }
2459  LVal.addComplex(Info, E, EltTy, Imag);
2460  return true;
2461 }
2462 
2463 static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
2464  QualType Type, const LValue &LVal,
2465  APValue &RVal);
2466 
2467 /// Try to evaluate the initializer for a variable declaration.
2468 ///
2469 /// \param Info Information about the ongoing evaluation.
2470 /// \param E An expression to be used when printing diagnostics.
2471 /// \param VD The variable whose initializer should be obtained.
2472 /// \param Frame The frame in which the variable was created. Must be null
2473 /// if this variable is not local to the evaluation.
2474 /// \param Result Filled in with a pointer to the value of the variable.
2475 static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
2476  const VarDecl *VD, CallStackFrame *Frame,
2477  APValue *&Result, const LValue *LVal) {
2478 
2479  // If this is a parameter to an active constexpr function call, perform
2480  // argument substitution.
2481  if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) {
2482  // Assume arguments of a potential constant expression are unknown
2483  // constant expressions.
2484  if (Info.checkingPotentialConstantExpression())
2485  return false;
2486  if (!Frame || !Frame->Arguments) {
2487  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2488  return false;
2489  }
2490  Result = &Frame->Arguments[PVD->getFunctionScopeIndex()];
2491  return true;
2492  }
2493 
2494  // If this is a local variable, dig out its value.
2495  if (Frame) {
2496  Result = LVal ? Frame->getTemporary(VD, LVal->getLValueVersion())
2497  : Frame->getCurrentTemporary(VD);
2498  if (!Result) {
2499  // Assume variables referenced within a lambda's call operator that were
2500  // not declared within the call operator are captures and during checking
2501  // of a potential constant expression, assume they are unknown constant
2502  // expressions.
2503  assert(isLambdaCallOperator(Frame->Callee) &&
2504  (VD->getDeclContext() != Frame->Callee || VD->isInitCapture()) &&
2505  "missing value for local variable");
2506  if (Info.checkingPotentialConstantExpression())
2507  return false;
2508  // FIXME: implement capture evaluation during constant expr evaluation.
2509  Info.FFDiag(E->getLocStart(),
2510  diag::note_unimplemented_constexpr_lambda_feature_ast)
2511  << "captures not currently allowed";
2512  return false;
2513  }
2514  return true;
2515  }
2516 
2517  // Dig out the initializer, and use the declaration which it's attached to.
2518  const Expr *Init = VD->getAnyInitializer(VD);
2519  if (!Init || Init->isValueDependent()) {
2520  // If we're checking a potential constant expression, the variable could be
2521  // initialized later.
2522  if (!Info.checkingPotentialConstantExpression())
2523  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2524  return false;
2525  }
2526 
2527  // If we're currently evaluating the initializer of this declaration, use that
2528  // in-flight value.
2529  if (Info.EvaluatingDecl.dyn_cast<const ValueDecl*>() == VD) {
2530  Result = Info.EvaluatingDeclValue;
2531  return true;
2532  }
2533 
2534  // Never evaluate the initializer of a weak variable. We can't be sure that
2535  // this is the definition which will be used.
2536  if (VD->isWeak()) {
2537  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2538  return false;
2539  }
2540 
2541  // Check that we can fold the initializer. In C++, we will have already done
2542  // this in the cases where it matters for conformance.
2544  if (!VD->evaluateValue(Notes)) {
2545  Info.FFDiag(E, diag::note_constexpr_var_init_non_constant,
2546  Notes.size() + 1) << VD;
2547  Info.Note(VD->getLocation(), diag::note_declared_at);
2548  Info.addNotes(Notes);
2549  return false;
2550  } else if (!VD->checkInitIsICE()) {
2551  Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant,
2552  Notes.size() + 1) << VD;
2553  Info.Note(VD->getLocation(), diag::note_declared_at);
2554  Info.addNotes(Notes);
2555  }
2556 
2557  Result = VD->getEvaluatedValue();
2558  return true;
2559 }
2560 
2562  Qualifiers Quals = T.getQualifiers();
2563  return Quals.hasConst() && !Quals.hasVolatile();
2564 }
2565 
2566 /// Get the base index of the given base class within an APValue representing
2567 /// the given derived class.
2568 static unsigned getBaseIndex(const CXXRecordDecl *Derived,
2569  const CXXRecordDecl *Base) {
2570  Base = Base->getCanonicalDecl();
2571  unsigned Index = 0;
2573  E = Derived->bases_end(); I != E; ++I, ++Index) {
2574  if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == Base)
2575  return Index;
2576  }
2577 
2578  llvm_unreachable("base class missing from derived class's bases list");
2579 }
2580 
2581 /// Extract the value of a character from a string literal.
2582 static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
2583  uint64_t Index) {
2584  // FIXME: Support MakeStringConstant
2585  if (const auto *ObjCEnc = dyn_cast<ObjCEncodeExpr>(Lit)) {
2586  std::string Str;
2587  Info.Ctx.getObjCEncodingForType(ObjCEnc->getEncodedType(), Str);
2588  assert(Index <= Str.size() && "Index too large");
2589  return APSInt::getUnsigned(Str.c_str()[Index]);
2590  }
2591 
2592  if (auto PE = dyn_cast<PredefinedExpr>(Lit))
2593  Lit = PE->getFunctionName();
2594  const StringLiteral *S = cast<StringLiteral>(Lit);
2595  const ConstantArrayType *CAT =
2596  Info.Ctx.getAsConstantArrayType(S->getType());
2597  assert(CAT && "string literal isn't an array");
2598  QualType CharType = CAT->getElementType();
2599  assert(CharType->isIntegerType() && "unexpected character type");
2600 
2601  APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2602  CharType->isUnsignedIntegerType());
2603  if (Index < S->getLength())
2604  Value = S->getCodeUnit(Index);
2605  return Value;
2606 }
2607 
2608 // Expand a string literal into an array of characters.
2609 static void expandStringLiteral(EvalInfo &Info, const Expr *Lit,
2610  APValue &Result) {
2611  const StringLiteral *S = cast<StringLiteral>(Lit);
2612  const ConstantArrayType *CAT =
2613  Info.Ctx.getAsConstantArrayType(S->getType());
2614  assert(CAT && "string literal isn't an array");
2615  QualType CharType = CAT->getElementType();
2616  assert(CharType->isIntegerType() && "unexpected character type");
2617 
2618  unsigned Elts = CAT->getSize().getZExtValue();
2619  Result = APValue(APValue::UninitArray(),
2620  std::min(S->getLength(), Elts), Elts);
2621  APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2622  CharType->isUnsignedIntegerType());
2623  if (Result.hasArrayFiller())
2624  Result.getArrayFiller() = APValue(Value);
2625  for (unsigned I = 0, N = Result.getArrayInitializedElts(); I != N; ++I) {
2626  Value = S->getCodeUnit(I);
2627  Result.getArrayInitializedElt(I) = APValue(Value);
2628  }
2629 }
2630 
2631 // Expand an array so that it has more than Index filled elements.
2632 static void expandArray(APValue &Array, unsigned Index) {
2633  unsigned Size = Array.getArraySize();
2634  assert(Index < Size);
2635 
2636  // Always at least double the number of elements for which we store a value.
2637  unsigned OldElts = Array.getArrayInitializedElts();
2638  unsigned NewElts = std::max(Index+1, OldElts * 2);
2639  NewElts = std::min(Size, std::max(NewElts, 8u));
2640 
2641  // Copy the data across.
2642  APValue NewValue(APValue::UninitArray(), NewElts, Size);
2643  for (unsigned I = 0; I != OldElts; ++I)
2644  NewValue.getArrayInitializedElt(I).swap(Array.getArrayInitializedElt(I));
2645  for (unsigned I = OldElts; I != NewElts; ++I)
2646  NewValue.getArrayInitializedElt(I) = Array.getArrayFiller();
2647  if (NewValue.hasArrayFiller())
2648  NewValue.getArrayFiller() = Array.getArrayFiller();
2649  Array.swap(NewValue);
2650 }
2651 
2652 /// Determine whether a type would actually be read by an lvalue-to-rvalue
2653 /// conversion. If it's of class type, we may assume that the copy operation
2654 /// is trivial. Note that this is never true for a union type with fields
2655 /// (because the copy always "reads" the active member) and always true for
2656 /// a non-class type.
2659  if (!RD || (RD->isUnion() && !RD->field_empty()))
2660  return true;
2661  if (RD->isEmpty())
2662  return false;
2663 
2664  for (auto *Field : RD->fields())
2665  if (isReadByLvalueToRvalueConversion(Field->getType()))
2666  return true;
2667 
2668  for (auto &BaseSpec : RD->bases())
2669  if (isReadByLvalueToRvalueConversion(BaseSpec.getType()))
2670  return true;
2671 
2672  return false;
2673 }
2674 
2675 /// Diagnose an attempt to read from any unreadable field within the specified
2676 /// type, which might be a class type.
2677 static bool diagnoseUnreadableFields(EvalInfo &Info, const Expr *E,
2678  QualType T) {
2680  if (!RD)
2681  return false;
2682 
2683  if (!RD->hasMutableFields())
2684  return false;
2685 
2686  for (auto *Field : RD->fields()) {
2687  // If we're actually going to read this field in some way, then it can't
2688  // be mutable. If we're in a union, then assigning to a mutable field
2689  // (even an empty one) can change the active member, so that's not OK.
2690  // FIXME: Add core issue number for the union case.
2691  if (Field->isMutable() &&
2692  (RD->isUnion() || isReadByLvalueToRvalueConversion(Field->getType()))) {
2693  Info.FFDiag(E, diag::note_constexpr_ltor_mutable, 1) << Field;
2694  Info.Note(Field->getLocation(), diag::note_declared_at);
2695  return true;
2696  }
2697 
2698  if (diagnoseUnreadableFields(Info, E, Field->getType()))
2699  return true;
2700  }
2701 
2702  for (auto &BaseSpec : RD->bases())
2703  if (diagnoseUnreadableFields(Info, E, BaseSpec.getType()))
2704  return true;
2705 
2706  // All mutable fields were empty, and thus not actually read.
2707  return false;
2708 }
2709 
2710 /// Kinds of access we can perform on an object, for diagnostics.
2716 };
2717 
2718 namespace {
2719 /// A handle to a complete object (an object that is not a subobject of
2720 /// another object).
2721 struct CompleteObject {
2722  /// The value of the complete object.
2723  APValue *Value;
2724  /// The type of the complete object.
2725  QualType Type;
2726  bool LifetimeStartedInEvaluation;
2727 
2728  CompleteObject() : Value(nullptr) {}
2729  CompleteObject(APValue *Value, QualType Type,
2730  bool LifetimeStartedInEvaluation)
2731  : Value(Value), Type(Type),
2732  LifetimeStartedInEvaluation(LifetimeStartedInEvaluation) {
2733  assert(Value && "missing value for complete object");
2734  }
2735 
2736  explicit operator bool() const { return Value; }
2737 };
2738 } // end anonymous namespace
2739 
2740 /// Find the designated sub-object of an rvalue.
2741 template<typename SubobjectHandler>
2742 typename SubobjectHandler::result_type
2743 findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj,
2744  const SubobjectDesignator &Sub, SubobjectHandler &handler) {
2745  if (Sub.Invalid)
2746  // A diagnostic will have already been produced.
2747  return handler.failed();
2748  if (Sub.isOnePastTheEnd() || Sub.isMostDerivedAnUnsizedArray()) {
2749  if (Info.getLangOpts().CPlusPlus11)
2750  Info.FFDiag(E, Sub.isOnePastTheEnd()
2751  ? diag::note_constexpr_access_past_end
2752  : diag::note_constexpr_access_unsized_array)
2753  << handler.AccessKind;
2754  else
2755  Info.FFDiag(E);
2756  return handler.failed();
2757  }
2758 
2759  APValue *O = Obj.Value;
2760  QualType ObjType = Obj.Type;
2761  const FieldDecl *LastField = nullptr;
2762  const bool MayReadMutableMembers =
2763  Obj.LifetimeStartedInEvaluation && Info.getLangOpts().CPlusPlus14;
2764 
2765  // Walk the designator's path to find the subobject.
2766  for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {
2767  if (O->isUninit()) {
2768  if (!Info.checkingPotentialConstantExpression())
2769  Info.FFDiag(E, diag::note_constexpr_access_uninit) << handler.AccessKind;
2770  return handler.failed();
2771  }
2772 
2773  if (I == N) {
2774  // If we are reading an object of class type, there may still be more
2775  // things we need to check: if there are any mutable subobjects, we
2776  // cannot perform this read. (This only happens when performing a trivial
2777  // copy or assignment.)
2778  if (ObjType->isRecordType() && handler.AccessKind == AK_Read &&
2779  !MayReadMutableMembers && diagnoseUnreadableFields(Info, E, ObjType))
2780  return handler.failed();
2781 
2782  if (!handler.found(*O, ObjType))
2783  return false;
2784 
2785  // If we modified a bit-field, truncate it to the right width.
2786  if (handler.AccessKind != AK_Read &&
2787  LastField && LastField->isBitField() &&
2788  !truncateBitfieldValue(Info, E, *O, LastField))
2789  return false;
2790 
2791  return true;
2792  }
2793 
2794  LastField = nullptr;
2795  if (ObjType->isArrayType()) {
2796  // Next subobject is an array element.
2797  const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType);
2798  assert(CAT && "vla in literal type?");
2799  uint64_t Index = Sub.Entries[I].ArrayIndex;
2800  if (CAT->getSize().ule(Index)) {
2801  // Note, it should not be possible to form a pointer with a valid
2802  // designator which points more than one past the end of the array.
2803  if (Info.getLangOpts().CPlusPlus11)
2804  Info.FFDiag(E, diag::note_constexpr_access_past_end)
2805  << handler.AccessKind;
2806  else
2807  Info.FFDiag(E);
2808  return handler.failed();
2809  }
2810 
2811  ObjType = CAT->getElementType();
2812 
2813  // An array object is represented as either an Array APValue or as an
2814  // LValue which refers to a string literal.
2815  if (O->isLValue()) {
2816  assert(I == N - 1 && "extracting subobject of character?");
2817  assert(!O->hasLValuePath() || O->getLValuePath().empty());
2818  if (handler.AccessKind != AK_Read)
2819  expandStringLiteral(Info, O->getLValueBase().get<const Expr *>(),
2820  *O);
2821  else
2822  return handler.foundString(*O, ObjType, Index);
2823  }
2824 
2825  if (O->getArrayInitializedElts() > Index)
2826  O = &O->getArrayInitializedElt(Index);
2827  else if (handler.AccessKind != AK_Read) {
2828  expandArray(*O, Index);
2829  O = &O->getArrayInitializedElt(Index);
2830  } else
2831  O = &O->getArrayFiller();
2832  } else if (ObjType->isAnyComplexType()) {
2833  // Next subobject is a complex number.
2834  uint64_t Index = Sub.Entries[I].ArrayIndex;
2835  if (Index > 1) {
2836  if (Info.getLangOpts().CPlusPlus11)
2837  Info.FFDiag(E, diag::note_constexpr_access_past_end)
2838  << handler.AccessKind;
2839  else
2840  Info.FFDiag(E);
2841  return handler.failed();
2842  }
2843 
2844  bool WasConstQualified = ObjType.isConstQualified();
2845  ObjType = ObjType->castAs<ComplexType>()->getElementType();
2846  if (WasConstQualified)
2847  ObjType.addConst();
2848 
2849  assert(I == N - 1 && "extracting subobject of scalar?");
2850  if (O->isComplexInt()) {
2851  return handler.found(Index ? O->getComplexIntImag()
2852  : O->getComplexIntReal(), ObjType);
2853  } else {
2854  assert(O->isComplexFloat());
2855  return handler.found(Index ? O->getComplexFloatImag()
2856  : O->getComplexFloatReal(), ObjType);
2857  }
2858  } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
2859  // In C++14 onwards, it is permitted to read a mutable member whose
2860  // lifetime began within the evaluation.
2861  // FIXME: Should we also allow this in C++11?
2862  if (Field->isMutable() && handler.AccessKind == AK_Read &&
2863  !MayReadMutableMembers) {
2864  Info.FFDiag(E, diag::note_constexpr_ltor_mutable, 1)
2865  << Field;
2866  Info.Note(Field->getLocation(), diag::note_declared_at);
2867  return handler.failed();
2868  }
2869 
2870  // Next subobject is a class, struct or union field.
2871  RecordDecl *RD = ObjType->castAs<RecordType>()->getDecl();
2872  if (RD->isUnion()) {
2873  const FieldDecl *UnionField = O->getUnionField();
2874  if (!UnionField ||
2875  UnionField->getCanonicalDecl() != Field->getCanonicalDecl()) {
2876  Info.FFDiag(E, diag::note_constexpr_access_inactive_union_member)
2877  << handler.AccessKind << Field << !UnionField << UnionField;
2878  return handler.failed();
2879  }
2880  O = &O->getUnionValue();
2881  } else
2882  O = &O->getStructField(Field->getFieldIndex());
2883 
2884  bool WasConstQualified = ObjType.isConstQualified();
2885  ObjType = Field->getType();
2886  if (WasConstQualified && !Field->isMutable())
2887  ObjType.addConst();
2888 
2889  if (ObjType.isVolatileQualified()) {
2890  if (Info.getLangOpts().CPlusPlus) {
2891  // FIXME: Include a description of the path to the volatile subobject.
2892  Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
2893  << handler.AccessKind << 2 << Field;
2894  Info.Note(Field->getLocation(), diag::note_declared_at);
2895  } else {
2896  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2897  }
2898  return handler.failed();
2899  }
2900 
2901  LastField = Field;
2902  } else {
2903  // Next subobject is a base class.
2904  const CXXRecordDecl *Derived = ObjType->getAsCXXRecordDecl();
2905  const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]);
2906  O = &O->getStructBase(getBaseIndex(Derived, Base));
2907 
2908  bool WasConstQualified = ObjType.isConstQualified();
2909  ObjType = Info.Ctx.getRecordType(Base);
2910  if (WasConstQualified)
2911  ObjType.addConst();
2912  }
2913  }
2914 }
2915 
2916 namespace {
2917 struct ExtractSubobjectHandler {
2918  EvalInfo &Info;
2919  APValue &Result;
2920 
2921  static const AccessKinds AccessKind = AK_Read;
2922 
2923  typedef bool result_type;
2924  bool failed() { return false; }
2925  bool found(APValue &Subobj, QualType SubobjType) {
2926  Result = Subobj;
2927  return true;
2928  }
2929  bool found(APSInt &Value, QualType SubobjType) {
2930  Result = APValue(Value);
2931  return true;
2932  }
2933  bool found(APFloat &Value, QualType SubobjType) {
2934  Result = APValue(Value);
2935  return true;
2936  }
2937  bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
2939  Info, Subobj.getLValueBase().get<const Expr *>(), Character));
2940  return true;
2941  }
2942 };
2943 } // end anonymous namespace
2944 
2946 
2947 /// Extract the designated sub-object of an rvalue.
2948 static bool extractSubobject(EvalInfo &Info, const Expr *E,
2949  const CompleteObject &Obj,
2950  const SubobjectDesignator &Sub,
2951  APValue &Result) {
2952  ExtractSubobjectHandler Handler = { Info, Result };
2953  return findSubobject(Info, E, Obj, Sub, Handler);
2954 }
2955 
2956 namespace {
2957 struct ModifySubobjectHandler {
2958  EvalInfo &Info;
2959  APValue &NewVal;
2960  const Expr *E;
2961 
2962  typedef bool result_type;
2963  static const AccessKinds AccessKind = AK_Assign;
2964 
2965  bool checkConst(QualType QT) {
2966  // Assigning to a const object has undefined behavior.
2967  if (QT.isConstQualified()) {
2968  Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
2969  return false;
2970  }
2971  return true;
2972  }
2973 
2974  bool failed() { return false; }
2975  bool found(APValue &Subobj, QualType SubobjType) {
2976  if (!checkConst(SubobjType))
2977  return false;
2978  // We've been given ownership of NewVal, so just swap it in.
2979  Subobj.swap(NewVal);
2980  return true;
2981  }
2982  bool found(APSInt &Value, QualType SubobjType) {
2983  if (!checkConst(SubobjType))
2984  return false;
2985  if (!NewVal.isInt()) {
2986  // Maybe trying to write a cast pointer value into a complex?
2987  Info.FFDiag(E);
2988  return false;
2989  }
2990  Value = NewVal.getInt();
2991  return true;
2992  }
2993  bool found(APFloat &Value, QualType SubobjType) {
2994  if (!checkConst(SubobjType))
2995  return false;
2996  Value = NewVal.getFloat();
2997  return true;
2998  }
2999  bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
3000  llvm_unreachable("shouldn't encounter string elements with ExpandArrays");
3001  }
3002 };
3003 } // end anonymous namespace
3004 
3006 
3007 /// Update the designated sub-object of an rvalue to the given value.
3008 static bool modifySubobject(EvalInfo &Info, const Expr *E,
3009  const CompleteObject &Obj,
3010  const SubobjectDesignator &Sub,
3011  APValue &NewVal) {
3012  ModifySubobjectHandler Handler = { Info, NewVal, E };
3013  return findSubobject(Info, E, Obj, Sub, Handler);
3014 }
3015 
3016 /// Find the position where two subobject designators diverge, or equivalently
3017 /// the length of the common initial subsequence.
3018 static unsigned FindDesignatorMismatch(QualType ObjType,
3019  const SubobjectDesignator &A,
3020  const SubobjectDesignator &B,
3021  bool &WasArrayIndex) {
3022  unsigned I = 0, N = std::min(A.Entries.size(), B.Entries.size());
3023  for (/**/; I != N; ++I) {
3024  if (!ObjType.isNull() &&
3025  (ObjType->isArrayType() || ObjType->isAnyComplexType())) {
3026  // Next subobject is an array element.
3027  if (A.Entries[I].ArrayIndex != B.Entries[I].ArrayIndex) {
3028  WasArrayIndex = true;
3029  return I;
3030  }
3031  if (ObjType->isAnyComplexType())
3032  ObjType = ObjType->castAs<ComplexType>()->getElementType();
3033  else
3034  ObjType = ObjType->castAsArrayTypeUnsafe()->getElementType();
3035  } else {
3036  if (A.Entries[I].BaseOrMember != B.Entries[I].BaseOrMember) {
3037  WasArrayIndex = false;
3038  return I;
3039  }
3040  if (const FieldDecl *FD = getAsField(A.Entries[I]))
3041  // Next subobject is a field.
3042  ObjType = FD->getType();
3043  else
3044  // Next subobject is a base class.
3045  ObjType = QualType();
3046  }
3047  }
3048  WasArrayIndex = false;
3049  return I;
3050 }
3051 
3052 /// Determine whether the given subobject designators refer to elements of the
3053 /// same array object.
3054 static bool AreElementsOfSameArray(QualType ObjType,
3055  const SubobjectDesignator &A,
3056  const SubobjectDesignator &B) {
3057  if (A.Entries.size() != B.Entries.size())
3058  return false;
3059 
3060  bool IsArray = A.MostDerivedIsArrayElement;
3061  if (IsArray && A.MostDerivedPathLength != A.Entries.size())
3062  // A is a subobject of the array element.
3063  return false;
3064 
3065  // If A (and B) designates an array element, the last entry will be the array
3066  // index. That doesn't have to match. Otherwise, we're in the 'implicit array
3067  // of length 1' case, and the entire path must match.
3068  bool WasArrayIndex;
3069  unsigned CommonLength = FindDesignatorMismatch(ObjType, A, B, WasArrayIndex);
3070  return CommonLength >= A.Entries.size() - IsArray;
3071 }
3072 
3073 /// Find the complete object to which an LValue refers.
3074 static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
3075  AccessKinds AK, const LValue &LVal,
3076  QualType LValType) {
3077  if (!LVal.Base) {
3078  Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
3079  return CompleteObject();
3080  }
3081 
3082  CallStackFrame *Frame = nullptr;
3083  if (LVal.getLValueCallIndex()) {
3084  Frame = Info.getCallFrame(LVal.getLValueCallIndex());
3085  if (!Frame) {
3086  Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1)
3087  << AK << LVal.Base.is<const ValueDecl*>();
3088  NoteLValueLocation(Info, LVal.Base);
3089  return CompleteObject();
3090  }
3091  }
3092 
3093  // C++11 DR1311: An lvalue-to-rvalue conversion on a volatile-qualified type
3094  // is not a constant expression (even if the object is non-volatile). We also
3095  // apply this rule to C++98, in order to conform to the expected 'volatile'
3096  // semantics.
3097  if (LValType.isVolatileQualified()) {
3098  if (Info.getLangOpts().CPlusPlus)
3099  Info.FFDiag(E, diag::note_constexpr_access_volatile_type)
3100  << AK << LValType;
3101  else
3102  Info.FFDiag(E);
3103  return CompleteObject();
3104  }
3105 
3106  // Compute value storage location and type of base object.
3107  APValue *BaseVal = nullptr;
3108  QualType BaseType = getType(LVal.Base);
3109  bool LifetimeStartedInEvaluation = Frame;
3110 
3111  if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl*>()) {
3112  // In C++98, const, non-volatile integers initialized with ICEs are ICEs.
3113  // In C++11, constexpr, non-volatile variables initialized with constant
3114  // expressions are constant expressions too. Inside constexpr functions,
3115  // parameters are constant expressions even if they're non-const.
3116  // In C++1y, objects local to a constant expression (those with a Frame) are
3117  // both readable and writable inside constant expressions.
3118  // In C, such things can also be folded, although they are not ICEs.
3119  const VarDecl *VD = dyn_cast<VarDecl>(D);
3120  if (VD) {
3121  if (const VarDecl *VDef = VD->getDefinition(Info.Ctx))
3122  VD = VDef;
3123  }
3124  if (!VD || VD->isInvalidDecl()) {
3125  Info.FFDiag(E);
3126  return CompleteObject();
3127  }
3128 
3129  // Accesses of volatile-qualified objects are not allowed.
3130  if (BaseType.isVolatileQualified()) {
3131  if (Info.getLangOpts().CPlusPlus) {
3132  Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
3133  << AK << 1 << VD;
3134  Info.Note(VD->getLocation(), diag::note_declared_at);
3135  } else {
3136  Info.FFDiag(E);
3137  }
3138  return CompleteObject();
3139  }
3140 
3141  // Unless we're looking at a local variable or argument in a constexpr call,
3142  // the variable we're reading must be const.
3143  if (!Frame) {
3144  if (Info.getLangOpts().CPlusPlus14 &&
3145  VD == Info.EvaluatingDecl.dyn_cast<const ValueDecl *>()) {
3146  // OK, we can read and modify an object if we're in the process of
3147  // evaluating its initializer, because its lifetime began in this
3148  // evaluation.
3149  } else if (AK != AK_Read) {
3150  // All the remaining cases only permit reading.
3151  Info.FFDiag(E, diag::note_constexpr_modify_global);
3152  return CompleteObject();
3153  } else if (VD->isConstexpr()) {
3154  // OK, we can read this variable.
3155  } else if (BaseType->isIntegralOrEnumerationType()) {
3156  // In OpenCL if a variable is in constant address space it is a const value.
3157  if (!(BaseType.isConstQualified() ||
3158  (Info.getLangOpts().OpenCL &&
3159  BaseType.getAddressSpace() == LangAS::opencl_constant))) {
3160  if (Info.getLangOpts().CPlusPlus) {
3161  Info.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;
3162  Info.Note(VD->getLocation(), diag::note_declared_at);
3163  } else {
3164  Info.FFDiag(E);
3165  }
3166  return CompleteObject();
3167  }
3168  } else if (BaseType->isFloatingType() && BaseType.isConstQualified()) {
3169  // We support folding of const floating-point types, in order to make
3170  // static const data members of such types (supported as an extension)
3171  // more useful.
3172  if (Info.getLangOpts().CPlusPlus11) {
3173  Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
3174  Info.Note(VD->getLocation(), diag::note_declared_at);
3175  } else {
3176  Info.CCEDiag(E);
3177  }
3178  } else if (BaseType.isConstQualified() && VD->hasDefinition(Info.Ctx)) {
3179  Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr) << VD;
3180  // Keep evaluating to see what we can do.
3181  } else {
3182  // FIXME: Allow folding of values of any literal type in all languages.
3183  if (Info.checkingPotentialConstantExpression() &&
3184  VD->getType().isConstQualified() && !VD->hasDefinition(Info.Ctx)) {
3185  // The definition of this variable could be constexpr. We can't
3186  // access it right now, but may be able to in future.
3187  } else if (Info.getLangOpts().CPlusPlus11) {
3188  Info.FFDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
3189  Info.Note(VD->getLocation(), diag::note_declared_at);
3190  } else {
3191  Info.FFDiag(E);
3192  }
3193  return CompleteObject();
3194  }
3195  }
3196 
3197  if (!evaluateVarDeclInit(Info, E, VD, Frame, BaseVal, &LVal))
3198  return CompleteObject();
3199  } else {
3200  const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3201 
3202  if (!Frame) {
3203  if (const MaterializeTemporaryExpr *MTE =
3204  dyn_cast<MaterializeTemporaryExpr>(Base)) {
3205  assert(MTE->getStorageDuration() == SD_Static &&
3206  "should have a frame for a non-global materialized temporary");
3207 
3208  // Per C++1y [expr.const]p2:
3209  // an lvalue-to-rvalue conversion [is not allowed unless it applies to]
3210  // - a [...] glvalue of integral or enumeration type that refers to
3211  // a non-volatile const object [...]
3212  // [...]
3213  // - a [...] glvalue of literal type that refers to a non-volatile
3214  // object whose lifetime began within the evaluation of e.
3215  //
3216  // C++11 misses the 'began within the evaluation of e' check and
3217  // instead allows all temporaries, including things like:
3218  // int &&r = 1;
3219  // int x = ++r;
3220  // constexpr int k = r;
3221  // Therefore we use the C++14 rules in C++11 too.
3222  const ValueDecl *VD = Info.EvaluatingDecl.dyn_cast<const ValueDecl*>();
3223  const ValueDecl *ED = MTE->getExtendingDecl();
3224  if (!(BaseType.isConstQualified() &&
3225  BaseType->isIntegralOrEnumerationType()) &&
3226  !(VD && VD->getCanonicalDecl() == ED->getCanonicalDecl())) {
3227  Info.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
3228  Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here);
3229  return CompleteObject();
3230  }
3231 
3232  BaseVal = Info.Ctx.getMaterializedTemporaryValue(MTE, false);
3233  assert(BaseVal && "got reference to unevaluated temporary");
3234  LifetimeStartedInEvaluation = true;
3235  } else {
3236  Info.FFDiag(E);
3237  return CompleteObject();
3238  }
3239  } else {
3240  BaseVal = Frame->getTemporary(Base, LVal.Base.getVersion());
3241  assert(BaseVal && "missing value for temporary");
3242  }
3243 
3244  // Volatile temporary objects cannot be accessed in constant expressions.
3245  if (BaseType.isVolatileQualified()) {
3246  if (Info.getLangOpts().CPlusPlus) {
3247  Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
3248  << AK << 0;
3249  Info.Note(Base->getExprLoc(), diag::note_constexpr_temporary_here);
3250  } else {
3251  Info.FFDiag(E);
3252  }
3253  return CompleteObject();
3254  }
3255  }
3256 
3257  // During the construction of an object, it is not yet 'const'.
3258  // FIXME: This doesn't do quite the right thing for const subobjects of the
3259  // object under construction.
3260  if (Info.isEvaluatingConstructor(LVal.getLValueBase(),
3261  LVal.getLValueCallIndex(),
3262  LVal.getLValueVersion())) {
3263  BaseType = Info.Ctx.getCanonicalType(BaseType);
3264  BaseType.removeLocalConst();
3265  LifetimeStartedInEvaluation = true;
3266  }
3267 
3268  // In C++14, we can't safely access any mutable state when we might be
3269  // evaluating after an unmodeled side effect.
3270  //
3271  // FIXME: Not all local state is mutable. Allow local constant subobjects
3272  // to be read here (but take care with 'mutable' fields).
3273  if ((Frame && Info.getLangOpts().CPlusPlus14 &&
3274  Info.EvalStatus.HasSideEffects) ||
3275  (AK != AK_Read && Info.IsSpeculativelyEvaluating))
3276  return CompleteObject();
3277 
3278  return CompleteObject(BaseVal, BaseType, LifetimeStartedInEvaluation);
3279 }
3280 
3281 /// Perform an lvalue-to-rvalue conversion on the given glvalue. This
3282 /// can also be used for 'lvalue-to-lvalue' conversions for looking up the
3283 /// glvalue referred to by an entity of reference type.
3284 ///
3285 /// \param Info - Information about the ongoing evaluation.
3286 /// \param Conv - The expression for which we are performing the conversion.
3287 /// Used for diagnostics.
3288 /// \param Type - The type of the glvalue (before stripping cv-qualifiers in the
3289 /// case of a non-class type).
3290 /// \param LVal - The glvalue on which we are attempting to perform this action.
3291 /// \param RVal - The produced value will be placed here.
3292 static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
3293  QualType Type,
3294  const LValue &LVal, APValue &RVal) {
3295  if (LVal.Designator.Invalid)
3296  return false;
3297 
3298  // Check for special cases where there is no existing APValue to look at.
3299  const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3300  if (Base && !LVal.getLValueCallIndex() && !Type.isVolatileQualified()) {
3301  if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
3302  // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the
3303  // initializer until now for such expressions. Such an expression can't be
3304  // an ICE in C, so this only matters for fold.
3305  if (Type.isVolatileQualified()) {
3306  Info.FFDiag(Conv);
3307  return false;
3308  }
3309  APValue Lit;
3310  if (!Evaluate(Lit, Info, CLE->getInitializer()))
3311  return false;
3312  CompleteObject LitObj(&Lit, Base->getType(), false);
3313  return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal);
3314  } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) {
3315  // We represent a string literal array as an lvalue pointing at the
3316  // corresponding expression, rather than building an array of chars.
3317  // FIXME: Support ObjCEncodeExpr, MakeStringConstant
3318  APValue Str(Base, CharUnits::Zero(), APValue::NoLValuePath(), 0);
3319  CompleteObject StrObj(&Str, Base->getType(), false);
3320  return extractSubobject(Info, Conv, StrObj, LVal.Designator, RVal);
3321  }
3322  }
3323 
3324  CompleteObject Obj = findCompleteObject(Info, Conv, AK_Read, LVal, Type);
3325  return Obj && extractSubobject(Info, Conv, Obj, LVal.Designator, RVal);
3326 }
3327 
3328 /// Perform an assignment of Val to LVal. Takes ownership of Val.
3329 static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal,
3330  QualType LValType, APValue &Val) {
3331  if (LVal.Designator.Invalid)
3332  return false;
3333 
3334  if (!Info.getLangOpts().CPlusPlus14) {
3335  Info.FFDiag(E);
3336  return false;
3337  }
3338 
3339  CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
3340  return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val);
3341 }
3342 
3343 namespace {
3344 struct CompoundAssignSubobjectHandler {
3345  EvalInfo &Info;
3346  const Expr *E;
3347  QualType PromotedLHSType;
3348  BinaryOperatorKind Opcode;
3349  const APValue &RHS;
3350 
3351  static const AccessKinds AccessKind = AK_Assign;
3352 
3353  typedef bool result_type;
3354 
3355  bool checkConst(QualType QT) {
3356  // Assigning to a const object has undefined behavior.
3357  if (QT.isConstQualified()) {
3358  Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3359  return false;
3360  }
3361  return true;
3362  }
3363 
3364  bool failed() { return false; }
3365  bool found(APValue &Subobj, QualType SubobjType) {
3366  switch (Subobj.getKind()) {
3367  case APValue::Int:
3368  return found(Subobj.getInt(), SubobjType);
3369  case APValue::Float:
3370  return found(Subobj.getFloat(), SubobjType);
3371  case APValue::ComplexInt:
3372  case APValue::ComplexFloat:
3373  // FIXME: Implement complex compound assignment.
3374  Info.FFDiag(E);
3375  return false;
3376  case APValue::LValue:
3377  return foundPointer(Subobj, SubobjType);
3378  default:
3379  // FIXME: can this happen?
3380  Info.FFDiag(E);
3381  return false;
3382  }
3383  }
3384  bool found(APSInt &Value, QualType SubobjType) {
3385  if (!checkConst(SubobjType))
3386  return false;
3387 
3388  if (!SubobjType->isIntegerType() || !RHS.isInt()) {
3389  // We don't support compound assignment on integer-cast-to-pointer
3390  // values.
3391  Info.FFDiag(E);
3392  return false;
3393  }
3394 
3395  APSInt LHS = HandleIntToIntCast(Info, E, PromotedLHSType,
3396  SubobjType, Value);
3397  if (!handleIntIntBinOp(Info, E, LHS, Opcode, RHS.getInt(), LHS))
3398  return false;
3399  Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS);
3400  return true;
3401  }
3402  bool found(APFloat &Value, QualType SubobjType) {
3403  return checkConst(SubobjType) &&
3404  HandleFloatToFloatCast(Info, E, SubobjType, PromotedLHSType,
3405  Value) &&
3406  handleFloatFloatBinOp(Info, E, Value, Opcode, RHS.getFloat()) &&
3407  HandleFloatToFloatCast(Info, E, PromotedLHSType, SubobjType, Value);
3408  }
3409  bool foundPointer(APValue &Subobj, QualType SubobjType) {
3410  if (!checkConst(SubobjType))
3411  return false;
3412 
3413  QualType PointeeType;
3414  if (const PointerType *PT = SubobjType->getAs<PointerType>())
3415  PointeeType = PT->getPointeeType();
3416 
3417  if (PointeeType.isNull() || !RHS.isInt() ||
3418  (Opcode != BO_Add && Opcode != BO_Sub)) {
3419  Info.FFDiag(E);
3420  return false;
3421  }
3422 
3423  APSInt Offset = RHS.getInt();
3424  if (Opcode == BO_Sub)
3425  negateAsSigned(Offset);
3426 
3427  LValue LVal;
3428  LVal.setFrom(Info.Ctx, Subobj);
3429  if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, Offset))
3430  return false;
3431  LVal.moveInto(Subobj);
3432  return true;
3433  }
3434  bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
3435  llvm_unreachable("shouldn't encounter string elements here");
3436  }
3437 };
3438 } // end anonymous namespace
3439 
3441 
3442 /// Perform a compound assignment of LVal <op>= RVal.
3444  EvalInfo &Info, const Expr *E,
3445  const LValue &LVal, QualType LValType, QualType PromotedLValType,
3446  BinaryOperatorKind Opcode, const APValue &RVal) {
3447  if (LVal.Designator.Invalid)
3448  return false;
3449 
3450  if (!Info.getLangOpts().CPlusPlus14) {
3451  Info.FFDiag(E);
3452  return false;
3453  }
3454 
3455  CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
3456  CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode,
3457  RVal };
3458  return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
3459 }
3460 
3461 namespace {
3462 struct IncDecSubobjectHandler {
3463  EvalInfo &Info;
3464  const UnaryOperator *E;
3466  APValue *Old;
3467 
3468  typedef bool result_type;
3469 
3470  bool checkConst(QualType QT) {
3471  // Assigning to a const object has undefined behavior.
3472  if (QT.isConstQualified()) {
3473  Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3474  return false;
3475  }
3476  return true;
3477  }
3478 
3479  bool failed() { return false; }
3480  bool found(APValue &Subobj, QualType SubobjType) {
3481  // Stash the old value. Also clear Old, so we don't clobber it later
3482  // if we're post-incrementing a complex.
3483  if (Old) {
3484  *Old = Subobj;
3485  Old = nullptr;
3486  }
3487 
3488  switch (Subobj.getKind()) {
3489  case APValue::Int:
3490  return found(Subobj.getInt(), SubobjType);
3491  case APValue::Float:
3492  return found(Subobj.getFloat(), SubobjType);
3493  case APValue::ComplexInt:
3494  return found(Subobj.getComplexIntReal(),
3495  SubobjType->castAs<ComplexType>()->getElementType()
3496  .withCVRQualifiers(SubobjType.getCVRQualifiers()));
3497  case APValue::ComplexFloat:
3498  return found(Subobj.getComplexFloatReal(),
3499  SubobjType->castAs<ComplexType>()->getElementType()
3500  .withCVRQualifiers(SubobjType.getCVRQualifiers()));
3501  case APValue::LValue:
3502  return foundPointer(Subobj, SubobjType);
3503  default:
3504  // FIXME: can this happen?
3505  Info.FFDiag(E);
3506  return false;
3507  }
3508  }
3509  bool found(APSInt &Value, QualType SubobjType) {
3510  if (!checkConst(SubobjType))
3511  return false;
3512 
3513  if (!SubobjType->isIntegerType()) {
3514  // We don't support increment / decrement on integer-cast-to-pointer
3515  // values.
3516  Info.FFDiag(E);
3517  return false;
3518  }
3519 
3520  if (Old) *Old = APValue(Value);
3521 
3522  // bool arithmetic promotes to int, and the conversion back to bool
3523  // doesn't reduce mod 2^n, so special-case it.
3524  if (SubobjType->isBooleanType()) {
3525  if (AccessKind == AK_Increment)
3526  Value = 1;
3527  else
3528  Value = !Value;
3529  return true;
3530  }
3531 
3532  bool WasNegative = Value.isNegative();
3533  if (AccessKind == AK_Increment) {
3534  ++Value;
3535 
3536  if (!WasNegative && Value.isNegative() && E->canOverflow()) {
3537  APSInt ActualValue(Value, /*IsUnsigned*/true);
3538  return HandleOverflow(Info, E, ActualValue, SubobjType);
3539  }
3540  } else {
3541  --Value;
3542 
3543  if (WasNegative && !Value.isNegative() && E->canOverflow()) {
3544  unsigned BitWidth = Value.getBitWidth();
3545  APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false);
3546  ActualValue.setBit(BitWidth);
3547  return HandleOverflow(Info, E, ActualValue, SubobjType);
3548  }
3549  }
3550  return true;
3551  }
3552  bool found(APFloat &Value, QualType SubobjType) {
3553  if (!checkConst(SubobjType))
3554  return false;
3555 
3556  if (Old) *Old = APValue(Value);
3557 
3558  APFloat One(Value.getSemantics(), 1);
3559  if (AccessKind == AK_Increment)
3560  Value.add(One, APFloat::rmNearestTiesToEven);
3561  else
3562  Value.subtract(One, APFloat::rmNearestTiesToEven);
3563  return true;
3564  }
3565  bool foundPointer(APValue &Subobj, QualType SubobjType) {
3566  if (!checkConst(SubobjType))
3567  return false;
3568 
3569  QualType PointeeType;
3570  if (const PointerType *PT = SubobjType->getAs<PointerType>())
3571  PointeeType = PT->getPointeeType();
3572  else {
3573  Info.FFDiag(E);
3574  return false;
3575  }
3576 
3577  LValue LVal;
3578  LVal.setFrom(Info.Ctx, Subobj);
3579  if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType,
3580  AccessKind == AK_Increment ? 1 : -1))
3581  return false;
3582  LVal.moveInto(Subobj);
3583  return true;
3584  }
3585  bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
3586  llvm_unreachable("shouldn't encounter string elements here");
3587  }
3588 };
3589 } // end anonymous namespace
3590 
3591 /// Perform an increment or decrement on LVal.
3592 static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal,
3593  QualType LValType, bool IsIncrement, APValue *Old) {
3594  if (LVal.Designator.Invalid)
3595  return false;
3596 
3597  if (!Info.getLangOpts().CPlusPlus14) {
3598  Info.FFDiag(E);
3599  return false;
3600  }
3601 
3602  AccessKinds AK = IsIncrement ? AK_Increment : AK_Decrement;
3603  CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType);
3604  IncDecSubobjectHandler Handler = {Info, cast<UnaryOperator>(E), AK, Old};
3605  return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
3606 }
3607 
3608 /// Build an lvalue for the object argument of a member function call.
3609 static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
3610  LValue &This) {
3611  if (Object->getType()->isPointerType())
3612  return EvaluatePointer(Object, This, Info);
3613 
3614  if (Object->isGLValue())
3615  return EvaluateLValue(Object, This, Info);
3616 
3617  if (Object->getType()->isLiteralType(Info.Ctx))
3618  return EvaluateTemporary(Object, This, Info);
3619 
3620  Info.FFDiag(Object, diag::note_constexpr_nonliteral) << Object->getType();
3621  return false;
3622 }
3623 
3624 /// HandleMemberPointerAccess - Evaluate a member access operation and build an
3625 /// lvalue referring to the result.
3626 ///
3627 /// \param Info - Information about the ongoing evaluation.
3628 /// \param LV - An lvalue referring to the base of the member pointer.
3629 /// \param RHS - The member pointer expression.
3630 /// \param IncludeMember - Specifies whether the member itself is included in
3631 /// the resulting LValue subobject designator. This is not possible when
3632 /// creating a bound member function.
3633 /// \return The field or method declaration to which the member pointer refers,
3634 /// or 0 if evaluation fails.
3635 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
3636  QualType LVType,
3637  LValue &LV,
3638  const Expr *RHS,
3639  bool IncludeMember = true) {
3640  MemberPtr MemPtr;
3641  if (!EvaluateMemberPointer(RHS, MemPtr, Info))
3642  return nullptr;
3643 
3644  // C++11 [expr.mptr.oper]p6: If the second operand is the null pointer to
3645  // member value, the behavior is undefined.
3646  if (!MemPtr.getDecl()) {
3647  // FIXME: Specific diagnostic.
3648  Info.FFDiag(RHS);
3649  return nullptr;
3650  }
3651 
3652  if (MemPtr.isDerivedMember()) {
3653  // This is a member of some derived class. Truncate LV appropriately.
3654  // The end of the derived-to-base path for the base object must match the
3655  // derived-to-base path for the member pointer.
3656  if (LV.Designator.MostDerivedPathLength + MemPtr.Path.size() >
3657  LV.Designator.Entries.size()) {
3658  Info.FFDiag(RHS);
3659  return nullptr;
3660  }
3661  unsigned PathLengthToMember =
3662  LV.Designator.Entries.size() - MemPtr.Path.size();
3663  for (unsigned I = 0, N = MemPtr.Path.size(); I != N; ++I) {
3664  const CXXRecordDecl *LVDecl = getAsBaseClass(
3665  LV.Designator.Entries[PathLengthToMember + I]);
3666  const CXXRecordDecl *MPDecl = MemPtr.Path[I];
3667  if (LVDecl->getCanonicalDecl() != MPDecl->getCanonicalDecl()) {
3668  Info.FFDiag(RHS);
3669  return nullptr;
3670  }
3671  }
3672 
3673  // Truncate the lvalue to the appropriate derived class.
3674  if (!CastToDerivedClass(Info, RHS, LV, MemPtr.getContainingRecord(),
3675  PathLengthToMember))
3676  return nullptr;
3677  } else if (!MemPtr.Path.empty()) {
3678  // Extend the LValue path with the member pointer's path.
3679  LV.Designator.Entries.reserve(LV.Designator.Entries.size() +
3680  MemPtr.Path.size() + IncludeMember);
3681 
3682  // Walk down to the appropriate base class.
3683  if (const PointerType *PT = LVType->getAs<PointerType>())
3684  LVType = PT->getPointeeType();
3685  const CXXRecordDecl *RD = LVType->getAsCXXRecordDecl();
3686  assert(RD && "member pointer access on non-class-type expression");
3687  // The first class in the path is that of the lvalue.
3688  for (unsigned I = 1, N = MemPtr.Path.size(); I != N; ++I) {
3689  const CXXRecordDecl *Base = MemPtr.Path[N - I - 1];
3690  if (!HandleLValueDirectBase(Info, RHS, LV, RD, Base))
3691  return nullptr;
3692  RD = Base;
3693  }
3694  // Finally cast to the class containing the member.
3695  if (!HandleLValueDirectBase(Info, RHS, LV, RD,
3696  MemPtr.getContainingRecord()))
3697  return nullptr;
3698  }
3699 
3700  // Add the member. Note that we cannot build bound member functions here.
3701  if (IncludeMember) {
3702  if (const FieldDecl *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) {
3703  if (!HandleLValueMember(Info, RHS, LV, FD))
3704  return nullptr;
3705  } else if (const IndirectFieldDecl *IFD =
3706  dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) {
3707  if (!HandleLValueIndirectMember(Info, RHS, LV, IFD))
3708  return nullptr;
3709  } else {
3710  llvm_unreachable("can't construct reference to bound member function");
3711  }
3712  }
3713 
3714  return MemPtr.getDecl();
3715 }
3716 
3717 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
3718  const BinaryOperator *BO,
3719  LValue &LV,
3720  bool IncludeMember = true) {
3721  assert(BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI);
3722 
3723  if (!EvaluateObjectArgument(Info, BO->getLHS(), LV)) {
3724  if (Info.noteFailure()) {
3725  MemberPtr MemPtr;
3726  EvaluateMemberPointer(BO->getRHS(), MemPtr, Info);
3727  }
3728  return nullptr;
3729  }
3730 
3731  return HandleMemberPointerAccess(Info, BO->getLHS()->getType(), LV,
3732  BO->getRHS(), IncludeMember);
3733 }
3734 
3735 /// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on
3736 /// the provided lvalue, which currently refers to the base object.
3737 static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E,
3738  LValue &Result) {
3739  SubobjectDesignator &D = Result.Designator;
3740  if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
3741  return false;
3742 
3743  QualType TargetQT = E->getType();
3744  if (const PointerType *PT = TargetQT->getAs<PointerType>())
3745  TargetQT = PT->getPointeeType();
3746 
3747  // Check this cast lands within the final derived-to-base subobject path.
3748  if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) {
3749  Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3750  << D.MostDerivedType << TargetQT;
3751  return false;
3752  }
3753 
3754  // Check the type of the final cast. We don't need to check the path,
3755  // since a cast can only be formed if the path is unique.
3756  unsigned NewEntriesSize = D.Entries.size() - E->path_size();
3757  const CXXRecordDecl *TargetType = TargetQT->getAsCXXRecordDecl();
3758  const CXXRecordDecl *FinalType;
3759  if (NewEntriesSize == D.MostDerivedPathLength)
3760  FinalType = D.MostDerivedType->getAsCXXRecordDecl();
3761  else
3762  FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
3763  if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) {
3764  Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3765  << D.MostDerivedType << TargetQT;
3766  return false;
3767  }
3768 
3769  // Truncate the lvalue to the appropriate derived class.
3770  return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize);
3771 }
3772 
3773 namespace {
3775  /// Evaluation failed.
3776  ESR_Failed,
3777  /// Hit a 'return' statement.
3778  ESR_Returned,
3779  /// Evaluation succeeded.
3780  ESR_Succeeded,
3781  /// Hit a 'continue' statement.
3782  ESR_Continue,
3783  /// Hit a 'break' statement.
3784  ESR_Break,
3785  /// Still scanning for 'case' or 'default' statement.
3786  ESR_CaseNotFound
3787 };
3788 }
3789 
3790 static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD) {
3791  // We don't need to evaluate the initializer for a static local.
3792  if (!VD->hasLocalStorage())
3793  return true;
3794 
3795  LValue Result;
3796  APValue &Val = createTemporary(VD, true, Result, *Info.CurrentCall);
3797 
3798  const Expr *InitE = VD->getInit();
3799  if (!InitE) {
3800  Info.FFDiag(VD->getLocStart(), diag::note_constexpr_uninitialized)
3801  << false << VD->getType();
3802  Val = APValue();
3803  return false;
3804  }
3805 
3806  if (InitE->isValueDependent())
3807  return false;
3808 
3809  if (!EvaluateInPlace(Val, Info, Result, InitE)) {
3810  // Wipe out any partially-computed value, to allow tracking that this
3811  // evaluation failed.
3812  Val = APValue();
3813  return false;
3814  }
3815 
3816  return true;
3817 }
3818 
3819 static bool EvaluateDecl(EvalInfo &Info, const Decl *D) {
3820  bool OK = true;
3821 
3822  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
3823  OK &= EvaluateVarDecl(Info, VD);
3824 
3825  if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(D))
3826  for (auto *BD : DD->bindings())
3827  if (auto *VD = BD->getHoldingVar())
3828  OK &= EvaluateDecl(Info, VD);
3829 
3830  return OK;
3831 }
3832 
3833 
3834 /// Evaluate a condition (either a variable declaration or an expression).
3835 static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
3836  const Expr *Cond, bool &Result) {
3837  FullExpressionRAII Scope(Info);
3838  if (CondDecl && !EvaluateDecl(Info, CondDecl))
3839  return false;
3840  return EvaluateAsBooleanCondition(Cond, Result, Info);
3841 }
3842 
3843 namespace {
3844 /// A location where the result (returned value) of evaluating a
3845 /// statement should be stored.
3846 struct StmtResult {
3847  /// The APValue that should be filled in with the returned value.
3848  APValue &Value;
3849  /// The location containing the result, if any (used to support RVO).
3850  const LValue *Slot;
3851 };
3852 
3853 struct TempVersionRAII {
3854  CallStackFrame &Frame;
3855 
3856  TempVersionRAII(CallStackFrame &Frame) : Frame(Frame) {
3857  Frame.pushTempVersion();
3858  }
3859 
3860  ~TempVersionRAII() {
3861  Frame.popTempVersion();
3862  }
3863 };
3864 
3865 }
3866 
3867 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
3868  const Stmt *S,
3869  const SwitchCase *SC = nullptr);
3870 
3871 /// Evaluate the body of a loop, and translate the result as appropriate.
3872 static EvalStmtResult EvaluateLoopBody(StmtResult &Result, EvalInfo &Info,
3873  const Stmt *Body,
3874  const SwitchCase *Case = nullptr) {
3875  BlockScopeRAII Scope(Info);
3876  switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, Body, Case)) {
3877  case ESR_Break:
3878  return ESR_Succeeded;
3879  case ESR_Succeeded:
3880  case ESR_Continue:
3881  return ESR_Continue;
3882  case ESR_Failed:
3883  case ESR_Returned:
3884  case ESR_CaseNotFound:
3885  return ESR;
3886  }
3887  llvm_unreachable("Invalid EvalStmtResult!");
3888 }
3889 
3890 /// Evaluate a switch statement.
3891 static EvalStmtResult EvaluateSwitch(StmtResult &Result, EvalInfo &Info,
3892  const SwitchStmt *SS) {
3893  BlockScopeRAII Scope(Info);
3894 
3895  // Evaluate the switch condition.
3896  APSInt Value;
3897  {
3898  FullExpressionRAII Scope(Info);
3899  if (const Stmt *Init = SS->getInit()) {
3900  EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
3901  if (ESR != ESR_Succeeded)
3902  return ESR;
3903  }
3904  if (SS->getConditionVariable() &&
3905  !EvaluateDecl(Info, SS->getConditionVariable()))
3906  return ESR_Failed;
3907  if (!EvaluateInteger(SS->getCond(), Value, Info))
3908  return ESR_Failed;
3909  }
3910 
3911  // Find the switch case corresponding to the value of the condition.
3912  // FIXME: Cache this lookup.
3913  const SwitchCase *Found = nullptr;
3914  for (const SwitchCase *SC = SS->getSwitchCaseList(); SC;
3915  SC = SC->getNextSwitchCase()) {
3916  if (isa<DefaultStmt>(SC)) {
3917  Found = SC;
3918  continue;
3919  }
3920 
3921  const CaseStmt *CS = cast<CaseStmt>(SC);
3922  APSInt LHS = CS->getLHS()->EvaluateKnownConstInt(Info.Ctx);
3923  APSInt RHS = CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx)
3924  : LHS;
3925  if (LHS <= Value && Value <= RHS) {
3926  Found = SC;
3927  break;
3928  }
3929  }
3930 
3931  if (!Found)
3932  return ESR_Succeeded;
3933 
3934  // Search the switch body for the switch case and evaluate it from there.
3935  switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, SS->getBody(), Found)) {
3936  case ESR_Break:
3937  return ESR_Succeeded;
3938  case ESR_Succeeded:
3939  case ESR_Continue:
3940  case ESR_Failed:
3941  case ESR_Returned:
3942  return ESR;
3943  case ESR_CaseNotFound:
3944  // This can only happen if the switch case is nested within a statement
3945  // expression. We have no intention of supporting that.
3946  Info.FFDiag(Found->getLocStart(), diag::note_constexpr_stmt_expr_unsupported);
3947  return ESR_Failed;
3948  }
3949  llvm_unreachable("Invalid EvalStmtResult!");
3950 }
3951 
3952 // Evaluate a statement.
3953 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
3954  const Stmt *S, const SwitchCase *Case) {
3955  if (!Info.nextStep(S))
3956  return ESR_Failed;
3957 
3958  // If we're hunting down a 'case' or 'default' label, recurse through
3959  // substatements until we hit the label.
3960  if (Case) {
3961  // FIXME: We don't start the lifetime of objects whose initialization we
3962  // jump over. However, such objects must be of class type with a trivial
3963  // default constructor that initialize all subobjects, so must be empty,
3964  // so this almost never matters.
3965  switch (S->getStmtClass()) {
3966  case Stmt::CompoundStmtClass:
3967  // FIXME: Precompute which substatement of a compound statement we
3968  // would jump to, and go straight there rather than performing a
3969  // linear scan each time.
3970  case Stmt::LabelStmtClass:
3971  case Stmt::AttributedStmtClass:
3972  case Stmt::DoStmtClass:
3973  break;
3974 
3975  case Stmt::CaseStmtClass:
3976  case Stmt::DefaultStmtClass:
3977  if (Case == S)
3978  Case = nullptr;
3979  break;
3980 
3981  case Stmt::IfStmtClass: {
3982  // FIXME: Precompute which side of an 'if' we would jump to, and go
3983  // straight there rather than scanning both sides.
3984  const IfStmt *IS = cast<IfStmt>(S);
3985 
3986  // Wrap the evaluation in a block scope, in case it's a DeclStmt
3987  // preceded by our switch label.
3988  BlockScopeRAII Scope(Info);
3989 
3990  EvalStmtResult ESR = EvaluateStmt(Result, Info, IS->getThen(), Case);
3991  if (ESR != ESR_CaseNotFound || !IS->getElse())
3992  return ESR;
3993  return EvaluateStmt(Result, Info, IS->getElse(), Case);
3994  }
3995 
3996  case Stmt::WhileStmtClass: {
3997  EvalStmtResult ESR =
3998  EvaluateLoopBody(Result, Info, cast<WhileStmt>(S)->getBody(), Case);
3999  if (ESR != ESR_Continue)
4000  return ESR;
4001  break;
4002  }
4003 
4004  case Stmt::ForStmtClass: {
4005  const ForStmt *FS = cast<ForStmt>(S);
4006  EvalStmtResult ESR =
4007  EvaluateLoopBody(Result, Info, FS->getBody(), Case);
4008  if (ESR != ESR_Continue)
4009  return ESR;
4010  if (FS->getInc()) {
4011  FullExpressionRAII IncScope(Info);
4012  if (!EvaluateIgnoredValue(Info, FS->getInc()))
4013  return ESR_Failed;
4014  }
4015  break;
4016  }
4017 
4018  case Stmt::DeclStmtClass:
4019  // FIXME: If the variable has initialization that can't be jumped over,
4020  // bail out of any immediately-surrounding compound-statement too.
4021  default:
4022  return ESR_CaseNotFound;
4023  }
4024  }
4025 
4026  switch (S->getStmtClass()) {
4027  default:
4028  if (const Expr *E = dyn_cast<Expr>(S)) {
4029  // Don't bother evaluating beyond an expression-statement which couldn't
4030  // be evaluated.
4031  FullExpressionRAII Scope(Info);
4032  if (!EvaluateIgnoredValue(Info, E))
4033  return ESR_Failed;
4034  return ESR_Succeeded;
4035  }
4036 
4037  Info.FFDiag(S->getLocStart());
4038  return ESR_Failed;
4039 
4040  case Stmt::NullStmtClass:
4041  return ESR_Succeeded;
4042 
4043  case Stmt::DeclStmtClass: {
4044  const DeclStmt *DS = cast<DeclStmt>(S);
4045  for (const auto *DclIt : DS->decls()) {
4046  // Each declaration initialization is its own full-expression.
4047  // FIXME: This isn't quite right; if we're performing aggregate
4048  // initialization, each braced subexpression is its own full-expression.
4049  FullExpressionRAII Scope(Info);
4050  if (!EvaluateDecl(Info, DclIt) && !Info.noteFailure())
4051  return ESR_Failed;
4052  }
4053  return ESR_Succeeded;
4054  }
4055 
4056  case Stmt::ReturnStmtClass: {
4057  const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
4058  FullExpressionRAII Scope(Info);
4059  if (RetExpr &&
4060  !(Result.Slot
4061  ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
4062  : Evaluate(Result.Value, Info, RetExpr)))
4063  return ESR_Failed;
4064  return ESR_Returned;
4065  }
4066 
4067  case Stmt::CompoundStmtClass: {
4068  BlockScopeRAII Scope(Info);
4069 
4070  const CompoundStmt *CS = cast<CompoundStmt>(S);
4071  for (const auto *BI : CS->body()) {
4072  EvalStmtResult ESR = EvaluateStmt(Result, Info, BI, Case);
4073  if (ESR == ESR_Succeeded)
4074  Case = nullptr;
4075  else if (ESR != ESR_CaseNotFound)
4076  return ESR;
4077  }
4078  return Case ? ESR_CaseNotFound : ESR_Succeeded;
4079  }
4080 
4081  case Stmt::IfStmtClass: {
4082  const IfStmt *IS = cast<IfStmt>(S);
4083 
4084  // Evaluate the condition, as either a var decl or as an expression.
4085  BlockScopeRAII Scope(Info);
4086  if (const Stmt *Init = IS->getInit()) {
4087  EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
4088  if (ESR != ESR_Succeeded)
4089  return ESR;
4090  }
4091  bool Cond;
4092  if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
4093  return ESR_Failed;
4094 
4095  if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
4096  EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt);
4097  if (ESR != ESR_Succeeded)
4098  return ESR;
4099  }
4100  return ESR_Succeeded;
4101  }
4102 
4103  case Stmt::WhileStmtClass: {
4104  const WhileStmt *WS = cast<WhileStmt>(S);
4105  while (true) {
4106  BlockScopeRAII Scope(Info);
4107  bool Continue;
4108  if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(),
4109  Continue))
4110  return ESR_Failed;
4111  if (!Continue)
4112  break;
4113 
4114  EvalStmtResult ESR = EvaluateLoopBody(Result, Info, WS->getBody());
4115  if (ESR != ESR_Continue)
4116  return ESR;
4117  }
4118  return ESR_Succeeded;
4119  }
4120 
4121  case Stmt::DoStmtClass: {
4122  const DoStmt *DS = cast<DoStmt>(S);
4123  bool Continue;
4124  do {
4125  EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case);
4126  if (ESR != ESR_Continue)
4127  return ESR;
4128  Case = nullptr;
4129 
4130  FullExpressionRAII CondScope(Info);
4131  if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info))
4132  return ESR_Failed;
4133  } while (Continue);
4134  return ESR_Succeeded;
4135  }
4136 
4137  case Stmt::ForStmtClass: {
4138  const ForStmt *FS = cast<ForStmt>(S);
4139  BlockScopeRAII Scope(Info);
4140  if (FS->getInit()) {
4141  EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
4142  if (ESR != ESR_Succeeded)
4143  return ESR;
4144  }
4145  while (true) {
4146  BlockScopeRAII Scope(Info);
4147  bool Continue = true;
4148  if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(),
4149  FS->getCond(), Continue))
4150  return ESR_Failed;
4151  if (!Continue)
4152  break;
4153 
4154  EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody());
4155  if (ESR != ESR_Continue)
4156  return ESR;
4157 
4158  if (FS->getInc()) {
4159  FullExpressionRAII IncScope(Info);
4160  if (!EvaluateIgnoredValue(Info, FS->getInc()))
4161  return ESR_Failed;
4162  }
4163  }
4164  return ESR_Succeeded;
4165  }
4166 
4167  case Stmt::CXXForRangeStmtClass: {
4168  const CXXForRangeStmt *FS = cast<CXXForRangeStmt>(S);
4169  BlockScopeRAII Scope(Info);
4170 
4171  // Initialize the __range variable.
4172  EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getRangeStmt());
4173  if (ESR != ESR_Succeeded)
4174  return ESR;
4175 
4176  // Create the __begin and __end iterators.
4177  ESR = EvaluateStmt(Result, Info, FS->getBeginStmt());
4178  if (ESR != ESR_Succeeded)
4179  return ESR;
4180  ESR = EvaluateStmt(Result, Info, FS->getEndStmt());
4181  if (ESR != ESR_Succeeded)
4182  return ESR;
4183 
4184  while (true) {
4185  // Condition: __begin != __end.
4186  {
4187  bool Continue = true;
4188  FullExpressionRAII CondExpr(Info);
4189  if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info))
4190  return ESR_Failed;
4191  if (!Continue)
4192  break;
4193  }
4194 
4195  // User's variable declaration, initialized by *__begin.
4196  BlockScopeRAII InnerScope(Info);
4197  ESR = EvaluateStmt(Result, Info, FS->getLoopVarStmt());
4198  if (ESR != ESR_Succeeded)
4199  return ESR;
4200 
4201  // Loop body.
4202  ESR = EvaluateLoopBody(Result, Info, FS->getBody());
4203  if (ESR != ESR_Continue)
4204  return ESR;
4205 
4206  // Increment: ++__begin
4207  if (!EvaluateIgnoredValue(Info, FS->getInc()))
4208  return ESR_Failed;
4209  }
4210 
4211  return ESR_Succeeded;
4212  }
4213 
4214  case Stmt::SwitchStmtClass:
4215  return EvaluateSwitch(Result, Info, cast<SwitchStmt>(S));
4216 
4217  case Stmt::ContinueStmtClass:
4218  return ESR_Continue;
4219 
4220  case Stmt::BreakStmtClass:
4221  return ESR_Break;
4222 
4223  case Stmt::LabelStmtClass:
4224  return EvaluateStmt(Result, Info, cast<LabelStmt>(S)->getSubStmt(), Case);
4225 
4226  case Stmt::AttributedStmtClass:
4227  // As a general principle, C++11 attributes can be ignored without
4228  // any semantic impact.
4229  return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(),
4230  Case);
4231 
4232  case Stmt::CaseStmtClass:
4233  case Stmt::DefaultStmtClass:
4234  return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case);
4235  }
4236 }
4237 
4238 /// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial
4239 /// default constructor. If so, we'll fold it whether or not it's marked as
4240 /// constexpr. If it is marked as constexpr, we will never implicitly define it,
4241 /// so we need special handling.
4242 static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,
4243  const CXXConstructorDecl *CD,
4244  bool IsValueInitialization) {
4245  if (!CD->isTrivial() || !CD->isDefaultConstructor())
4246  return false;
4247 
4248  // Value-initialization does not call a trivial default constructor, so such a
4249  // call is a core constant expression whether or not the constructor is
4250  // constexpr.
4251  if (!CD->isConstexpr() && !IsValueInitialization) {
4252  if (Info.getLangOpts().CPlusPlus11) {
4253  // FIXME: If DiagDecl is an implicitly-declared special member function,
4254  // we should be much more explicit about why it's not constexpr.
4255  Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
4256  << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD;
4257  Info.Note(CD->getLocation(), diag::note_declared_at);
4258  } else {
4259  Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
4260  }
4261  }
4262  return true;
4263 }
4264 
4265 /// CheckConstexprFunction - Check that a function can be called in a constant
4266 /// expression.
4267 static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc,
4268  const FunctionDecl *Declaration,
4269  const FunctionDecl *Definition,
4270  const Stmt *Body) {
4271  // Potential constant expressions can contain calls to declared, but not yet
4272  // defined, constexpr functions.
4273  if (Info.checkingPotentialConstantExpression() && !Definition &&
4274  Declaration->isConstexpr())
4275  return false;
4276 
4277  // Bail out with no diagnostic if the function declaration itself is invalid.
4278  // We will have produced a relevant diagnostic while parsing it.
4279  if (Declaration->isInvalidDecl())
4280  return false;
4281 
4282  // Can we evaluate this function call?
4283  if (Definition && Definition->isConstexpr() &&
4284  !Definition->isInvalidDecl() && Body)
4285  return true;
4286 
4287  if (Info.getLangOpts().CPlusPlus11) {
4288  const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;
4289 
4290  // If this function is not constexpr because it is an inherited
4291  // non-constexpr constructor, diagnose that directly.
4292  auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
4293  if (CD && CD->isInheritingConstructor()) {
4294  auto *Inherited = CD->getInheritedConstructor().getConstructor();
4295  if (!Inherited->isConstexpr())
4296  DiagDecl = CD = Inherited;
4297  }
4298 
4299  // FIXME: If DiagDecl is an implicitly-declared special member function
4300  // or an inheriting constructor, we should be much more explicit about why
4301  // it's not constexpr.
4302  if (CD && CD->isInheritingConstructor())
4303  Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1)
4304  << CD->getInheritedConstructor().getConstructor()->getParent();
4305  else
4306  Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1)
4307  << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
4308  Info.Note(DiagDecl->getLocation(), diag::note_declared_at);
4309  } else {
4310  Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
4311  }
4312  return false;
4313 }
4314 
4315 /// Determine if a class has any fields that might need to be copied by a
4316 /// trivial copy or move operation.
4317 static bool hasFields(const CXXRecordDecl *RD) {
4318  if (!RD || RD->isEmpty())
4319  return false;
4320  for (auto *FD : RD->fields()) {
4321  if (FD->isUnnamedBitfield())
4322  continue;
4323  return true;
4324  }
4325  for (auto &Base : RD->bases())
4326  if (hasFields(Base.getType()->getAsCXXRecordDecl()))
4327  return true;
4328  return false;
4329 }
4330 
4331 namespace {
4332 typedef SmallVector<APValue, 8> ArgVector;
4333 }
4334 
4335 /// EvaluateArgs - Evaluate the arguments to a function call.
4336 static bool EvaluateArgs(ArrayRef<const Expr*> Args, ArgVector &ArgValues,
4337  EvalInfo &Info) {
4338  bool Success = true;
4339  for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end();
4340  I != E; ++I) {
4341  if (!Evaluate(ArgValues[I - Args.begin()], Info, *I)) {
4342  // If we're checking for a potential constant expression, evaluate all
4343  // initializers even if some of them fail.
4344  if (!Info.noteFailure())
4345  return false;
4346  Success = false;
4347  }
4348  }
4349  return Success;
4350 }
4351 
4352 /// Evaluate a function call.
4354  const FunctionDecl *Callee, const LValue *This,
4355  ArrayRef<const Expr*> Args, const Stmt *Body,
4356  EvalInfo &Info, APValue &Result,
4357  const LValue *ResultSlot) {
4358  ArgVector ArgValues(Args.size());
4359  if (!EvaluateArgs(Args, ArgValues, Info))
4360  return false;
4361 
4362  if (!Info.CheckCallLimit(CallLoc))
4363  return false;
4364 
4365  CallStackFrame Frame(Info, CallLoc, Callee, This, ArgValues.data());
4366 
4367  // For a trivial copy or move assignment, perform an APValue copy. This is
4368  // essential for unions, where the operations performed by the assignment
4369  // operator cannot be represented as statements.
4370  //
4371  // Skip this for non-union classes with no fields; in that case, the defaulted
4372  // copy/move does not actually read the object.
4373  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee);
4374  if (MD && MD->isDefaulted() &&
4375  (MD->getParent()->isUnion() ||
4376  (MD->isTrivial() && hasFields(MD->getParent())))) {
4377  assert(This &&
4378  (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()));
4379  LValue RHS;
4380  RHS.setFrom(Info.Ctx, ArgValues[0]);
4381  APValue RHSValue;
4382  if (!handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(),
4383  RHS, RHSValue))
4384  return false;
4385  if (!handleAssignment(Info, Args[0], *This, MD->getThisType(Info.Ctx),
4386  RHSValue))
4387  return false;
4388  This->moveInto(Result);
4389  return true;
4390  } else if (MD && isLambdaCallOperator(MD)) {
4391  // We're in a lambda; determine the lambda capture field maps unless we're
4392  // just constexpr checking a lambda's call operator. constexpr checking is
4393  // done before the captures have been added to the closure object (unless
4394  // we're inferring constexpr-ness), so we don't have access to them in this
4395  // case. But since we don't need the captures to constexpr check, we can
4396  // just ignore them.
4397  if (!Info.checkingPotentialConstantExpression())
4398  MD->getParent()->getCaptureFields(Frame.LambdaCaptureFields,
4399  Frame.LambdaThisCaptureField);
4400  }
4401 
4402  StmtResult Ret = {Result, ResultSlot};
4403  EvalStmtResult ESR = EvaluateStmt(Ret, Info, Body);
4404  if (ESR == ESR_Succeeded) {
4405  if (Callee->getReturnType()->isVoidType())
4406  return true;
4407  Info.FFDiag(Callee->getLocEnd(), diag::note_constexpr_no_return);
4408  }
4409  return ESR == ESR_Returned;
4410 }
4411 
4412 /// Evaluate a constructor call.
4413 static bool HandleConstructorCall(const Expr *E, const LValue &This,
4414  APValue *ArgValues,
4415  const CXXConstructorDecl *Definition,
4416  EvalInfo &Info, APValue &Result) {
4417  SourceLocation CallLoc = E->getExprLoc();
4418  if (!Info.CheckCallLimit(CallLoc))
4419  return false;
4420 
4421  const CXXRecordDecl *RD = Definition->getParent();
4422  if (RD->getNumVBases()) {
4423  Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
4424  return false;
4425  }
4426 
4427  EvalInfo::EvaluatingConstructorRAII EvalObj(
4428  Info, {This.getLValueBase(),
4429  {This.getLValueCallIndex(), This.getLValueVersion()}});
4430  CallStackFrame Frame(Info, CallLoc, Definition, &This, ArgValues);
4431 
4432  // FIXME: Creating an APValue just to hold a nonexistent return value is
4433  // wasteful.
4434  APValue RetVal;
4435  StmtResult Ret = {RetVal, nullptr};
4436 
4437  // If it's a delegating constructor, delegate.
4438  if (Definition->isDelegatingConstructor()) {
4440  {
4441  FullExpressionRAII InitScope(Info);
4442  if (!EvaluateInPlace(Result, Info, This, (*I)->getInit()))
4443  return false;
4444  }
4445  return EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed;
4446  }
4447 
4448  // For a trivial copy or move constructor, perform an APValue copy. This is
4449  // essential for unions (or classes with anonymous union members), where the
4450  // operations performed by the constructor cannot be represented by
4451  // ctor-initializers.
4452  //
4453  // Skip this for empty non-union classes; we should not perform an
4454  // lvalue-to-rvalue conversion on them because their copy constructor does not
4455  // actually read them.
4456  if (Definition->isDefaulted() && Definition->isCopyOrMoveConstructor() &&
4457  (Definition->getParent()->isUnion() ||
4458  (Definition->isTrivial() && hasFields(Definition->getParent())))) {
4459  LValue RHS;
4460  RHS.setFrom(Info.Ctx, ArgValues[0]);
4462  Info, E, Definition->getParamDecl(0)->getType().getNonReferenceType(),
4463  RHS, Result);
4464  }
4465 
4466  // Reserve space for the struct members.
4467  if (!RD->isUnion() && Result.isUninit())
4468  Result = APValue(APValue::UninitStruct(), RD->getNumBases(),
4469  std::distance(RD->field_begin(), RD->field_end()));
4470 
4471  if (RD->isInvalidDecl()) return false;
4472  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
4473 
4474  // A scope for temporaries lifetime-extended by reference members.
4475  BlockScopeRAII LifetimeExtendedScope(Info);
4476 
4477  bool Success = true;
4478  unsigned BasesSeen = 0;
4479 #ifndef NDEBUG
4481 #endif
4482  for (const auto *I : Definition->inits()) {
4483  LValue Subobject = This;
4484  LValue SubobjectParent = This;
4485  APValue *Value = &Result;
4486 
4487  // Determine the subobject to initialize.
4488  FieldDecl *FD = nullptr;
4489  if (I->isBaseInitializer()) {
4490  QualType BaseType(I->getBaseClass(), 0);
4491 #ifndef NDEBUG
4492  // Non-virtual base classes are initialized in the order in the class
4493  // definition. We have already checked for virtual base classes.
4494  assert(!BaseIt->isVirtual() && "virtual base for literal type");
4495  assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&
4496  "base class initializers not in expected order");
4497  ++BaseIt;
4498 #endif
4499  if (!HandleLValueDirectBase(Info, I->getInit(), Subobject, RD,
4500  BaseType->getAsCXXRecordDecl(), &Layout))
4501  return false;
4502  Value = &Result.getStructBase(BasesSeen++);
4503  } else if ((FD = I->getMember())) {
4504  if (!HandleLValueMember(Info, I->getInit(), Subobject, FD, &Layout))
4505  return false;
4506  if (RD->isUnion()) {
4507  Result = APValue(FD);
4508  Value = &Result.getUnionValue();
4509  } else {
4510  Value = &Result.getStructField(FD->getFieldIndex());
4511  }
4512  } else if (IndirectFieldDecl *IFD = I->getIndirectMember()) {
4513  // Walk the indirect field decl's chain to find the object to initialize,
4514  // and make sure we've initialized every step along it.
4515  auto IndirectFieldChain = IFD->chain();
4516  for (auto *C : IndirectFieldChain) {
4517  FD = cast<FieldDecl>(C);
4518  CXXRecordDecl *CD = cast<CXXRecordDecl>(FD->getParent());
4519  // Switch the union field if it differs. This happens if we had
4520  // preceding zero-initialization, and we're now initializing a union
4521  // subobject other than the first.
4522  // FIXME: In this case, the values of the other subobjects are
4523  // specified, since zero-initialization sets all padding bits to zero.
4524  if (Value->isUninit() ||
4525  (Value->isUnion() && Value->getUnionField() != FD)) {
4526  if (CD->isUnion())
4527  *Value = APValue(FD);
4528  else
4529  *Value = APValue(APValue::UninitStruct(), CD->getNumBases(),
4530  std::distance(CD->field_begin(), CD->field_end()));
4531  }
4532  // Store Subobject as its parent before updating it for the last element
4533  // in the chain.
4534  if (C == IndirectFieldChain.back())
4535  SubobjectParent = Subobject;
4536  if (!HandleLValueMember(Info, I->getInit(), Subobject, FD))
4537  return false;
4538  if (CD->isUnion())
4539  Value = &Value->getUnionValue();
4540  else
4541  Value = &Value->getStructField(FD->getFieldIndex());
4542  }
4543  } else {
4544  llvm_unreachable("unknown base initializer kind");
4545  }
4546 
4547  // Need to override This for implicit field initializers as in this case
4548  // This refers to innermost anonymous struct/union containing initializer,
4549  // not to currently constructed class.
4550  const Expr *Init = I->getInit();
4551  ThisOverrideRAII ThisOverride(*Info.CurrentCall, &SubobjectParent,
4552  isa<CXXDefaultInitExpr>(Init));
4553  FullExpressionRAII InitScope(Info);
4554  if (!EvaluateInPlace(*Value, Info, Subobject, Init) ||
4555  (FD && FD->isBitField() &&
4556  !truncateBitfieldValue(Info, Init, *Value, FD))) {
4557  // If we're checking for a potential constant expression, evaluate all
4558  // initializers even if some of them fail.
4559  if (!Info.noteFailure())
4560  return false;
4561  Success = false;
4562  }
4563  }
4564 
4565  return Success &&
4566  EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed;
4567 }
4568 
4569 static bool HandleConstructorCall(const Expr *E, const LValue &This,
4570  ArrayRef<const Expr*> Args,
4571  const CXXConstructorDecl *Definition,
4572  EvalInfo &Info, APValue &Result) {
4573  ArgVector ArgValues(Args.size());
4574  if (!EvaluateArgs(Args, ArgValues, Info))
4575  return false;
4576 
4577  return HandleConstructorCall(E, This, ArgValues.data(), Definition,
4578  Info, Result);
4579 }
4580 
4581 //===----------------------------------------------------------------------===//
4582 // Generic Evaluation
4583 //===----------------------------------------------------------------------===//
4584 namespace {
4585 
4586 template <class Derived>
4587 class ExprEvaluatorBase
4588  : public ConstStmtVisitor<Derived, bool> {
4589 private:
4590  Derived &getDerived() { return static_cast<Derived&>(*this); }
4591  bool DerivedSuccess(const APValue &V, const Expr *E) {
4592  return getDerived().Success(V, E);
4593  }
4594  bool DerivedZeroInitialization(const Expr *E) {
4595  return getDerived().ZeroInitialization(E);
4596  }
4597 
4598  // Check whether a conditional operator with a non-constant condition is a
4599  // potential constant expression. If neither arm is a potential constant
4600  // expression, then the conditional operator is not either.
4601  template<typename ConditionalOperator>
4602  void CheckPotentialConstantConditional(const ConditionalOperator *E) {
4603  assert(Info.checkingPotentialConstantExpression());
4604 
4605  // Speculatively evaluate both arms.
4607  {
4608  SpeculativeEvaluationRAII Speculate(Info, &Diag);
4609  StmtVisitorTy::Visit(E->getFalseExpr());
4610  if (Diag.empty())
4611  return;
4612  }
4613 
4614  {
4615  SpeculativeEvaluationRAII Speculate(Info, &Diag);
4616  Diag.clear();
4617  StmtVisitorTy::Visit(E->getTrueExpr());
4618  if (Diag.empty())
4619  return;
4620  }
4621 
4622  Error(E, diag::note_constexpr_conditional_never_const);
4623  }
4624 
4625 
4626  template<typename ConditionalOperator>
4627  bool HandleConditionalOperator(const ConditionalOperator *E) {
4628  bool BoolResult;
4629  if (!EvaluateAsBooleanCondition(E->getCond(), BoolResult, Info)) {
4630  if (Info.checkingPotentialConstantExpression() && Info.noteFailure()) {
4631  CheckPotentialConstantConditional(E);
4632  return false;
4633  }
4634  if (Info.noteFailure()) {
4635  StmtVisitorTy::Visit(E->getTrueExpr());
4636  StmtVisitorTy::Visit(E->getFalseExpr());
4637  }
4638  return false;
4639  }
4640 
4641  Expr *EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr();
4642  return StmtVisitorTy::Visit(EvalExpr);
4643  }
4644 
4645 protected:
4646  EvalInfo &Info;
4647  typedef ConstStmtVisitor<Derived, bool> StmtVisitorTy;
4648  typedef ExprEvaluatorBase ExprEvaluatorBaseTy;
4649 
4650  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
4651  return Info.CCEDiag(E, D);
4652  }
4653 
4654  bool ZeroInitialization(const Expr *E) { return Error(E); }
4655 
4656 public:
4657  ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
4658 
4659  EvalInfo &getEvalInfo() { return Info; }
4660 
4661  /// Report an evaluation error. This should only be called when an error is
4662  /// first discovered. When propagating an error, just return false.
4663  bool Error(const Expr *E, diag::kind D) {
4664  Info.FFDiag(E, D);
4665  return false;
4666  }
4667  bool Error(const Expr *E) {
4668  return Error(E, diag::note_invalid_subexpr_in_const_expr);
4669  }
4670 
4671  bool VisitStmt(const Stmt *) {
4672  llvm_unreachable("Expression evaluator should not be called on stmts");
4673  }
4674  bool VisitExpr(const Expr *E) {
4675  return Error(E);
4676  }
4677 
4678  bool VisitParenExpr(const ParenExpr *E)
4679  { return StmtVisitorTy::Visit(E->getSubExpr()); }
4680  bool VisitUnaryExtension(const UnaryOperator *E)
4681  { return StmtVisitorTy::Visit(E->getSubExpr()); }
4682  bool VisitUnaryPlus(const UnaryOperator *E)
4683  { return StmtVisitorTy::Visit(E->getSubExpr()); }
4684  bool VisitChooseExpr(const ChooseExpr *E)
4685  { return StmtVisitorTy::Visit(E->getChosenSubExpr()); }
4686  bool VisitGenericSelectionExpr(const GenericSelectionExpr *E)
4687  { return StmtVisitorTy::Visit(E->getResultExpr()); }
4688  bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E)
4689  { return StmtVisitorTy::Visit(E->getReplacement()); }
4690  bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) {
4691  TempVersionRAII RAII(*Info.CurrentCall);
4692  return StmtVisitorTy::Visit(E->getExpr());
4693  }
4694  bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
4695  TempVersionRAII RAII(*Info.CurrentCall);
4696  // The initializer may not have been parsed yet, or might be erroneous.
4697  if (!E->getExpr())
4698  return Error(E);
4699  return StmtVisitorTy::Visit(E->getExpr());
4700  }
4701  // We cannot create any objects for which cleanups are required, so there is
4702  // nothing to do here; all cleanups must come from unevaluated subexpressions.
4703  bool VisitExprWithCleanups(const ExprWithCleanups *E)
4704  { return StmtVisitorTy::Visit(E->getSubExpr()); }
4705 
4706  bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
4707  CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
4708  return static_cast<Derived*>(this)->VisitCastExpr(E);
4709  }
4710  bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
4711  CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
4712  return static_cast<Derived*>(this)->VisitCastExpr(E);
4713  }
4714 
4715  bool VisitBinaryOperator(const BinaryOperator *E) {
4716  switch (E->getOpcode()) {
4717  default:
4718  return Error(E);
4719 
4720  case BO_Comma:
4721  VisitIgnoredValue(E->getLHS());
4722  return StmtVisitorTy::Visit(E->getRHS());
4723 
4724  case BO_PtrMemD:
4725  case BO_PtrMemI: {
4726  LValue Obj;
4727  if (!HandleMemberPointerAccess(Info, E, Obj))
4728  return false;
4729  APValue Result;
4730  if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result))
4731  return false;
4732  return DerivedSuccess(Result, E);
4733  }
4734  }
4735  }
4736 
4737  bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E) {
4738  // Evaluate and cache the common expression. We treat it as a temporary,
4739  // even though it's not quite the same thing.
4740  if (!Evaluate(Info.CurrentCall->createTemporary(E->getOpaqueValue(), false),
4741  Info, E->getCommon()))
4742  return false;
4743 
4744  return HandleConditionalOperator(E);
4745  }
4746 
4747  bool VisitConditionalOperator(const ConditionalOperator *E) {
4748  bool IsBcpCall = false;
4749  // If the condition (ignoring parens) is a __builtin_constant_p call,
4750  // the result is a constant expression if it can be folded without
4751  // side-effects. This is an important GNU extension. See GCC PR38377
4752  // for discussion.
4753  if (const CallExpr *CallCE =
4754  dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
4755  if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
4756  IsBcpCall = true;
4757 
4758  // Always assume __builtin_constant_p(...) ? ... : ... is a potential
4759  // constant expression; we can't check whether it's potentially foldable.
4760  if (Info.checkingPotentialConstantExpression() && IsBcpCall)
4761  return false;
4762 
4763  FoldConstant Fold(Info, IsBcpCall);
4764  if (!HandleConditionalOperator(E)) {
4765  Fold.keepDiagnostics();
4766  return false;
4767  }
4768 
4769  return true;
4770  }
4771 
4772  bool VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
4773  if (APValue *Value = Info.CurrentCall->getCurrentTemporary(E))
4774  return DerivedSuccess(*Value, E);
4775 
4776  const Expr *Source = E->getSourceExpr();
4777  if (!Source)
4778  return Error(E);
4779  if (Source == E) { // sanity checking.
4780  assert(0 && "OpaqueValueExpr recursively refers to itself");
4781  return Error(E);
4782  }
4783  return StmtVisitorTy::Visit(Source);
4784  }
4785 
4786  bool VisitCallExpr(const CallExpr *E) {
4787  APValue Result;
4788  if (!handleCallExpr(E, Result, nullptr))
4789  return false;
4790  return DerivedSuccess(Result, E);
4791  }
4792 
4793  bool handleCallExpr(const CallExpr *E, APValue &Result,
4794  const LValue *ResultSlot) {
4795  const Expr *Callee = E->getCallee()->IgnoreParens();
4796  QualType CalleeType = Callee->getType();
4797 
4798  const FunctionDecl *FD = nullptr;
4799  LValue *This = nullptr, ThisVal;
4800  auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
4801  bool HasQualifier = false;
4802 
4803  // Extract function decl and 'this' pointer from the callee.
4804  if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) {
4805  const ValueDecl *Member = nullptr;
4806  if (const MemberExpr *ME = dyn_cast<MemberExpr>(Callee)) {
4807  // Explicit bound member calls, such as x.f() or p->g();
4808  if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal))
4809  return false;
4810  Member = ME->getMemberDecl();
4811  This = &ThisVal;
4812  HasQualifier = ME->hasQualifier();
4813  } else if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) {
4814  // Indirect bound member calls ('.*' or '->*').
4815  Member = HandleMemberPointerAccess(Info, BE, ThisVal, false);
4816  if (!Member) return false;
4817  This = &ThisVal;
4818  } else
4819  return Error(Callee);
4820 
4821  FD = dyn_cast<FunctionDecl>(Member);
4822  if (!FD)
4823  return Error(Callee);
4824  } else if (CalleeType->isFunctionPointerType()) {
4825  LValue Call;
4826  if (!EvaluatePointer(Callee, Call, Info))
4827  return false;
4828 
4829  if (!Call.getLValueOffset().isZero())
4830  return Error(Callee);
4831  FD = dyn_cast_or_null<FunctionDecl>(
4832  Call.getLValueBase().dyn_cast<const ValueDecl*>());
4833  if (!FD)
4834  return Error(Callee);
4835  // Don't call function pointers which have been cast to some other type.
4836  // Per DR (no number yet), the caller and callee can differ in noexcept.
4837  if (!Info.Ctx.hasSameFunctionTypeIgnoringExceptionSpec(
4838  CalleeType->getPointeeType(), FD->getType())) {
4839  return Error(E);
4840  }
4841 
4842  // Overloaded operator calls to member functions are represented as normal
4843  // calls with '*this' as the first argument.
4844  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
4845  if (MD && !MD->isStatic()) {
4846  // FIXME: When selecting an implicit conversion for an overloaded
4847  // operator delete, we sometimes try to evaluate calls to conversion
4848  // operators without a 'this' parameter!
4849  if (Args.empty())
4850  return Error(E);
4851 
4852  if (!EvaluateObjectArgument(Info, Args[0], ThisVal))
4853  return false;
4854  This = &ThisVal;
4855  Args = Args.slice(1);
4856  } else if (MD && MD->isLambdaStaticInvoker()) {
4857  // Map the static invoker for the lambda back to the call operator.
4858  // Conveniently, we don't have to slice out the 'this' argument (as is
4859  // being done for the non-static case), since a static member function
4860  // doesn't have an implicit argument passed in.
4861  const CXXRecordDecl *ClosureClass = MD->getParent();
4862  assert(
4863  ClosureClass->captures_begin() == ClosureClass->captures_end() &&
4864  "Number of captures must be zero for conversion to function-ptr");
4865 
4866  const CXXMethodDecl *LambdaCallOp =
4867  ClosureClass->getLambdaCallOperator();
4868 
4869  // Set 'FD', the function that will be called below, to the call
4870  // operator. If the closure object represents a generic lambda, find
4871  // the corresponding specialization of the call operator.
4872 
4873  if (ClosureClass->isGenericLambda()) {
4874  assert(MD->isFunctionTemplateSpecialization() &&
4875  "A generic lambda's static-invoker function must be a "
4876  "template specialization");
4878  FunctionTemplateDecl *CallOpTemplate =
4879  LambdaCallOp->getDescribedFunctionTemplate();
4880  void *InsertPos = nullptr;
4881  FunctionDecl *CorrespondingCallOpSpecialization =
4882  CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos);
4883  assert(CorrespondingCallOpSpecialization &&
4884  "We must always have a function call operator specialization "
4885  "that corresponds to our static invoker specialization");
4886  FD = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization);
4887  } else
4888  FD = LambdaCallOp;
4889  }
4890 
4891 
4892  } else
4893  return Error(E);
4894 
4895  if (This && !This->checkSubobject(Info, E, CSK_This))
4896  return false;
4897 
4898  // DR1358 allows virtual constexpr functions in some cases. Don't allow
4899  // calls to such functions in constant expressions.
4900  if (This && !HasQualifier &&
4901  isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isVirtual())
4902  return Error(E, diag::note_constexpr_virtual_call);
4903 
4904  const FunctionDecl *Definition = nullptr;
4905  Stmt *Body = FD->getBody(Definition);
4906 
4907  if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body) ||
4908  !HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Body, Info,
4909  Result, ResultSlot))
4910  return false;
4911 
4912  return true;
4913  }
4914 
4915  bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
4916  return StmtVisitorTy::Visit(E->getInitializer());
4917  }
4918  bool VisitInitListExpr(const InitListExpr *E) {
4919  if (E->getNumInits() == 0)
4920  return DerivedZeroInitialization(E);
4921  if (E->getNumInits() == 1)
4922  return StmtVisitorTy::Visit(E->getInit(0));
4923  return Error(E);
4924  }
4925  bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
4926  return DerivedZeroInitialization(E);
4927  }
4928  bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
4929  return DerivedZeroInitialization(E);
4930  }
4931  bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
4932  return DerivedZeroInitialization(E);
4933  }
4934 
4935  /// A member expression where the object is a prvalue is itself a prvalue.
4936  bool VisitMemberExpr(const MemberExpr *E) {
4937  assert(!E->isArrow() && "missing call to bound member function?");
4938 
4939  APValue Val;
4940  if (!Evaluate(Val, Info, E->getBase()))
4941  return false;
4942 
4943  QualType BaseTy = E->getBase()->getType();
4944 
4945  const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
4946  if (!FD) return Error(E);
4947  assert(!FD->getType()->isReferenceType() && "prvalue reference?");
4948  assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() ==
4949  FD->getParent()->getCanonicalDecl() && "record / field mismatch");
4950 
4951  CompleteObject Obj(&Val, BaseTy, true);
4952  SubobjectDesignator Designator(BaseTy);
4953  Designator.addDeclUnchecked(FD);
4954 
4955  APValue Result;
4956  return extractSubobject(Info, E, Obj, Designator, Result) &&
4957  DerivedSuccess(Result, E);
4958  }
4959 
4960  bool VisitCastExpr(const CastExpr *E) {
4961  switch (E->getCastKind()) {
4962  default:
4963  break;
4964 
4965  case CK_AtomicToNonAtomic: {
4966  APValue AtomicVal;
4967  // This does not need to be done in place even for class/array types:
4968  // atomic-to-non-atomic conversion implies copying the object
4969  // representation.
4970  if (!Evaluate(AtomicVal, Info, E->getSubExpr()))
4971  return false;
4972  return DerivedSuccess(AtomicVal, E);
4973  }
4974 
4975  case CK_NoOp:
4976  case CK_UserDefinedConversion:
4977  return StmtVisitorTy::Visit(E->getSubExpr());
4978 
4979  case CK_LValueToRValue: {
4980  LValue LVal;
4981  if (!EvaluateLValue(E->getSubExpr(), LVal, Info))
4982  return false;
4983  APValue RVal;
4984  // Note, we use the subexpression's type in order to retain cv-qualifiers.
4985  if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
4986  LVal, RVal))
4987  return false;
4988  return DerivedSuccess(RVal, E);
4989  }
4990  }
4991 
4992  return Error(E);
4993  }
4994 
4995  bool VisitUnaryPostInc(const UnaryOperator *UO) {
4996  return VisitUnaryPostIncDec(UO);
4997  }
4998  bool VisitUnaryPostDec(const UnaryOperator *UO) {
4999  return VisitUnaryPostIncDec(UO);
5000  }
5001  bool VisitUnaryPostIncDec(const UnaryOperator *UO) {
5002  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5003  return Error(UO);
5004 
5005  LValue LVal;
5006  if (!EvaluateLValue(UO->getSubExpr(), LVal, Info))
5007  return false;
5008  APValue RVal;
5009  if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(),
5010  UO->isIncrementOp(), &RVal))
5011  return false;
5012  return DerivedSuccess(RVal, UO);
5013  }
5014 
5015  bool VisitStmtExpr(const StmtExpr *E) {
5016  // We will have checked the full-expressions inside the statement expression
5017  // when they were completed, and don't need to check them again now.
5018  if (Info.checkingForOverflow())
5019  return Error(E);
5020 
5021  BlockScopeRAII Scope(Info);
5022  const CompoundStmt *CS = E->getSubStmt();
5023  if (CS->body_empty())
5024  return true;
5025 
5027  BE = CS->body_end();
5028  /**/; ++BI) {
5029  if (BI + 1 == BE) {
5030  const Expr *FinalExpr = dyn_cast<Expr>(*BI);
5031  if (!FinalExpr) {
5032  Info.FFDiag((*BI)->getLocStart(),
5033  diag::note_constexpr_stmt_expr_unsupported);
5034  return false;
5035  }
5036  return this->Visit(FinalExpr);
5037  }
5038 
5039  APValue ReturnValue;
5040  StmtResult Result = { ReturnValue, nullptr };
5041  EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI);
5042  if (ESR != ESR_Succeeded) {
5043  // FIXME: If the statement-expression terminated due to 'return',
5044  // 'break', or 'continue', it would be nice to propagate that to
5045  // the outer statement evaluation rather than bailing out.
5046  if (ESR != ESR_Failed)
5047  Info.FFDiag((*BI)->getLocStart(),
5048  diag::note_constexpr_stmt_expr_unsupported);
5049  return false;
5050  }
5051  }
5052 
5053  llvm_unreachable("Return from function from the loop above.");
5054  }
5055 
5056  /// Visit a value which is evaluated, but whose value is ignored.
5057  void VisitIgnoredValue(const Expr *E) {
5058  EvaluateIgnoredValue(Info, E);
5059  }
5060 
5061  /// Potentially visit a MemberExpr's base expression.
5062  void VisitIgnoredBaseExpression(const Expr *E) {
5063  // While MSVC doesn't evaluate the base expression, it does diagnose the
5064  // presence of side-effecting behavior.
5065  if (Info.getLangOpts().MSVCCompat && !E->HasSideEffects(Info.Ctx))
5066  return;
5067  VisitIgnoredValue(E);
5068  }
5069 };
5070 
5071 } // namespace
5072 
5073 //===----------------------------------------------------------------------===//
5074 // Common base class for lvalue and temporary evaluation.
5075 //===----------------------------------------------------------------------===//
5076 namespace {
5077 template<class Derived>
5078 class LValueExprEvaluatorBase
5079  : public ExprEvaluatorBase<Derived> {
5080 protected:
5081  LValue &Result;
5082  bool InvalidBaseOK;
5083  typedef LValueExprEvaluatorBase LValueExprEvaluatorBaseTy;
5084  typedef ExprEvaluatorBase<Derived> ExprEvaluatorBaseTy;
5085 
5086  bool Success(APValue::LValueBase B) {
5087  Result.set(B);
5088  return true;
5089  }
5090 
5091  bool evaluatePointer(const Expr *E, LValue &Result) {
5092  return EvaluatePointer(E, Result, this->Info, InvalidBaseOK);
5093  }
5094 
5095 public:
5096  LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result, bool InvalidBaseOK)
5097  : ExprEvaluatorBaseTy(Info), Result(Result),
5098  InvalidBaseOK(InvalidBaseOK) {}
5099 
5100  bool Success(const APValue &V, const Expr *E) {
5101  Result.setFrom(this->Info.Ctx, V);
5102  return true;
5103  }
5104 
5105  bool VisitMemberExpr(const MemberExpr *E) {
5106  // Handle non-static data members.
5107  QualType BaseTy;
5108  bool EvalOK;
5109  if (E->isArrow()) {
5110  EvalOK = evaluatePointer(E->getBase(), Result);
5111  BaseTy = E->getBase()->getType()->castAs<PointerType>()->getPointeeType();
5112  } else if (E->getBase()->isRValue()) {
5113  assert(E->getBase()->getType()->isRecordType());
5114  EvalOK = EvaluateTemporary(E->getBase(), Result, this->Info);
5115  BaseTy = E->getBase()->getType();
5116  } else {
5117  EvalOK = this->Visit(E->getBase());
5118  BaseTy = E->getBase()->getType();
5119  }
5120  if (!EvalOK) {
5121  if (!InvalidBaseOK)
5122  return false;
5123  Result.setInvalid(E);
5124  return true;
5125  }
5126 
5127  const ValueDecl *MD = E->getMemberDecl();
5128  if (const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
5129  assert(BaseTy->getAs<RecordType>()->getDecl()->getCanonicalDecl() ==
5130  FD->getParent()->getCanonicalDecl() && "record / field mismatch");
5131  (void)BaseTy;
5132  if (!HandleLValueMember(this->Info, E, Result, FD))
5133  return false;
5134  } else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(MD)) {
5135  if (!HandleLValueIndirectMember(this->Info, E, Result, IFD))
5136  return false;
5137  } else
5138  return this->Error(E);
5139 
5140  if (MD->getType()->isReferenceType()) {
5141  APValue RefValue;
5142  if (!handleLValueToRValueConversion(this->Info, E, MD->getType(), Result,
5143  RefValue))
5144  return false;
5145  return Success(RefValue, E);
5146  }
5147  return true;
5148  }
5149 
5150  bool VisitBinaryOperator(const BinaryOperator *E) {
5151  switch (E->getOpcode()) {
5152  default:
5153  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
5154 
5155  case BO_PtrMemD:
5156  case BO_PtrMemI:
5157  return HandleMemberPointerAccess(this->Info, E, Result);
5158  }
5159  }
5160 
5161  bool VisitCastExpr(const CastExpr *E) {
5162  switch (E->getCastKind()) {
5163  default:
5164  return ExprEvaluatorBaseTy::VisitCastExpr(E);
5165 
5166  case CK_DerivedToBase:
5167  case CK_UncheckedDerivedToBase:
5168  if (!this->Visit(E->getSubExpr()))
5169  return false;
5170 
5171  // Now figure out the necessary offset to add to the base LV to get from
5172  // the derived class to the base class.
5173  return HandleLValueBasePath(this->Info, E, E->getSubExpr()->getType(),
5174  Result);
5175  }
5176  }
5177 };
5178 }
5179 
5180 //===----------------------------------------------------------------------===//
5181 // LValue Evaluation
5182 //
5183 // This is used for evaluating lvalues (in C and C++), xvalues (in C++11),
5184 // function designators (in C), decl references to void objects (in C), and
5185 // temporaries (if building with -Wno-address-of-temporary).
5186 //
5187 // LValue evaluation produces values comprising a base expression of one of the
5188 // following types:
5189 // - Declarations
5190 // * VarDecl
5191 // * FunctionDecl
5192 // - Literals
5193 // * CompoundLiteralExpr in C (and in global scope in C++)
5194 // * StringLiteral
5195 // * CXXTypeidExpr
5196 // * PredefinedExpr
5197 // * ObjCStringLiteralExpr
5198 // * ObjCEncodeExpr
5199 // * AddrLabelExpr
5200 // * BlockExpr
5201 // * CallExpr for a MakeStringConstant builtin
5202 // - Locals and temporaries
5203 // * MaterializeTemporaryExpr
5204 // * Any Expr, with a CallIndex indicating the function in which the temporary
5205 // was evaluated, for cases where the MaterializeTemporaryExpr is missing
5206 // from the AST (FIXME).
5207 // * A MaterializeTemporaryExpr that has static storage duration, with no
5208 // CallIndex, for a lifetime-extended temporary.
5209 // plus an offset in bytes.
5210 //===----------------------------------------------------------------------===//
5211 namespace {
5212 class LValueExprEvaluator
5213  : public LValueExprEvaluatorBase<LValueExprEvaluator> {
5214 public:
5215  LValueExprEvaluator(EvalInfo &Info, LValue &Result, bool InvalidBaseOK) :
5216  LValueExprEvaluatorBaseTy(Info, Result, InvalidBaseOK) {}
5217 
5218  bool VisitVarDecl(const Expr *E, const VarDecl *VD);
5219  bool VisitUnaryPreIncDec(const UnaryOperator *UO);
5220 
5221  bool VisitDeclRefExpr(const DeclRefExpr *E);
5222  bool VisitPredefinedExpr(const PredefinedExpr *E) { return Success(E); }
5223  bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
5224  bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
5225  bool VisitMemberExpr(const MemberExpr *E);
5226  bool VisitStringLiteral(const StringLiteral *E) { return Success(E); }
5227  bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { return Success(E); }
5228  bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
5229  bool VisitCXXUuidofExpr(const CXXUuidofExpr *E);
5230  bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
5231  bool VisitUnaryDeref(const UnaryOperator *E);
5232  bool VisitUnaryReal(const UnaryOperator *E);
5233  bool VisitUnaryImag(const UnaryOperator *E);
5234  bool VisitUnaryPreInc(const UnaryOperator *UO) {
5235  return VisitUnaryPreIncDec(UO);
5236  }
5237  bool VisitUnaryPreDec(const UnaryOperator *UO) {
5238  return VisitUnaryPreIncDec(UO);
5239  }
5240  bool VisitBinAssign(const BinaryOperator *BO);
5241  bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO);
5242 
5243  bool VisitCastExpr(const CastExpr *E) {
5244  switch (E->getCastKind()) {
5245  default:
5246  return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
5247 
5248  case CK_LValueBitCast:
5249  this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5250  if (!Visit(E->getSubExpr()))
5251  return false;
5252  Result.Designator.setInvalid();
5253  return true;
5254 
5255  case CK_BaseToDerived:
5256  if (!Visit(E->getSubExpr()))
5257  return false;
5258  return HandleBaseToDerivedCast(Info, E, Result);
5259  }
5260  }
5261 };
5262 } // end anonymous namespace
5263 
5264 /// Evaluate an expression as an lvalue. This can be legitimately called on
5265 /// expressions which are not glvalues, in three cases:
5266 /// * function designators in C, and
5267 /// * "extern void" objects
5268 /// * @selector() expressions in Objective-C
5269 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
5270  bool InvalidBaseOK) {
5271  assert(E->isGLValue() || E->getType()->isFunctionType() ||
5272  E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E));
5273  return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
5274 }
5275 
5276 bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) {
5277  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(E->getDecl()))
5278  return Success(FD);
5279  if (const VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
5280  return VisitVarDecl(E, VD);
5281  if (const BindingDecl *BD = dyn_cast<BindingDecl>(E->getDecl()))
5282  return Visit(BD->getBinding());
5283  return Error(E);
5284 }
5285 
5286 
5287 bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
5288 
5289  // If we are within a lambda's call operator, check whether the 'VD' referred
5290  // to within 'E' actually represents a lambda-capture that maps to a
5291  // data-member/field within the closure object, and if so, evaluate to the
5292  // field or what the field refers to.
5293  if (Info.CurrentCall && isLambdaCallOperator(Info.CurrentCall->Callee) &&
5294  isa<DeclRefExpr>(E) &&
5295  cast<DeclRefExpr>(E)->refersToEnclosingVariableOrCapture()) {
5296  // We don't always have a complete capture-map when checking or inferring if
5297  // the function call operator meets the requirements of a constexpr function
5298  // - but we don't need to evaluate the captures to determine constexprness
5299  // (dcl.constexpr C++17).
5300  if (Info.checkingPotentialConstantExpression())
5301  return false;
5302 
5303  if (auto *FD = Info.CurrentCall->LambdaCaptureFields.lookup(VD)) {
5304  // Start with 'Result' referring to the complete closure object...
5305  Result = *Info.CurrentCall->This;
5306  // ... then update it to refer to the field of the closure object
5307  // that represents the capture.
5308  if (!HandleLValueMember(Info, E, Result, FD))
5309  return false;
5310  // And if the field is of reference type, update 'Result' to refer to what
5311  // the field refers to.
5312  if (FD->getType()->isReferenceType()) {
5313  APValue RVal;
5314  if (!handleLValueToRValueConversion(Info, E, FD->getType(), Result,
5315  RVal))
5316  return false;
5317  Result.setFrom(Info.Ctx, RVal);
5318  }
5319  return true;
5320  }
5321  }
5322  CallStackFrame *Frame = nullptr;
5323  if (VD->hasLocalStorage() && Info.CurrentCall->Index > 1) {
5324  // Only if a local variable was declared in the function currently being
5325  // evaluated, do we expect to be able to find its value in the current
5326  // frame. (Otherwise it was likely declared in an enclosing context and
5327  // could either have a valid evaluatable value (for e.g. a constexpr
5328  // variable) or be ill-formed (and trigger an appropriate evaluation
5329  // diagnostic)).
5330  if (Info.CurrentCall->Callee &&
5331  Info.CurrentCall->Callee->Equals(VD->getDeclContext())) {
5332  Frame = Info.CurrentCall;
5333  }
5334  }
5335 
5336  if (!VD->getType()->isReferenceType()) {
5337  if (Frame) {
5338  Result.set({VD, Frame->Index,
5339  Info.CurrentCall->getCurrentTemporaryVersion(VD)});
5340  return true;
5341  }
5342  return Success(VD);
5343  }
5344 
5345  APValue *V;
5346  if (!evaluateVarDeclInit(Info, E, VD, Frame, V, nullptr))
5347  return false;
5348  if (V->isUninit()) {
5349  if (!Info.checkingPotentialConstantExpression())
5350  Info.FFDiag(E, diag::note_constexpr_use_uninit_reference);
5351  return false;
5352  }
5353  return Success(*V, E);
5354 }
5355 
5356 bool LValueExprEvaluator::VisitMaterializeTemporaryExpr(
5357  const MaterializeTemporaryExpr *E) {
5358  // Walk through the expression to find the materialized temporary itself.
5359  SmallVector<const Expr *, 2> CommaLHSs;
5361  const Expr *Inner = E->GetTemporaryExpr()->
5362  skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
5363 
5364  // If we passed any comma operators, evaluate their LHSs.
5365  for (unsigned I = 0, N = CommaLHSs.size(); I != N; ++I)
5366  if (!EvaluateIgnoredValue(Info, CommaLHSs[I]))
5367  return false;
5368 
5369  // A materialized temporary with static storage duration can appear within the
5370  // result of a constant expression evaluation, so we need to preserve its
5371  // value for use outside this evaluation.
5372  APValue *Value;
5373  if (E->getStorageDuration() == SD_Static) {
5374  Value = Info.Ctx.getMaterializedTemporaryValue(E, true);
5375  *Value = APValue();
5376  Result.set(E);
5377  } else {
5379  *Info.CurrentCall);
5380  }
5381 
5382  QualType Type = Inner->getType();
5383 
5384  // Materialize the temporary itself.
5385  if (!EvaluateInPlace(*Value, Info, Result, Inner) ||
5386  (E->getStorageDuration() == SD_Static &&
5387  !CheckConstantExpression(Info, E->getExprLoc(), Type, *Value))) {
5388  *Value = APValue();
5389  return false;
5390  }
5391 
5392  // Adjust our lvalue to refer to the desired subobject.
5393  for (unsigned I = Adjustments.size(); I != 0; /**/) {
5394  --I;
5395  switch (Adjustments[I].Kind) {
5397  if (!HandleLValueBasePath(Info, Adjustments[I].DerivedToBase.BasePath,
5398  Type, Result))
5399  return false;
5400  Type = Adjustments[I].DerivedToBase.BasePath->getType();
5401  break;
5402 
5404  if (!HandleLValueMember(Info, E, Result, Adjustments[I].Field))
5405  return false;
5406  Type = Adjustments[I].Field->getType();
5407  break;
5408 
5410  if (!HandleMemberPointerAccess(this->Info, Type, Result,
5411  Adjustments[I].Ptr.RHS))
5412  return false;
5413  Type = Adjustments[I].Ptr.MPT->getPointeeType();
5414  break;
5415  }
5416  }
5417 
5418  return true;
5419 }
5420 
5421 bool
5422 LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
5423  assert((!Info.getLangOpts().CPlusPlus || E->isFileScope()) &&
5424  "lvalue compound literal in c++?");
5425  // Defer visiting the literal until the lvalue-to-rvalue conversion. We can
5426  // only see this when folding in C, so there's no standard to follow here.
5427  return Success(E);
5428 }
5429 
5430 bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
5431  if (!E->isPotentiallyEvaluated())
5432  return Success(E);
5433 
5434  Info.FFDiag(E, diag::note_constexpr_typeid_polymorphic)
5435  << E->getExprOperand()->getType()
5436  << E->getExprOperand()->getSourceRange();
5437  return false;
5438 }
5439 
5440 bool LValueExprEvaluator::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
5441  return Success(E);
5442 }
5443 
5444 bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
5445  // Handle static data members.
5446  if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) {
5447  VisitIgnoredBaseExpression(E->getBase());
5448  return VisitVarDecl(E, VD);
5449  }
5450 
5451  // Handle static member functions.
5452  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) {
5453  if (MD->isStatic()) {
5454  VisitIgnoredBaseExpression(E->getBase());
5455  return Success(MD);
5456  }
5457  }
5458 
5459  // Handle non-static data members.
5460  return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
5461 }
5462 
5463 bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
5464  // FIXME: Deal with vectors as array subscript bases.
5465  if (E->getBase()->getType()->isVectorType())
5466  return Error(E);
5467 
5468  bool Success = true;
5469  if (!evaluatePointer(E->getBase(), Result)) {
5470  if (!Info.noteFailure())
5471  return false;
5472  Success = false;
5473  }
5474 
5475  APSInt Index;
5476  if (!EvaluateInteger(E->getIdx(), Index, Info))
5477  return false;
5478 
5479  return Success &&
5480  HandleLValueArrayAdjustment(Info, E, Result, E->getType(), Index);
5481 }
5482 
5483 bool LValueExprEvaluator::VisitUnaryDeref(const UnaryOperator *E) {
5484  return evaluatePointer(E->getSubExpr(), Result);
5485 }
5486 
5487 bool LValueExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
5488  if (!Visit(E->getSubExpr()))
5489  return false;
5490  // __real is a no-op on scalar lvalues.
5491  if (E->getSubExpr()->getType()->isAnyComplexType())
5492  HandleLValueComplexElement(Info, E, Result, E->getType(), false);
5493  return true;
5494 }
5495 
5496 bool LValueExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
5497  assert(E->getSubExpr()->getType()->isAnyComplexType() &&
5498  "lvalue __imag__ on scalar?");
5499  if (!Visit(E->getSubExpr()))
5500  return false;
5501  HandleLValueComplexElement(Info, E, Result, E->getType(), true);
5502  return true;
5503 }
5504 
5505 bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) {
5506  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5507  return Error(UO);
5508 
5509  if (!this->Visit(UO->getSubExpr()))
5510  return false;
5511 
5512  return handleIncDec(
5513  this->Info, UO, Result, UO->getSubExpr()->getType(),
5514  UO->isIncrementOp(), nullptr);
5515 }
5516 
5517 bool LValueExprEvaluator::VisitCompoundAssignOperator(
5518  const CompoundAssignOperator *CAO) {
5519  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5520  return Error(CAO);
5521 
5522  APValue RHS;
5523 
5524  // The overall lvalue result is the result of evaluating the LHS.
5525  if (!this->Visit(CAO->getLHS())) {
5526  if (Info.noteFailure())
5527  Evaluate(RHS, this->Info, CAO->getRHS());
5528  return false;
5529  }
5530 
5531  if (!Evaluate(RHS, this->Info, CAO->getRHS()))
5532  return false;
5533 
5534  return handleCompoundAssignment(
5535  this->Info, CAO,
5536  Result, CAO->getLHS()->getType(), CAO->getComputationLHSType(),
5537  CAO->getOpForCompoundAssignment(CAO->getOpcode()), RHS);
5538 }
5539 
5540 bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) {
5541  if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5542  return Error(E);
5543 
5544  APValue NewVal;
5545 
5546  if (!this->Visit(E->getLHS())) {
5547  if (Info.noteFailure())
5548  Evaluate(NewVal, this->Info, E->getRHS());
5549  return false;
5550  }
5551 
5552  if (!Evaluate(NewVal, this->Info, E->getRHS()))
5553  return false;
5554 
5555  return handleAssignment(this->Info, E, Result, E->getLHS()->getType(),
5556  NewVal);
5557 }
5558 
5559 //===----------------------------------------------------------------------===//
5560 // Pointer Evaluation
5561 //===----------------------------------------------------------------------===//
5562 
5563 /// Attempts to compute the number of bytes available at the pointer
5564 /// returned by a function with the alloc_size attribute. Returns true if we
5565 /// were successful. Places an unsigned number into `Result`.
5566 ///
5567 /// This expects the given CallExpr to be a call to a function with an
5568 /// alloc_size attribute.
5570  const CallExpr *Call,
5571  llvm::APInt &Result) {
5572  const AllocSizeAttr *AllocSize = getAllocSizeAttr(Call);
5573 
5574  assert(AllocSize && AllocSize->getElemSizeParam().isValid());
5575  unsigned SizeArgNo = AllocSize->getElemSizeParam().getASTIndex();
5576  unsigned BitsInSizeT = Ctx.getTypeSize(Ctx.getSizeType());
5577  if (Call->getNumArgs() <= SizeArgNo)
5578  return false;
5579 
5580  auto EvaluateAsSizeT = [&](const Expr *E, APSInt &Into) {
5581  if (!E->EvaluateAsInt(Into, Ctx, Expr::SE_AllowSideEffects))
5582  return false;
5583  if (Into.isNegative() || !Into.isIntN(BitsInSizeT))
5584  return false;
5585  Into = Into.zextOrSelf(BitsInSizeT);
5586  return true;
5587  };
5588 
5589  APSInt SizeOfElem;
5590  if (!EvaluateAsSizeT(Call->getArg(SizeArgNo), SizeOfElem))
5591  return false;
5592 
5593  if (!AllocSize->getNumElemsParam().isValid()) {
5594  Result = std::move(SizeOfElem);
5595  return true;
5596  }
5597 
5598  APSInt NumberOfElems;
5599  unsigned NumArgNo = AllocSize->getNumElemsParam().getASTIndex();
5600  if (!EvaluateAsSizeT(Call->getArg(NumArgNo), NumberOfElems))
5601  return false;
5602 
5603  bool Overflow;
5604  llvm::APInt BytesAvailable = SizeOfElem.umul_ov(NumberOfElems, Overflow);
5605  if (Overflow)
5606  return false;
5607 
5608  Result = std::move(BytesAvailable);
5609  return true;
5610 }
5611 
5612 /// Convenience function. LVal's base must be a call to an alloc_size
5613 /// function.
5615  const LValue &LVal,
5616  llvm::APInt &Result) {
5617  assert(isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
5618  "Can't get the size of a non alloc_size function");
5619  const auto *Base = LVal.getLValueBase().get<const Expr *>();
5620  const CallExpr *CE = tryUnwrapAllocSizeCall(Base);
5621  return getBytesReturnedByAllocSizeCall(Ctx, CE, Result);
5622 }
5623 
5624 /// Attempts to evaluate the given LValueBase as the result of a call to
5625 /// a function with the alloc_size attribute. If it was possible to do so, this
5626 /// function will return true, make Result's Base point to said function call,
5627 /// and mark Result's Base as invalid.
5628 static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base,
5629  LValue &Result) {
5630  if (Base.isNull())
5631  return false;
5632 
5633  // Because we do no form of static analysis, we only support const variables.
5634  //
5635  // Additionally, we can't support parameters, nor can we support static
5636  // variables (in the latter case, use-before-assign isn't UB; in the former,
5637  // we have no clue what they'll be assigned to).
5638  const auto *VD =
5639  dyn_cast_or_null<VarDecl>(Base.dyn_cast<const ValueDecl *>());
5640  if (!VD || !VD->isLocalVarDecl() || !VD->getType().isConstQualified())
5641  return false;
5642 
5643  const Expr *Init = VD->getAnyInitializer();
5644  if (!Init)
5645  return false;
5646 
5647  const Expr *E = Init->IgnoreParens();
5648  if (!tryUnwrapAllocSizeCall(E))
5649  return false;
5650 
5651  // Store E instead of E unwrapped so that the type of the LValue's base is
5652  // what the user wanted.
5653  Result.setInvalid(E);
5654 
5655  QualType Pointee = E->getType()->castAs<PointerType>()->getPointeeType();
5656  Result.addUnsizedArray(Info, E, Pointee);
5657  return true;
5658 }
5659 
5660 namespace {
5661 class PointerExprEvaluator
5662  : public ExprEvaluatorBase<PointerExprEvaluator> {
5663  LValue &Result;
5664  bool InvalidBaseOK;
5665 
5666  bool Success(const Expr *E) {
5667  Result.set(E);
5668  return true;
5669  }
5670 
5671  bool evaluateLValue(const Expr *E, LValue &Result) {
5672  return EvaluateLValue(E, Result, Info, InvalidBaseOK);
5673  }
5674 
5675  bool evaluatePointer(const Expr *E, LValue &Result) {
5676  return EvaluatePointer(E, Result, Info, InvalidBaseOK);
5677  }
5678 
5679  bool visitNonBuiltinCallExpr(const CallExpr *E);
5680 public:
5681 
5682  PointerExprEvaluator(EvalInfo &info, LValue &Result, bool InvalidBaseOK)
5683  : ExprEvaluatorBaseTy(info), Result(Result),
5684  InvalidBaseOK(InvalidBaseOK) {}
5685 
5686  bool Success(const APValue &V, const Expr *E) {
5687  Result.setFrom(Info.Ctx, V);
5688  return true;
5689  }
5690  bool ZeroInitialization(const Expr *E) {
5691  auto TargetVal = Info.Ctx.getTargetNullPointerValue(E->getType());
5692  Result.setNull(E->getType(), TargetVal);
5693  return true;
5694  }
5695 
5696  bool VisitBinaryOperator(const BinaryOperator *E);
5697  bool VisitCastExpr(const CastExpr* E);
5698  bool VisitUnaryAddrOf(const UnaryOperator *E);
5699  bool VisitObjCStringLiteral(const ObjCStringLiteral *E)
5700  { return Success(E); }
5701  bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
5702  if (Info.noteFailure())
5703  EvaluateIgnoredValue(Info, E->getSubExpr());
5704  return Error(E);
5705  }
5706  bool VisitAddrLabelExpr(const AddrLabelExpr *E)
5707  { return Success(E); }
5708  bool VisitCallExpr(const CallExpr *E);
5709  bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
5710  bool VisitBlockExpr(const BlockExpr *E) {
5711  if (!E->getBlockDecl()->hasCaptures())
5712  return Success(E);
5713  return Error(E);
5714  }
5715  bool VisitCXXThisExpr(const CXXThisExpr *E) {
5716  // Can't look at 'this' when checking a potential constant expression.
5717  if (Info.checkingPotentialConstantExpression())
5718  return false;
5719  if (!Info.CurrentCall->This) {
5720  if (Info.getLangOpts().CPlusPlus11)
5721  Info.FFDiag(E, diag::note_constexpr_this) << E->isImplicit();
5722  else
5723  Info.FFDiag(E);
5724  return false;
5725  }
5726  Result = *Info.CurrentCall->This;
5727  // If we are inside a lambda's call operator, the 'this' expression refers
5728  // to the enclosing '*this' object (either by value or reference) which is
5729  // either copied into the closure object's field that represents the '*this'
5730  // or refers to '*this'.
5731  if (isLambdaCallOperator(Info.CurrentCall->Callee)) {
5732  // Update 'Result' to refer to the data member/field of the closure object
5733  // that represents the '*this' capture.
5734  if (!HandleLValueMember(Info, E, Result,
5735  Info.CurrentCall->LambdaThisCaptureField))
5736  return false;
5737  // If we captured '*this' by reference, replace the field with its referent.
5738  if (Info.CurrentCall->LambdaThisCaptureField->getType()
5739  ->isPointerType()) {
5740  APValue RVal;
5741  if (!handleLValueToRValueConversion(Info, E, E->getType(), Result,
5742  RVal))
5743  return false;
5744 
5745  Result.setFrom(Info.Ctx, RVal);
5746  }
5747  }
5748  return true;
5749  }
5750 
5751  // FIXME: Missing: @protocol, @selector
5752 };
5753 } // end anonymous namespace
5754 
5755 static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
5756  bool InvalidBaseOK) {
5757  assert(E->isRValue() && E->getType()->hasPointerRepresentation());
5758  return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
5759 }
5760 
5761 bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
5762  if (E->getOpcode() != BO_Add &&
5763  E->getOpcode() != BO_Sub)
5764  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
5765 
5766  const Expr *PExp = E->getLHS();
5767  const Expr *IExp = E->getRHS();
5768  if (IExp->getType()->isPointerType())
5769  std::swap(PExp, IExp);
5770 
5771  bool EvalPtrOK = evaluatePointer(PExp, Result);
5772  if (!EvalPtrOK && !Info.noteFailure())
5773  return false;
5774 
5775  llvm::APSInt Offset;
5776  if (!EvaluateInteger(IExp, Offset, Info) || !EvalPtrOK)
5777  return false;
5778 
5779  if (E->getOpcode() == BO_Sub)
5780  negateAsSigned(Offset);
5781 
5782  QualType Pointee = PExp->getType()->castAs<PointerType>()->getPointeeType();
5783  return HandleLValueArrayAdjustment(Info, E, Result, Pointee, Offset);
5784 }
5785 
5786 bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
5787  return evaluateLValue(E->getSubExpr(), Result);
5788 }
5789 
5790 bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
5791  const Expr *SubExpr = E->getSubExpr();
5792 
5793  switch (E->getCastKind()) {
5794  default:
5795  break;
5796 
5797  case CK_BitCast:
5798  case CK_CPointerToObjCPointerCast:
5799  case CK_BlockPointerToObjCPointerCast:
5800  case CK_AnyPointerToBlockPointerCast:
5801  case CK_AddressSpaceConversion:
5802  if (!Visit(SubExpr))
5803  return false;
5804  // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are
5805  // permitted in constant expressions in C++11. Bitcasts from cv void* are
5806  // also static_casts, but we disallow them as a resolution to DR1312.
5807  if (!E->getType()->isVoidPointerType()) {
5808  // If we changed anything other than cvr-qualifiers, we can't use this
5809  // value for constant folding. FIXME: Qualification conversions should
5810  // always be CK_NoOp, but we get this wrong in C.
5811  if (!Info.Ctx.hasCvrSimilarType(E->getType(), E->getSubExpr()->getType()))
5812  Result.Designator.setInvalid();
5813  if (SubExpr->getType()->isVoidPointerType())
5814  CCEDiag(E, diag::note_constexpr_invalid_cast)
5815  << 3 << SubExpr->getType();
5816  else
5817  CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5818  }
5819  if (E->getCastKind() == CK_AddressSpaceConversion && Result.IsNullPtr)
5820  ZeroInitialization(E);
5821  return true;
5822 
5823  case CK_DerivedToBase:
5824  case CK_UncheckedDerivedToBase:
5825  if (!evaluatePointer(E->getSubExpr(), Result))
5826  return false;
5827  if (!Result.Base && Result.Offset.isZero())
5828  return true;
5829 
5830  // Now figure out the necessary offset to add to the base LV to get from
5831  // the derived class to the base class.
5832  return HandleLValueBasePath(Info, E, E->getSubExpr()->getType()->
5833  castAs<PointerType>()->getPointeeType(),
5834  Result);
5835 
5836  case CK_BaseToDerived:
5837  if (!Visit(E->getSubExpr()))
5838  return false;
5839  if (!Result.Base && Result.Offset.isZero())
5840  return true;
5841  return HandleBaseToDerivedCast(Info, E, Result);
5842 
5843  case CK_NullToPointer:
5844  VisitIgnoredValue(E->getSubExpr());
5845  return ZeroInitialization(E);
5846 
5847  case CK_IntegralToPointer: {
5848  CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5849 
5850  APValue Value;
5851  if (!EvaluateIntegerOrLValue(SubExpr, Value, Info))
5852  break;
5853 
5854  if (Value.isInt()) {
5855  unsigned Size = Info.Ctx.getTypeSize(E->getType());
5856  uint64_t N = Value.getInt().extOrTrunc(Size).getZExtValue();
5857  Result.Base = (Expr*)nullptr;
5858  Result.InvalidBase = false;
5859  Result.Offset = CharUnits::fromQuantity(N);
5860  Result.Designator.setInvalid();
5861  Result.IsNullPtr = false;
5862  return true;
5863  } else {
5864  // Cast is of an lvalue, no need to change value.
5865  Result.setFrom(Info.Ctx, Value);
5866  return true;
5867  }
5868  }
5869 
5870  case CK_ArrayToPointerDecay: {
5871  if (SubExpr->isGLValue()) {
5872  if (!evaluateLValue(SubExpr, Result))
5873  return false;
5874  } else {
5875  APValue &Value = createTemporary(SubExpr, false, Result,
5876  *Info.CurrentCall);
5877  if (!EvaluateInPlace(Value, Info, Result, SubExpr))
5878  return false;
5879  }
5880  // The result is a pointer to the first element of the array.
5881  auto *AT = Info.Ctx.getAsArrayType(SubExpr->getType());
5882  if (auto *CAT = dyn_cast<ConstantArrayType>(AT))
5883  Result.addArray(Info, E, CAT);
5884  else
5885  Result.addUnsizedArray(Info, E, AT->getElementType());
5886  return true;
5887  }
5888 
5889  case CK_FunctionToPointerDecay:
5890  return evaluateLValue(SubExpr, Result);
5891 
5892  case CK_LValueToRValue: {
5893  LValue LVal;
5894  if (!evaluateLValue(E->getSubExpr(), LVal))
5895  return false;
5896 
5897  APValue RVal;
5898  // Note, we use the subexpression's type in order to retain cv-qualifiers.
5899  if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
5900  LVal, RVal))
5901  return InvalidBaseOK &&
5902  evaluateLValueAsAllocSize(Info, LVal.Base, Result);
5903  return Success(RVal, E);
5904  }
5905  }
5906 
5907  return ExprEvaluatorBaseTy::VisitCastExpr(E);
5908 }
5909 
5910 static CharUnits GetAlignOfType(EvalInfo &Info, QualType T) {
5911  // C++ [expr.alignof]p3:
5912  // When alignof is applied to a reference type, the result is the
5913  // alignment of the referenced type.
5914  if (const ReferenceType *Ref = T->getAs<ReferenceType>())
5915  T = Ref->getPointeeType();
5916 
5917  // __alignof is defined to return the preferred alignment.
5918  if (T.getQualifiers().hasUnaligned())
5919  return CharUnits::One();
5920  return Info.Ctx.toCharUnitsFromBits(
5921  Info.Ctx.getPreferredTypeAlign(T.getTypePtr()));
5922 }
5923 
5924 static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E) {
5925  E = E->IgnoreParens();
5926 
5927  // The kinds of expressions that we have special-case logic here for
5928  // should be kept up to date with the special checks for those
5929  // expressions in Sema.
5930 
5931  // alignof decl is always accepted, even if it doesn't make sense: we default
5932  // to 1 in those cases.
5933  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
5934  return Info.Ctx.getDeclAlign(DRE->getDecl(),
5935  /*RefAsPointee*/true);
5936 
5937  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
5938  return Info.Ctx.getDeclAlign(ME->getMemberDecl(),
5939  /*RefAsPointee*/true);
5940 
5941  return GetAlignOfType(Info, E->getType());
5942 }
5943 
5944 // To be clear: this happily visits unsupported builtins. Better name welcomed.
5945 bool PointerExprEvaluator::visitNonBuiltinCallExpr(const CallExpr *E) {
5946  if (ExprEvaluatorBaseTy::VisitCallExpr(E))
5947  return true;
5948 
5949  if (!(InvalidBaseOK && getAllocSizeAttr(E)))
5950  return false;
5951 
5952  Result.setInvalid(E);
5953  QualType PointeeTy = E->getType()->castAs<PointerType>()->getPointeeType();
5954  Result.addUnsizedArray(Info, E, PointeeTy);
5955  return true;
5956 }
5957 
5958 bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) {
5959  if (IsStringLiteralCall(E))
5960  return Success(E);
5961 
5962  if (unsigned BuiltinOp = E->getBuiltinCallee())
5963  return VisitBuiltinCallExpr(E, BuiltinOp);
5964 
5965  return visitNonBuiltinCallExpr(E);
5966 }
5967 
5968 bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
5969  unsigned BuiltinOp) {
5970  switch (BuiltinOp) {
5971  case Builtin::BI__builtin_addressof:
5972  return evaluateLValue(E->getArg(0), Result);
5973  case Builtin::BI__builtin_assume_aligned: {
5974  // We need to be very careful here because: if the pointer does not have the
5975  // asserted alignment, then the behavior is undefined, and undefined
5976  // behavior is non-constant.
5977  if (!evaluatePointer(E->getArg(0), Result))
5978  return false;
5979 
5980  LValue OffsetResult(Result);
5981  APSInt Alignment;
5982  if (!EvaluateInteger(E->getArg(1), Alignment, Info))
5983  return false;
5984  CharUnits Align = CharUnits::fromQuantity(Alignment.getZExtValue());
5985 
5986  if (E->getNumArgs() > 2) {
5987  APSInt Offset;
5988  if (!EvaluateInteger(E->getArg(2), Offset, Info))
5989  return false;
5990 
5991  int64_t AdditionalOffset = -Offset.getZExtValue();
5992  OffsetResult.Offset += CharUnits::fromQuantity(AdditionalOffset);
5993  }
5994 
5995  // If there is a base object, then it must have the correct alignment.
5996  if (OffsetResult.Base) {
5997  CharUnits BaseAlignment;
5998  if (const ValueDecl *VD =
5999  OffsetResult.Base.dyn_cast<const ValueDecl*>()) {
6000  BaseAlignment = Info.Ctx.getDeclAlign(VD);
6001  } else {
6002  BaseAlignment =
6003  GetAlignOfExpr(Info, OffsetResult.Base.get<const Expr*>());
6004  }
6005 
6006  if (BaseAlignment < Align) {
6007  Result.Designator.setInvalid();
6008  // FIXME: Add support to Diagnostic for long / long long.
6009  CCEDiag(E->getArg(0),
6010  diag::note_constexpr_baa_insufficient_alignment) << 0
6011  << (unsigned)BaseAlignment.getQuantity()
6012  << (unsigned)Align.getQuantity();
6013  return false;
6014  }
6015  }
6016 
6017  // The offset must also have the correct alignment.
6018  if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) {
6019  Result.Designator.setInvalid();
6020 
6021  (OffsetResult.Base
6022  ? CCEDiag(E->getArg(0),
6023  diag::note_constexpr_baa_insufficient_alignment) << 1
6024  : CCEDiag(E->getArg(0),
6025  diag::note_constexpr_baa_value_insufficient_alignment))
6026  << (int)OffsetResult.Offset.getQuantity()
6027  << (unsigned)Align.getQuantity();
6028  return false;
6029  }
6030 
6031  return true;
6032  }
6033 
6034  case Builtin::BIstrchr:
6035  case Builtin::BIwcschr:
6036  case Builtin::BImemchr:
6037  case Builtin::BIwmemchr:
6038  if (Info.getLangOpts().CPlusPlus11)
6039  Info.CCEDiag(E, diag::note_constexpr_invalid_function)
6040  << /*isConstexpr*/0 << /*isConstructor*/0
6041  << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
6042  else
6043  Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
6044  LLVM_FALLTHROUGH;
6045  case Builtin::BI__builtin_strchr:
6046  case Builtin::BI__builtin_wcschr:
6047  case Builtin::BI__builtin_memchr:
6048  case Builtin::BI__builtin_char_memchr:
6049  case Builtin::BI__builtin_wmemchr: {
6050  if (!Visit(E->getArg(0)))
6051  return false;
6052  APSInt Desired;
6053  if (!EvaluateInteger(E->getArg(1), Desired, Info))
6054  return false;
6055  uint64_t MaxLength = uint64_t(-1);
6056  if (BuiltinOp != Builtin::BIstrchr &&
6057  BuiltinOp != Builtin::BIwcschr &&
6058  BuiltinOp != Builtin::BI__builtin_strchr &&
6059  BuiltinOp != Builtin::BI__builtin_wcschr) {
6060  APSInt N;
6061  if (!EvaluateInteger(E->getArg(2), N, Info))
6062  return false;
6063  MaxLength = N.getExtValue();
6064  }
6065 
6066  QualType CharTy = E->getArg(0)->getType()->getPointeeType();
6067 
6068  // Figure out what value we're actually looking for (after converting to
6069  // the corresponding unsigned type if necessary).
6070  uint64_t DesiredVal;
6071  bool StopAtNull = false;
6072  switch (BuiltinOp) {
6073  case Builtin::BIstrchr:
6074  case Builtin::BI__builtin_strchr:
6075  // strchr compares directly to the passed integer, and therefore
6076  // always fails if given an int that is not a char.
6077  if (!APSInt::isSameValue(HandleIntToIntCast(Info, E, CharTy,
6078  E->getArg(1)->getType(),
6079  Desired),
6080  Desired))
6081  return ZeroInitialization(E);
6082  StopAtNull = true;
6083  LLVM_FALLTHROUGH;
6084  case Builtin::BImemchr:
6085  case Builtin::BI__builtin_memchr:
6086  case Builtin::BI__builtin_char_memchr:
6087  // memchr compares by converting both sides to unsigned char. That's also
6088  // correct for strchr if we get this far (to cope with plain char being
6089  // unsigned in the strchr case).
6090  DesiredVal = Desired.trunc(Info.Ctx.getCharWidth()).getZExtValue();
6091  break;
6092 
6093  case Builtin::BIwcschr:
6094  case Builtin::BI__builtin_wcschr:
6095  StopAtNull = true;
6096  LLVM_FALLTHROUGH;
6097  case Builtin::BIwmemchr:
6098  case Builtin::BI__builtin_wmemchr:
6099  // wcschr and wmemchr are given a wchar_t to look for. Just use it.
6100  DesiredVal = Desired.getZExtValue();
6101  break;
6102  }
6103 
6104  for (; MaxLength; --MaxLength) {
6105  APValue Char;
6106  if (!handleLValueToRValueConversion(Info, E, CharTy, Result, Char) ||
6107  !Char.isInt())
6108  return false;
6109  if (Char.getInt().getZExtValue() == DesiredVal)
6110  return true;
6111  if (StopAtNull && !Char.getInt())
6112  break;
6113  if (!HandleLValueArrayAdjustment(Info, E, Result, CharTy, 1))
6114  return false;
6115  }
6116  // Not found: return nullptr.
6117  return ZeroInitialization(E);
6118  }
6119 
6120  default:
6121  return visitNonBuiltinCallExpr(E);
6122  }
6123 }
6124 
6125 //===----------------------------------------------------------------------===//
6126 // Member Pointer Evaluation
6127 //===----------------------------------------------------------------------===//
6128 
6129 namespace {
6130 class MemberPointerExprEvaluator
6131  : public ExprEvaluatorBase<MemberPointerExprEvaluator> {
6132  MemberPtr &Result;
6133 
6134  bool Success(const ValueDecl *D) {
6135  Result = MemberPtr(D);
6136  return true;
6137  }
6138 public:
6139 
6140  MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result)
6141  : ExprEvaluatorBaseTy(Info), Result(Result) {}
6142 
6143  bool Success(const APValue &V, const Expr *E) {
6144  Result.setFrom(V);
6145  return true;
6146  }
6147  bool ZeroInitialization(const Expr *E) {
6148  return Success((const ValueDecl*)nullptr);
6149  }
6150 
6151  bool VisitCastExpr(const CastExpr *E);
6152  bool VisitUnaryAddrOf(const UnaryOperator *E);
6153 };
6154 } // end anonymous namespace
6155 
6156 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
6157  EvalInfo &Info) {
6158  assert(E->isRValue() && E->getType()->isMemberPointerType());
6159  return MemberPointerExprEvaluator(Info, Result).Visit(E);
6160 }
6161 
6162 bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
6163  switch (E->getCastKind()) {
6164  default:
6165  return ExprEvaluatorBaseTy::VisitCastExpr(E);
6166 
6167  case CK_NullToMemberPointer:
6168  VisitIgnoredValue(E->getSubExpr());
6169  return ZeroInitialization(E);
6170 
6171  case CK_BaseToDerivedMemberPointer: {
6172  if (!Visit(E->getSubExpr()))
6173  return false;
6174  if (E->path_empty())
6175  return true;
6176  // Base-to-derived member pointer casts store the path in derived-to-base
6177  // order, so iterate backwards. The CXXBaseSpecifier also provides us with
6178  // the wrong end of the derived->base arc, so stagger the path by one class.
6179  typedef std::reverse_iterator<CastExpr::path_const_iterator> ReverseIter;
6180  for (ReverseIter PathI(E->path_end() - 1), PathE(E->path_begin());
6181  PathI != PathE; ++PathI) {
6182  assert(!(*PathI)->isVirtual() && "memptr cast through vbase");
6183  const CXXRecordDecl *Derived = (*PathI)->getType()->getAsCXXRecordDecl();
6184  if (!Result.castToDerived(Derived))
6185  return Error(E);
6186  }
6187  const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass();
6188  if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl()))
6189  return Error(E);
6190  return true;
6191  }
6192 
6193  case CK_DerivedToBaseMemberPointer:
6194  if (!Visit(E->getSubExpr()))
6195  return false;
6196  for (CastExpr::path_const_iterator PathI = E->path_begin(),
6197  PathE = E->path_end(); PathI != PathE; ++PathI) {
6198  assert(!(*PathI)->isVirtual() && "memptr cast through vbase");
6199  const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
6200  if (!Result.castToBase(Base))
6201  return Error(E);
6202  }
6203  return true;
6204  }
6205 }
6206 
6207 bool MemberPointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
6208  // C++11 [expr.unary.op]p3 has very strict rules on how the address of a
6209  // member can be formed.
6210  return Success(cast<DeclRefExpr>(E->getSubExpr())->getDecl());
6211 }
6212 
6213 //===----------------------------------------------------------------------===//
6214 // Record Evaluation
6215 //===----------------------------------------------------------------------===//
6216 
6217 namespace {
6218  class RecordExprEvaluator
6219  : public ExprEvaluatorBase<RecordExprEvaluator> {
6220  const LValue &This;
6221  APValue &Result;
6222  public:
6223 
6224  RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result)
6225  : ExprEvaluatorBaseTy(info), This(This), Result(Result) {}
6226 
6227  bool Success(const APValue &V, const Expr *E) {
6228  Result = V;
6229  return true;
6230  }
6231  bool ZeroInitialization(const Expr *E) {
6232  return ZeroInitialization(E, E->getType());
6233  }
6234  bool ZeroInitialization(const Expr *E, QualType T);
6235 
6236  bool VisitCallExpr(const CallExpr *E) {
6237  return handleCallExpr(E, Result, &This);
6238  }
6239  bool VisitCastExpr(const CastExpr *E);
6240  bool VisitInitListExpr(const InitListExpr *E);
6241  bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
6242  return VisitCXXConstructExpr(E, E->getType());
6243  }
6244  bool VisitLambdaExpr(const LambdaExpr *E);
6245  bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
6246  bool VisitCXXConstructExpr(const CXXConstructExpr *E, QualType T);
6247  bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E);
6248 
6249  bool VisitBinCmp(const BinaryOperator *E);
6250  };
6251 }
6252 
6253 /// Perform zero-initialization on an object of non-union class type.
6254 /// C++11 [dcl.init]p5:
6255 /// To zero-initialize an object or reference of type T means:
6256 /// [...]
6257 /// -- if T is a (possibly cv-qualified) non-union class type,
6258 /// each non-static data member and each base-class subobject is
6259 /// zero-initialized
6260 static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E,
6261  const RecordDecl *RD,
6262  const LValue &This, APValue &Result) {
6263  assert(!RD->isUnion() && "Expected non-union class type");
6264  const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
6265  Result = APValue(APValue::UninitStruct(), CD ? CD->getNumBases() : 0,
6266  std::distance(RD->field_begin(), RD->field_end()));
6267 
6268  if (RD->isInvalidDecl()) return false;
6269  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6270 
6271  if (CD) {
6272  unsigned Index = 0;
6273  for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(),
6274  End = CD->bases_end(); I != End; ++I, ++Index) {
6275  const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl();
6276  LValue Subobject = This;
6277  if (!HandleLValueDirectBase(Info, E, Subobject, CD, Base, &Layout))
6278  return false;
6279  if (!HandleClassZeroInitialization(Info, E, Base, Subobject,
6280  Result.getStructBase(Index)))
6281  return false;
6282  }
6283  }
6284 
6285  for (const auto *I : RD->fields()) {
6286  // -- if T is a reference type, no initialization is performed.
6287  if (I->getType()->isReferenceType())
6288  continue;
6289 
6290  LValue Subobject = This;
6291  if (!HandleLValueMember(Info, E, Subobject, I, &Layout))
6292  return false;
6293 
6294  ImplicitValueInitExpr VIE(I->getType());
6295  if (!EvaluateInPlace(
6296  Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE))
6297  return false;
6298  }
6299 
6300  return true;
6301 }
6302 
6303 bool RecordExprEvaluator::ZeroInitialization(const Expr *E, QualType T) {
6304  const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
6305  if (RD->isInvalidDecl()) return false;
6306  if (RD->isUnion()) {
6307  // C++11 [dcl.init]p5: If T is a (possibly cv-qualified) union type, the
6308  // object's first non-static named data member is zero-initialized
6310  if (I == RD->field_end()) {
6311  Result = APValue((const FieldDecl*)nullptr);
6312  return true;
6313  }
6314 
6315  LValue Subobject = This;
6316  if (!HandleLValueMember(Info, E, Subobject, *I))
6317  return false;
6318  Result = APValue(*I);
6319  ImplicitValueInitExpr VIE(I->getType());
6320  return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE);
6321  }
6322 
6323  if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->getNumVBases()) {
6324  Info.FFDiag(E, diag::note_constexpr_virtual_base) << RD;
6325  return false;
6326  }
6327 
6328  return HandleClassZeroInitialization(Info, E, RD, This, Result);
6329 }
6330 
6331 bool RecordExprEvaluator::VisitCastExpr(const CastExpr *E) {
6332  switch (E->getCastKind()) {
6333  default:
6334  return ExprEvaluatorBaseTy::VisitCastExpr(E);
6335 
6336  case CK_ConstructorConversion:
6337  return Visit(E->getSubExpr());
6338 
6339  case CK_DerivedToBase:
6340  case CK_UncheckedDerivedToBase: {
6341  APValue DerivedObject;
6342  if (!Evaluate(DerivedObject, Info, E->getSubExpr()))
6343  return false;
6344  if (!DerivedObject.isStruct())
6345  return Error(E->getSubExpr());
6346 
6347  // Derived-to-base rvalue conversion: just slice off the derived part.
6348  APValue *Value = &DerivedObject;
6349  const CXXRecordDecl *RD = E->getSubExpr()->getType()->getAsCXXRecordDecl();
6350  for (CastExpr::path_const_iterator PathI = E->path_begin(),
6351  PathE = E->path_end(); PathI != PathE; ++PathI) {
6352  assert(!(*PathI)->isVirtual() && "record rvalue with virtual base");
6353  const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
6354  Value = &Value->getStructBase(getBaseIndex(RD, Base));
6355  RD = Base;
6356  }
6357  Result = *Value;
6358  return true;
6359  }
6360  }
6361 }
6362 
6363 bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
6364  if (E->isTransparent())
6365  return Visit(E->getInit(0));
6366 
6367  const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl();
6368  if (RD->isInvalidDecl()) return false;
6369  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6370 
6371  if (RD->isUnion()) {
6372  const FieldDecl *Field = E->getInitializedFieldInUnion();
6373  Result = APValue(Field);
6374  if (!Field)
6375  return true;
6376 
6377  // If the initializer list for a union does not contain any elements, the
6378  // first element of the union is value-initialized.
6379  // FIXME: The element should be initialized from an initializer list.
6380  // Is this difference ever observable for initializer lists which
6381  // we don't build?
6382  ImplicitValueInitExpr VIE(Field->getType());
6383  const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE;
6384 
6385  LValue Subobject = This;
6386  if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout))
6387  return false;
6388 
6389  // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
6390  ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
6391  isa<CXXDefaultInitExpr>(InitExpr));
6392 
6393  return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr);
6394  }
6395 
6396  auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
6397  if (Result.isUninit())
6398  Result = APValue(APValue::UninitStruct(), CXXRD ? CXXRD->getNumBases() : 0,
6399  std::distance(RD->field_begin(), RD->field_end()));
6400  unsigned ElementNo = 0;
6401  bool Success = true;
6402 
6403  // Initialize base classes.
6404  if (CXXRD) {
6405  for (const auto &Base : CXXRD->bases()) {
6406  assert(ElementNo < E->getNumInits() && "missing init for base class");
6407  const Expr *Init = E->getInit(ElementNo);
6408 
6409  LValue Subobject = This;
6410  if (!HandleLValueBase(Info, Init, Subobject, CXXRD, &Base))
6411  return false;
6412 
6413  APValue &FieldVal = Result.getStructBase(ElementNo);
6414  if (!EvaluateInPlace(FieldVal, Info, Subobject, Init)) {
6415  if (!Info.noteFailure())
6416  return false;
6417  Success = false;
6418  }
6419  ++ElementNo;
6420  }
6421  }
6422 
6423  // Initialize members.
6424  for (const auto *Field : RD->fields()) {
6425  // Anonymous bit-fields are not considered members of the class for
6426  // purposes of aggregate initialization.
6427  if (Field->isUnnamedBitfield())
6428  continue;
6429 
6430  LValue Subobject = This;
6431 
6432  bool HaveInit = ElementNo < E->getNumInits();
6433 
6434  // FIXME: Diagnostics here should point to the end of the initializer
6435  // list, not the start.
6436  if (!HandleLValueMember(Info, HaveInit ? E->getInit(ElementNo) : E,
6437  Subobject, Field, &Layout))
6438  return false;
6439 
6440  // Perform an implicit value-initialization for members beyond the end of
6441  // the initializer list.
6442  ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType());
6443  const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE;
6444 
6445  // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
6446  ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
6447  isa<CXXDefaultInitExpr>(Init));
6448 
6449  APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
6450  if (!EvaluateInPlace(FieldVal, Info, Subobject, Init) ||
6451  (Field->isBitField() && !truncateBitfieldValue(Info, Init,
6452  FieldVal, Field))) {
6453  if (!Info.noteFailure())
6454  return false;
6455  Success = false;
6456  }
6457  }
6458 
6459  return Success;
6460 }
6461 
6462 bool RecordExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
6463  QualType T) {
6464  // Note that E's type is not necessarily the type of our class here; we might
6465  // be initializing an array element instead.
6466  const CXXConstructorDecl *FD = E->getConstructor();
6467  if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl()) return false;
6468 
6469  bool ZeroInit = E->requiresZeroInitialization();
6470  if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) {
6471  // If we've already performed zero-initialization, we're already done.
6472  if (!Result.isUninit())
6473  return true;
6474 
6475  // We can get here in two different ways:
6476  // 1) We're performing value-initialization, and should zero-initialize
6477  // the object, or
6478  // 2) We're performing default-initialization of an object with a trivial
6479  // constexpr default constructor, in which case we should start the
6480  // lifetimes of all the base subobjects (there can be no data member
6481  // subobjects in this case) per [basic.life]p1.
6482  // Either way, ZeroInitialization is appropriate.
6483  return ZeroInitialization(E, T);
6484  }
6485 
6486  const FunctionDecl *Definition = nullptr;
6487  auto Body = FD->getBody(Definition);
6488 
6489  if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
6490  return false;
6491 
6492  // Avoid materializing a temporary for an elidable copy/move constructor.
6493  if (E->isElidable() && !ZeroInit)
6494  if (const MaterializeTemporaryExpr *ME
6495  = dyn_cast<MaterializeTemporaryExpr>(E->getArg(0)))
6496  return Visit(ME->GetTemporaryExpr());
6497 
6498  if (ZeroInit && !ZeroInitialization(E, T))
6499  return false;
6500 
6501  auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
6502  return HandleConstructorCall(E, This, Args,
6503  cast<CXXConstructorDecl>(Definition), Info,
6504  Result);
6505 }
6506 
6507 bool RecordExprEvaluator::VisitCXXInheritedCtorInitExpr(
6508  const CXXInheritedCtorInitExpr *E) {
6509  if (!Info.CurrentCall) {
6510  assert(Info.checkingPotentialConstantExpression());
6511  return false;
6512  }
6513 
6514  const CXXConstructorDecl *FD = E->getConstructor();
6515  if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl())
6516  return false;
6517 
6518  const FunctionDecl *Definition = nullptr;
6519  auto Body = FD->getBody(Definition);
6520 
6521  if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
6522  return false;
6523 
6524  return HandleConstructorCall(E, This, Info.CurrentCall->Arguments,
6525  cast<CXXConstructorDecl>(Definition), Info,
6526  Result);
6527 }
6528 
6529 bool RecordExprEvaluator::VisitCXXStdInitializerListExpr(
6530  const CXXStdInitializerListExpr *E) {
6531  const ConstantArrayType *ArrayType =
6532  Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
6533 
6534  LValue Array;
6535  if (!EvaluateLValue(E->getSubExpr(), Array, Info))
6536  return false;
6537 
6538  // Get a pointer to the first element of the array.
6539  Array.addArray(Info, E, ArrayType);
6540 
6541  // FIXME: Perform the checks on the field types in SemaInit.
6542  RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
6543  RecordDecl::field_iterator Field = Record->field_begin();
6544  if (Field == Record->field_end())
6545  return Error(E);
6546 
6547  // Start pointer.
6548  if (!Field->getType()->isPointerType() ||
6549  !Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
6550  ArrayType->getElementType()))
6551  return Error(E);
6552 
6553  // FIXME: What if the initializer_list type has base classes, etc?
6554  Result = APValue(APValue::UninitStruct(), 0, 2);
6555  Array.moveInto(Result.getStructField(0));
6556 
6557  if (++Field == Record->field_end())
6558  return Error(E);
6559 
6560  if (Field->getType()->isPointerType() &&
6561  Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
6562  ArrayType->getElementType())) {
6563  // End pointer.
6564  if (!HandleLValueArrayAdjustment(Info, E, Array,
6565  ArrayType->getElementType(),
6566  ArrayType->getSize().getZExtValue()))
6567  return false;
6568  Array.moveInto(Result.getStructField(1));
6569  } else if (Info.Ctx.hasSameType(Field->getType(), Info.Ctx.getSizeType()))
6570  // Length.
6571  Result.getStructField(1) = APValue(APSInt(ArrayType->getSize()));
6572  else
6573  return Error(E);
6574 
6575  if (++Field != Record->field_end())
6576  return Error(E);
6577 
6578  return true;
6579 }
6580 
6581 bool RecordExprEvaluator::VisitLambdaExpr(const LambdaExpr *E) {
6582  const CXXRecordDecl *ClosureClass = E->getLambdaClass();
6583  if (ClosureClass->isInvalidDecl()) return false;
6584 
6585  if (Info.checkingPotentialConstantExpression()) return true;
6586 
6587  const size_t NumFields =
6588  std::distance(ClosureClass->field_begin(), ClosureClass->field_end());
6589 
6590  assert(NumFields == (size_t)std::distance(E->capture_init_begin(),
6591  E->capture_init_end()) &&
6592  "The number of lambda capture initializers should equal the number of "
6593  "fields within the closure type");
6594 
6595  Result = APValue(APValue::UninitStruct(), /*NumBases*/0, NumFields);
6596  // Iterate through all the lambda's closure object's fields and initialize
6597  // them.
6598  auto *CaptureInitIt = E->capture_init_begin();
6599  const LambdaCapture *CaptureIt = ClosureClass->captures_begin();
6600  bool Success = true;
6601  for (const auto *Field : ClosureClass->fields()) {
6602  assert(CaptureInitIt != E->capture_init_end());
6603  // Get the initializer for this field
6604  Expr *const CurFieldInit = *CaptureInitIt++;
6605 
6606  // If there is no initializer, either this is a VLA or an error has
6607  // occurred.
6608  if (!CurFieldInit)
6609  return Error(E);
6610 
6611  APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
6612  if (!EvaluateInPlace(FieldVal, Info, This, CurFieldInit)) {
6613  if (!Info.keepEvaluatingAfterFailure())
6614  return false;
6615  Success = false;
6616  }
6617  ++CaptureIt;
6618  }
6619  return Success;
6620 }
6621 
6622 static bool EvaluateRecord(const Expr *E, const LValue &This,
6623  APValue &Result, EvalInfo &Info) {
6624  assert(E->isRValue() && E->getType()->isRecordType() &&
6625  "can't evaluate expression as a record rvalue");
6626  return RecordExprEvaluator(Info, This, Result).Visit(E);
6627 }
6628 
6629 //===----------------------------------------------------------------------===//
6630 // Temporary Evaluation
6631 //
6632 // Temporaries are represented in the AST as rvalues, but generally behave like
6633 // lvalues. The full-object of which the temporary is a subobject is implicitly
6634 // materialized so that a reference can bind to it.
6635 //===----------------------------------------------------------------------===//
6636 namespace {
6637 class TemporaryExprEvaluator
6638  : public LValueExprEvaluatorBase<TemporaryExprEvaluator> {
6639 public:
6640  TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) :
6641  LValueExprEvaluatorBaseTy(Info, Result, false) {}
6642 
6643  /// Visit an expression which constructs the value of this temporary.
6644  bool VisitConstructExpr(const Expr *E) {
6645  APValue &Value = createTemporary(E, false, Result, *Info.CurrentCall);
6646  return EvaluateInPlace(Value, Info, Result, E);
6647  }
6648 
6649  bool VisitCastExpr(const CastExpr *E) {
6650  switch (E->getCastKind()) {
6651  default:
6652  return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
6653 
6654  case CK_ConstructorConversion:
6655  return VisitConstructExpr(E->getSubExpr());
6656  }
6657  }
6658  bool VisitInitListExpr(const InitListExpr *E) {
6659  return VisitConstructExpr(E);
6660  }
6661  bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
6662  return VisitConstructExpr(E);
6663  }
6664  bool VisitCallExpr(const CallExpr *E) {
6665  return VisitConstructExpr(E);
6666  }
6667  bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E) {
6668  return VisitConstructExpr(E);
6669  }
6670  bool VisitLambdaExpr(const LambdaExpr *E) {
6671  return VisitConstructExpr(E);
6672  }
6673 };
6674 } // end anonymous namespace
6675 
6676 /// Evaluate an expression of record type as a temporary.
6677 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
6678  assert(E->isRValue() && E->getType()->isRecordType());
6679  return TemporaryExprEvaluator(Info, Result).Visit(E);
6680 }
6681 
6682 //===----------------------------------------------------------------------===//
6683 // Vector Evaluation
6684 //===----------------------------------------------------------------------===//
6685 
6686 namespace {
6687  class VectorExprEvaluator
6688  : public ExprEvaluatorBase<VectorExprEvaluator> {
6689  APValue &Result;
6690  public:
6691 
6692  VectorExprEvaluator(EvalInfo &info, APValue &Result)
6693  : ExprEvaluatorBaseTy(info), Result(Result) {}
6694 
6695  bool Success(ArrayRef<APValue> V, const Expr *E) {
6696  assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements());
6697  // FIXME: remove this APValue copy.
6698  Result = APValue(V.data(), V.size());
6699  return true;
6700  }
6701  bool Success(const APValue &V, const Expr *E) {
6702  assert(V.isVector());
6703  Result = V;
6704  return true;
6705  }
6706  bool ZeroInitialization(const Expr *E);
6707 
6708  bool VisitUnaryReal(const UnaryOperator *E)
6709  { return Visit(E->getSubExpr()); }
6710  bool VisitCastExpr(const CastExpr* E);
6711  bool VisitInitListExpr(const InitListExpr *E);
6712  bool VisitUnaryImag(const UnaryOperator *E);
6713  // FIXME: Missing: unary -, unary ~, binary add/sub/mul/div,
6714  // binary comparisons, binary and/or/xor,
6715  // shufflevector, ExtVectorElementExpr
6716  };
6717 } // end anonymous namespace
6718 
6719 static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
6720  assert(E->isRValue() && E->getType()->isVectorType() &&"not a vector rvalue");
6721  return VectorExprEvaluator(Info, Result).Visit(E);
6722 }
6723 
6724 bool VectorExprEvaluator::VisitCastExpr(const CastExpr *E) {
6725  const VectorType *VTy = E->getType()->castAs<VectorType>();
6726  unsigned NElts = VTy->getNumElements();
6727 
6728  const Expr *SE = E->getSubExpr();
6729  QualType SETy = SE->getType();
6730 
6731  switch (E->getCastKind()) {
6732  case CK_VectorSplat: {
6733  APValue Val = APValue();
6734  if (SETy->isIntegerType()) {
6735  APSInt IntResult;
6736  if (!EvaluateInteger(SE, IntResult, Info))
6737  return false;
6738  Val = APValue(std::move(IntResult));
6739  } else if (SETy->isRealFloatingType()) {
6740  APFloat FloatResult(0.0);
6741  if (!EvaluateFloat(SE, FloatResult, Info))
6742  return false;
6743  Val = APValue(std::move(FloatResult));
6744  } else {
6745  return Error(E);
6746  }
6747 
6748  // Splat and create vector APValue.
6749  SmallVector<APValue, 4> Elts(NElts, Val);
6750  return Success(Elts, E);
6751  }
6752  case CK_BitCast: {
6753  // Evaluate the operand into an APInt we can extract from.
6754  llvm::APInt SValInt;
6755  if (!EvalAndBitcastToAPInt(Info, SE, SValInt))
6756  return false;
6757  // Extract the elements
6758  QualType EltTy = VTy->getElementType();
6759  unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
6760  bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
6762  if (EltTy->isRealFloatingType()) {
6763  const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy);
6764  unsigned FloatEltSize = EltSize;
6765  if (&Sem == &APFloat::x87DoubleExtended())
6766  FloatEltSize = 80;
6767  for (unsigned i = 0; i < NElts; i++) {
6768  llvm::APInt Elt;
6769  if (BigEndian)
6770  Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize);
6771  else
6772  Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize);
6773  Elts.push_back(APValue(APFloat(Sem, Elt)));
6774  }
6775  } else if (EltTy->isIntegerType()) {
6776  for (unsigned i = 0; i < NElts; i++) {
6777  llvm::APInt Elt;
6778  if (BigEndian)
6779  Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize);
6780  else
6781  Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize);
6782  Elts.push_back(APValue(APSInt(Elt, EltTy->isSignedIntegerType())));
6783  }
6784  } else {
6785  return Error(E);
6786  }
6787  return Success(Elts, E);
6788  }
6789  default:
6790  return ExprEvaluatorBaseTy::VisitCastExpr(E);
6791  }
6792 }
6793 
6794 bool
6795 VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
6796  const VectorType *VT = E->getType()->castAs<VectorType>();
6797  unsigned NumInits = E->getNumInits();
6798  unsigned NumElements = VT->getNumElements();
6799 
6800  QualType EltTy = VT->getElementType();
6801  SmallVector<APValue, 4> Elements;
6802 
6803  // The number of initializers can be less than the number of
6804  // vector elements. For OpenCL, this can be due to nested vector
6805  // initialization. For GCC compatibility, missing trailing elements
6806  // should be initialized with zeroes.
6807  unsigned CountInits = 0, CountElts = 0;
6808  while (CountElts < NumElements) {
6809  // Handle nested vector initialization.
6810  if (CountInits < NumInits
6811  && E->getInit(CountInits)->getType()->isVectorType()) {
6812  APValue v;
6813  if (!EvaluateVector(E->getInit(CountInits), v, Info))
6814  return Error(E);
6815  unsigned vlen = v.getVectorLength();
6816  for (unsigned j = 0; j < vlen; j++)
6817  Elements.push_back(v.getVectorElt(j));
6818  CountElts += vlen;
6819  } else if (EltTy->isIntegerType()) {
6820  llvm::APSInt sInt(32);
6821  if (CountInits < NumInits) {
6822  if (!EvaluateInteger(E->getInit(CountInits), sInt, Info))
6823  return false;
6824  } else // trailing integer zero.
6825  sInt = Info.Ctx.MakeIntValue(0, EltTy);
6826  Elements.push_back(APValue(sInt));
6827  CountElts++;
6828  } else {
6829  llvm::APFloat f(0.0);
6830  if (CountInits < NumInits) {
6831  if (!EvaluateFloat(E->getInit(CountInits), f, Info))
6832  return false;
6833  } else // trailing float zero.
6834  f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
6835  Elements.push_back(APValue(f));
6836  CountElts++;
6837  }
6838  CountInits++;
6839  }
6840  return Success(Elements, E);
6841 }
6842 
6843 bool
6844 VectorExprEvaluator::ZeroInitialization(const Expr *E) {
6845  const VectorType *VT = E->getType()->getAs<VectorType>();
6846  QualType EltTy = VT->getElementType();
6847  APValue ZeroElement;
6848  if (EltTy->isIntegerType())
6849  ZeroElement = APValue(Info.Ctx.MakeIntValue(0, EltTy));
6850  else
6851  ZeroElement =
6852  APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
6853 
6854  SmallVector<APValue, 4> Elements(VT->getNumElements(), ZeroElement);
6855  return Success(Elements, E);
6856 }
6857 
6858 bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
6859  VisitIgnoredValue(E->getSubExpr());
6860  return ZeroInitialization(E);
6861 }
6862 
6863 //===----------------------------------------------------------------------===//
6864 // Array Evaluation
6865 //===----------------------------------------------------------------------===//
6866 
6867 namespace {
6868  class ArrayExprEvaluator
6869  : public ExprEvaluatorBase<ArrayExprEvaluator> {
6870  const LValue &This;
6871  APValue &Result;
6872  public:
6873 
6874  ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result)
6875  : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
6876 
6877  bool Success(const APValue &V, const Expr *E) {
6878  assert((V.isArray() || V.isLValue()) &&
6879  "expected array or string literal");
6880  Result = V;
6881  return true;
6882  }
6883 
6884  bool ZeroInitialization(const Expr *E) {
6885  const ConstantArrayType *CAT =
6886  Info.Ctx.getAsConstantArrayType(E->getType());
6887  if (!CAT)
6888  return Error(E);
6889 
6890  Result = APValue(APValue::UninitArray(), 0,
6891  CAT->getSize().getZExtValue());
6892  if (!Result.hasArrayFiller()) return true;
6893 
6894  // Zero-initialize all elements.
6895  LValue Subobject = This;
6896  Subobject.addArray(Info, E, CAT);
6898  return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
6899  }
6900 
6901  bool VisitCallExpr(const CallExpr *E) {
6902  return handleCallExpr(E, Result, &This);
6903  }
6904  bool VisitInitListExpr(const InitListExpr *E);
6905  bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E);
6906  bool VisitCXXConstructExpr(const CXXConstructExpr *E);
6907  bool VisitCXXConstructExpr(const CXXConstructExpr *E,
6908  const LValue &Subobject,
6909  APValue *Value, QualType Type);
6910  };
6911 } // end anonymous namespace
6912 
6913 static bool EvaluateArray(const Expr *E, const LValue &This,
6914  APValue &Result, EvalInfo &Info) {
6915  assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue");
6916  return ArrayExprEvaluator(Info, This, Result).Visit(E);
6917 }
6918 
6919 // Return true iff the given array filler may depend on the element index.
6920 static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {
6921  // For now, just whitelist non-class value-initialization and initialization
6922  // lists comprised of them.
6923  if (isa<ImplicitValueInitExpr>(FillerExpr))
6924  return false;
6925  if (const InitListExpr *ILE = dyn_cast<InitListExpr>(FillerExpr)) {
6926  for (unsigned I = 0, E = ILE->getNumInits(); I != E; ++I) {
6927  if (MaybeElementDependentArrayFiller(ILE->getInit(I)))
6928  return true;
6929  }
6930  return false;
6931  }
6932  return true;
6933 }
6934 
6935 bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
6936  const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(E->getType());
6937  if (!CAT)
6938  return Error(E);
6939 
6940  // C++11 [dcl.init.string]p1: A char array [...] can be initialized by [...]
6941  // an appropriately-typed string literal enclosed in braces.
6942  if (E->isStringLiteralInit()) {
6943  LValue LV;
6944  if (!EvaluateLValue(E->getInit(0), LV, Info))
6945  return false;
6946  APValue Val;
6947  LV.moveInto(Val);
6948  return Success(Val, E);
6949  }
6950 
6951  bool Success = true;
6952 
6953  assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) &&
6954  "zero-initialized array shouldn't have any initialized elts");
6955  APValue Filler;
6956  if (Result.isArray() && Result.hasArrayFiller())
6957  Filler = Result.getArrayFiller();
6958 
6959  unsigned NumEltsToInit = E->getNumInits();
6960  unsigned NumElts = CAT->getSize().getZExtValue();
6961  const Expr *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : nullptr;
6962 
6963  // If the initializer might depend on the array index, run it for each
6964  // array element.
6965  if (NumEltsToInit != NumElts && MaybeElementDependentArrayFiller(FillerExpr))
6966  NumEltsToInit = NumElts;
6967 
6968  LLVM_DEBUG(llvm::dbgs() << "The number of elements to initialize: "
6969  << NumEltsToInit << ".\n");
6970 
6971  Result = APValue(APValue::UninitArray(), NumEltsToInit, NumElts);
6972 
6973  // If the array was previously zero-initialized, preserve the
6974  // zero-initialized values.
6975  if (!Filler.isUninit()) {
6976  for (unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I)
6977  Result.getArrayInitializedElt(I) = Filler;
6978  if (Result.hasArrayFiller())
6979  Result.getArrayFiller() = Filler;
6980  }
6981 
6982  LValue Subobject = This;
6983  Subobject.addArray(Info, E, CAT);
6984  for (unsigned Index = 0; Index != NumEltsToInit; ++Index) {
6985  const Expr *Init =
6986  Index < E->getNumInits() ? E->getInit(Index) : FillerExpr;
6987  if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
6988  Info, Subobject, Init) ||
6989  !HandleLValueArrayAdjustment(Info, Init, Subobject,
6990  CAT->getElementType(), 1)) {
6991  if (!Info.noteFailure())
6992  return false;
6993  Success = false;
6994  }
6995  }
6996 
6997  if (!Result.hasArrayFiller())
6998  return Success;
6999 
7000  // If we get here, we have a trivial filler, which we can just evaluate
7001  // once and splat over the rest of the array elements.
7002  assert(FillerExpr && "no array filler for incomplete init list");
7003  return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject,
7004  FillerExpr) && Success;
7005 }
7006 
7007 bool ArrayExprEvaluator::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) {
7008  if (E->getCommonExpr() &&
7009  !Evaluate(Info.CurrentCall->createTemporary(E->getCommonExpr(), false),
7010  Info, E->getCommonExpr()->getSourceExpr()))
7011  return false;
7012 
7013  auto *CAT = cast<ConstantArrayType>(E->getType()->castAsArrayTypeUnsafe());
7014 
7015  uint64_t Elements = CAT->getSize().getZExtValue();
7016  Result = APValue(APValue::UninitArray(), Elements, Elements);
7017 
7018  LValue Subobject = This;
7019  Subobject.addArray(Info, E, CAT);
7020 
7021  bool Success = true;
7022  for (EvalInfo::ArrayInitLoopIndex Index(Info); Index != Elements; ++Index) {
7023  if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
7024  Info, Subobject, E->getSubExpr()) ||
7025  !HandleLValueArrayAdjustment(Info, E, Subobject,
7026  CAT->getElementType(), 1)) {
7027  if (!Info.noteFailure())
7028  return false;
7029  Success = false;
7030  }
7031  }
7032 
7033  return Success;
7034 }
7035 
7036 bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E) {
7037  return VisitCXXConstructExpr(E, This, &Result, E->getType());
7038 }
7039 
7040 bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
7041  const LValue &Subobject,
7042  APValue *Value,
7043  QualType Type) {
7044  bool HadZeroInit = !Value->isUninit();
7045 
7046  if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) {
7047  unsigned N = CAT->getSize().getZExtValue();
7048 
7049  // Preserve the array filler if we had prior zero-initialization.
7050  APValue Filler =
7051  HadZeroInit && Value->hasArrayFiller() ? Value->getArrayFiller()
7052  : APValue();
7053 
7054  *Value = APValue(APValue::UninitArray(), N, N);
7055 
7056  if (HadZeroInit)
7057  for (unsigned I = 0; I != N; ++I)
7058  Value->getArrayInitializedElt(I) = Filler;
7059 
7060  // Initialize the elements.
7061  LValue ArrayElt = Subobject;
7062  ArrayElt.addArray(Info, E, CAT);
7063  for (unsigned I = 0; I != N; ++I)
7064  if (!VisitCXXConstructExpr(E, ArrayElt, &Value->getArrayInitializedElt(I),
7065  CAT->getElementType()) ||
7066  !HandleLValueArrayAdjustment(Info, E, ArrayElt,
7067  CAT->getElementType(), 1))
7068  return false;
7069 
7070  return true;
7071  }
7072 
7073  if (!Type->isRecordType())
7074  return Error(E);
7075 
7076  return RecordExprEvaluator(Info, Subobject, *Value)
7077  .VisitCXXConstructExpr(E, Type);
7078 }
7079 
7080 //===----------------------------------------------------------------------===//
7081 // Integer Evaluation
7082 //
7083 // As a GNU extension, we support casting pointers to sufficiently-wide integer
7084 // types and back in constant folding. Integer values are thus represented
7085 // either as an integer-valued APValue, or as an lvalue-valued APValue.
7086 //===----------------------------------------------------------------------===//
7087 
7088 namespace {
7089 class IntExprEvaluator
7090  : public ExprEvaluatorBase<IntExprEvaluator> {
7091  APValue &Result;
7092 public:
7093  IntExprEvaluator(EvalInfo &info, APValue &result)
7094  : ExprEvaluatorBaseTy(info), Result(result) {}
7095 
7096  bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
7097  assert(E->getType()->isIntegralOrEnumerationType() &&
7098  "Invalid evaluation result.");
7099  assert(SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() &&
7100  "Invalid evaluation result.");
7101  assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
7102  "Invalid evaluation result.");
7103  Result = APValue(SI);
7104  return true;
7105  }
7106  bool Success(const llvm::APSInt &SI, const Expr *E) {
7107  return Success(SI, E, Result);
7108  }
7109 
7110  bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
7111  assert(E->getType()->isIntegralOrEnumerationType() &&
7112  "Invalid evaluation result.");
7113  assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
7114  "Invalid evaluation result.");
7115  Result = APValue(APSInt(I));
7116  Result.getInt().setIsUnsigned(
7118  return true;
7119  }
7120  bool Success(const llvm::APInt &I, const Expr *E) {
7121  return Success(I, E, Result);
7122  }
7123 
7124  bool Success(uint64_t Value, const Expr *E, APValue &Result) {
7125  assert(E->getType()->isIntegralOrEnumerationType() &&
7126  "Invalid evaluation result.");
7127  Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
7128  return true;
7129  }
7130  bool Success(uint64_t Value, const Expr *E) {
7131  return Success(Value, E, Result);
7132  }
7133 
7134  bool Success(CharUnits Size, const Expr *E) {
7135  return Success(Size.getQuantity(), E);
7136  }
7137 
7138  bool Success(const APValue &V, const Expr *E) {
7139  if (V.isLValue() || V.isAddrLabelDiff()) {
7140  Result = V;
7141  return true;
7142  }
7143  return Success(V.getInt(), E);
7144  }
7145 
7146  bool ZeroInitialization(const Expr *E) { return Success(0, E); }
7147 
7148  //===--------------------------------------------------------------------===//
7149  // Visitor Methods
7150  //===--------------------------------------------------------------------===//
7151 
7152  bool VisitIntegerLiteral(const IntegerLiteral *E) {
7153  return Success(E->getValue(), E);
7154  }
7155  bool VisitCharacterLiteral(const CharacterLiteral *E) {
7156  return Success(E->getValue(), E);
7157  }
7158 
7159  bool CheckReferencedDecl(const Expr *E, const Decl *D);
7160  bool VisitDeclRefExpr(const DeclRefExpr *E) {
7161  if (CheckReferencedDecl(E, E->getDecl()))
7162  return true;
7163 
7164  return ExprEvaluatorBaseTy::VisitDeclRefExpr(E);
7165  }
7166  bool VisitMemberExpr(const MemberExpr *E) {
7167  if (CheckReferencedDecl(E, E->getMemberDecl())) {
7168  VisitIgnoredBaseExpression(E->getBase());
7169  return true;
7170  }
7171 
7172  return ExprEvaluatorBaseTy::VisitMemberExpr(E);
7173  }
7174 
7175  bool VisitCallExpr(const CallExpr *E);
7176  bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
7177  bool VisitBinaryOperator(const BinaryOperator *E);
7178  bool VisitOffsetOfExpr(const OffsetOfExpr *E);
7179  bool VisitUnaryOperator(const UnaryOperator *E);
7180 
7181  bool VisitCastExpr(const CastExpr* E);
7182  bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
7183 
7184  bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
7185  return Success(E->getValue(), E);
7186  }
7187 
7188  bool VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
7189  return Success(E->getValue(), E);
7190  }
7191 
7192  bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) {
7193  if (Info.ArrayInitIndex == uint64_t(-1)) {
7194  // We were asked to evaluate this subexpression independent of the
7195  // enclosing ArrayInitLoopExpr. We can't do that.
7196  Info.FFDiag(E);
7197  return false;
7198  }
7199  return Success(Info.ArrayInitIndex, E);
7200  }
7201 
7202  // Note, GNU defines __null as an integer, not a pointer.
7203  bool VisitGNUNullExpr(const GNUNullExpr *E) {
7204  return ZeroInitialization(E);
7205  }
7206 
7207  bool VisitTypeTraitExpr(const TypeTraitExpr *E) {
7208  return Success(E->getValue(), E);
7209  }
7210 
7211  bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
7212  return Success(E->getValue(), E);
7213  }
7214 
7215  bool VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
7216  return Success(E->getValue(), E);
7217  }
7218 
7219  bool VisitUnaryReal(const UnaryOperator *E);
7220  bool VisitUnaryImag(const UnaryOperator *E);
7221 
7222  bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E);
7223  bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
7224 
7225  // FIXME: Missing: array subscript of vector, member of vector
7226 };
7227 
7228 class FixedPointExprEvaluator
7229  : public ExprEvaluatorBase<FixedPointExprEvaluator> {
7230  APValue &Result;
7231 
7232  public:
7233  FixedPointExprEvaluator(EvalInfo &info, APValue &result)
7234  : ExprEvaluatorBaseTy(info), Result(result) {}
7235 
7236  bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
7237  assert(E->getType()->isFixedPointType() && "Invalid evaluation result.");
7238  assert(SI.isSigned() == E->getType()->isSignedFixedPointType() &&
7239  "Invalid evaluation result.");
7240  assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
7241  "Invalid evaluation result.");
7242  Result = APValue(SI);
7243  return true;
7244  }
7245  bool Success(const llvm::APSInt &SI, const Expr *E) {
7246  return Success(SI, E, Result);
7247  }
7248 
7249  bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
7250  assert(E->getType()->isFixedPointType() && "Invalid evaluation result.");
7251  assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
7252  "Invalid evaluation result.");
7253  Result = APValue(APSInt(I));
7254  Result.getInt().setIsUnsigned(E->getType()->isUnsignedFixedPointType());
7255  return true;
7256  }
7257  bool Success(const llvm::APInt &I, const Expr *E) {
7258  return Success(I, E, Result);
7259  }
7260 
7261  bool Success(uint64_t Value, const Expr *E, APValue &Result) {
7262  assert(E->getType()->isFixedPointType() && "Invalid evaluation result.");
7263  Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
7264  return true;
7265  }
7266  bool Success(uint64_t Value, const Expr *E) {
7267  return Success(Value, E, Result);
7268  }
7269 
7270  bool Success(CharUnits Size, const Expr *E) {
7271  return Success(Size.getQuantity(), E);
7272  }
7273 
7274  bool Success(const APValue &V, const Expr *E) {
7275  if (V.isLValue() || V.isAddrLabelDiff()) {
7276  Result = V;
7277  return true;
7278  }
7279  return Success(V.getInt(), E);
7280  }
7281 
7282  bool ZeroInitialization(const Expr *E) { return Success(0, E); }
7283 
7284  //===--------------------------------------------------------------------===//
7285  // Visitor Methods
7286  //===--------------------------------------------------------------------===//
7287 
7288  bool VisitFixedPointLiteral(const FixedPointLiteral *E) {
7289  return Success(E->getValue(), E);
7290  }
7291 
7292  bool VisitUnaryOperator(const UnaryOperator *E);
7293 };
7294 } // end anonymous namespace
7295 
7296 /// EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and
7297 /// produce either the integer value or a pointer.
7298 ///
7299 /// GCC has a heinous extension which folds casts between pointer types and
7300 /// pointer-sized integral types. We support this by allowing the evaluation of
7301 /// an integer rvalue to produce a pointer (represented as an lvalue) instead.
7302 /// Some simple arithmetic on such values is supported (they are treated much
7303 /// like char*).
7304 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
7305  EvalInfo &Info) {
7306  assert(E->isRValue() && E->getType()->isIntegralOrEnumerationType());
7307  return IntExprEvaluator(Info, Result).Visit(E);
7308 }
7309 
7310 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
7311  APValue Val;
7312  if (!EvaluateIntegerOrLValue(E, Val, Info))
7313  return false;
7314  if (!Val.isInt()) {
7315  // FIXME: It would be better to produce the diagnostic for casting
7316  // a pointer to an integer.
7317  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
7318  return false;
7319  }
7320  Result = Val.getInt();
7321  return true;
7322 }
7323 
7324 /// Check whether the given declaration can be directly converted to an integral
7325 /// rvalue. If not, no diagnostic is produced; there are other things we can
7326 /// try.
7327 bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) {
7328  // Enums are integer constant exprs.
7329  if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) {
7330  // Check for signedness/width mismatches between E type and ECD value.
7331  bool SameSign = (ECD->getInitVal().isSigned()
7333  bool SameWidth = (ECD->getInitVal().getBitWidth()
7334  == Info.Ctx.getIntWidth(E->getType()));
7335  if (SameSign && SameWidth)
7336  return Success(ECD->getInitVal(), E);
7337  else {
7338  // Get rid of mismatch (otherwise Success assertions will fail)
7339  // by computing a new value matching the type of E.
7340  llvm::APSInt Val = ECD->getInitVal();
7341  if (!SameSign)
7342  Val.setIsSigned(!ECD->getInitVal().isSigned());
7343  if (!SameWidth)
7344  Val = Val.extOrTrunc(Info.Ctx.getIntWidth(E->getType()));
7345  return Success(Val, E);
7346  }
7347  }
7348  return false;
7349 }
7350 
7351 /// Values returned by __builtin_classify_type, chosen to match the values
7352 /// produced by GCC's builtin.
7353 enum class GCCTypeClass {
7354  None = -1,
7355  Void = 0,
7356  Integer = 1,
7357  // GCC reserves 2 for character types, but instead classifies them as
7358  // integers.
7359  Enum = 3,
7360  Bool = 4,
7361  Pointer = 5,
7362  // GCC reserves 6 for references, but appears to never use it (because
7363  // expressions never have reference type, presumably).
7364  PointerToDataMember = 7,
7365  RealFloat = 8,
7366  Complex = 9,
7367  // GCC reserves 10 for functions, but does not use it since GCC version 6 due
7368  // to decay to pointer. (Prior to version 6 it was only used in C++ mode).
7369  // GCC claims to reserve 11 for pointers to member functions, but *actually*
7370  // uses 12 for that purpose, same as for a class or struct. Maybe it
7371  // internally implements a pointer to member as a struct? Who knows.
7372  PointerToMemberFunction = 12, // Not a bug, see above.
7373  ClassOrStruct = 12,
7374  Union = 13,
7375  // GCC reserves 14 for arrays, but does not use it since GCC version 6 due to
7376  // decay to pointer. (Prior to version 6 it was only used in C++ mode).
7377  // GCC reserves 15 for strings, but actually uses 5 (pointer) for string
7378  // literals.
7379 };
7380 
7381 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
7382 /// as GCC.
7383 static GCCTypeClass
7385  assert(!T->isDependentType() && "unexpected dependent type");
7386 
7387  QualType CanTy = T.getCanonicalType();
7388  const BuiltinType *BT = dyn_cast<BuiltinType>(CanTy);
7389 
7390  switch (CanTy->getTypeClass()) {
7391 #define TYPE(ID, BASE)
7392 #define DEPENDENT_TYPE(ID, BASE) case Type::ID:
7393 #define NON_CANONICAL_TYPE(ID, BASE) case Type::ID:
7394 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(ID, BASE) case Type::ID:
7395 #include "clang/AST/TypeNodes.def"
7396  case Type::Auto:
7397  case Type::DeducedTemplateSpecialization:
7398  llvm_unreachable("unexpected non-canonical or dependent type");
7399 
7400  case Type::Builtin:
7401  switch (BT->getKind()) {
7402 #define BUILTIN_TYPE(ID, SINGLETON_ID)
7403 #define SIGNED_TYPE(ID, SINGLETON_ID) \
7404  case BuiltinType::ID: return GCCTypeClass::Integer;
7405 #define FLOATING_TYPE(ID, SINGLETON_ID) \
7406  case BuiltinType::ID: return GCCTypeClass::RealFloat;
7407 #define PLACEHOLDER_TYPE(ID, SINGLETON_ID) \
7408  case BuiltinType::ID: break;
7409 #include "clang/AST/BuiltinTypes.def"
7410  case BuiltinType::Void:
7411  return GCCTypeClass::Void;
7412 
7413  case BuiltinType::Bool:
7414  return GCCTypeClass::Bool;
7415 
7416  case BuiltinType::Char_U:
7417  case BuiltinType::UChar:
7418  case BuiltinType::WChar_U:
7419  case BuiltinType::Char8:
7420  case BuiltinType::Char16:
7421  case BuiltinType::Char32:
7422  case BuiltinType::UShort:
7423  case BuiltinType::UInt:
7424  case BuiltinType::ULong:
7425  case BuiltinType::ULongLong:
7426  case BuiltinType::UInt128:
7427  return GCCTypeClass::Integer;
7428 
7429  case BuiltinType::UShortAccum:
7430  case BuiltinType::UAccum:
7431  case BuiltinType::ULongAccum:
7432  case BuiltinType::UShortFract:
7433  case BuiltinType::UFract:
7434  case BuiltinType::ULongFract:
7435  case BuiltinType::SatUShortAccum:
7436  case BuiltinType::SatUAccum:
7437  case BuiltinType::SatULongAccum:
7438  case BuiltinType::SatUShortFract:
7439  case BuiltinType::SatUFract:
7440  case BuiltinType::SatULongFract:
7441  return GCCTypeClass::None;
7442 
7443  case BuiltinType::NullPtr:
7444 
7445  case BuiltinType::ObjCId:
7446  case BuiltinType::ObjCClass:
7447  case BuiltinType::ObjCSel:
7448 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7449  case BuiltinType::Id:
7450 #include "clang/Basic/OpenCLImageTypes.def"
7451  case BuiltinType::OCLSampler:
7452  case BuiltinType::OCLEvent:
7453  case BuiltinType::OCLClkEvent:
7454  case BuiltinType::OCLQueue:
7455  case BuiltinType::OCLReserveID:
7456  return GCCTypeClass::None;
7457 
7458  case BuiltinType::Dependent:
7459  llvm_unreachable("unexpected dependent type");
7460  };
7461  llvm_unreachable("unexpected placeholder type");
7462 
7463  case Type::Enum:
7464  return LangOpts.CPlusPlus ? GCCTypeClass::Enum : GCCTypeClass::Integer;
7465 
7466  case Type::Pointer:
7467  case Type::ConstantArray:
7468  case Type::VariableArray:
7469  case Type::IncompleteArray:
7470  case Type::FunctionNoProto:
7471  case Type::FunctionProto:
7472  return GCCTypeClass::Pointer;
7473 
7474  case Type::MemberPointer:
7475  return CanTy->isMemberDataPointerType()
7478 
7479  case Type::Complex:
7480  return GCCTypeClass::Complex;
7481 
7482  case Type::Record:
7483  return CanTy->isUnionType() ? GCCTypeClass::Union
7485 
7486  case Type::Atomic:
7487  // GCC classifies _Atomic T the same as T.
7489  CanTy->castAs<AtomicType>()->getValueType(), LangOpts);
7490 
7491  case Type::BlockPointer:
7492  case Type::Vector:
7493  case Type::ExtVector:
7494  case Type::ObjCObject:
7495  case Type::ObjCInterface:
7496  case Type::ObjCObjectPointer:
7497  case Type::Pipe:
7498  // GCC classifies vectors as None. We follow its lead and classify all
7499  // other types that don't fit into the regular classification the same way.
7500  return GCCTypeClass::None;
7501 
7502  case Type::LValueReference:
7503  case Type::RValueReference:
7504  llvm_unreachable("invalid type for expression");
7505  }
7506 
7507  llvm_unreachable("unexpected type class");
7508 }
7509 
7510 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
7511 /// as GCC.
7512 static GCCTypeClass
7514  // If no argument was supplied, default to None. This isn't
7515  // ideal, however it is what gcc does.
7516  if (E->getNumArgs() == 0)
7517  return GCCTypeClass::None;
7518 
7519  // FIXME: Bizarrely, GCC treats a call with more than one argument as not
7520  // being an ICE, but still folds it to a constant using the type of the first
7521  // argument.
7522  return EvaluateBuiltinClassifyType(E->getArg(0)->getType(), LangOpts);
7523 }
7524 
7525 /// EvaluateBuiltinConstantPForLValue - Determine the result of
7526 /// __builtin_constant_p when applied to the given lvalue.
7527 ///
7528 /// An lvalue is only "constant" if it is a pointer or reference to the first
7529 /// character of a string literal.
7530 template<typename LValue>
7531 static bool EvaluateBuiltinConstantPForLValue(const LValue &LV) {
7532  const Expr *E = LV.getLValueBase().template dyn_cast<const Expr*>();
7533  return E && isa<StringLiteral>(E) && LV.getLValueOffset().isZero();
7534 }
7535 
7536 /// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to
7537 /// GCC as we can manage.
7538 static bool EvaluateBuiltinConstantP(ASTContext &Ctx, const Expr *Arg) {
7539  QualType ArgType = Arg->getType();
7540 
7541  // __builtin_constant_p always has one operand. The rules which gcc follows
7542  // are not precisely documented, but are as follows:
7543  //
7544  // - If the operand is of integral, floating, complex or enumeration type,
7545  // and can be folded to a known value of that type, it returns 1.
7546  // - If the operand and can be folded to a pointer to the first character
7547  // of a string literal (or such a pointer cast to an integral type), it
7548  // returns 1.
7549  //
7550  // Otherwise, it returns 0.
7551  //
7552  // FIXME: GCC also intends to return 1 for literals of aggregate types, but
7553  // its support for this does not currently work.
7554  if (ArgType->isIntegralOrEnumerationType()) {
7556  if (!Arg->EvaluateAsRValue(Result, Ctx) || Result.HasSideEffects)
7557  return false;
7558 
7559  APValue &V = Result.Val;
7560  if (V.getKind() == APValue::Int)
7561  return true;
7562  if (V.getKind() == APValue::LValue)
7564  } else if (ArgType->isFloatingType() || ArgType->isAnyComplexType()) {
7565  return Arg->isEvaluatable(Ctx);
7566  } else if (ArgType->isPointerType() || Arg->isGLValue()) {
7567  LValue LV;
7568  Expr::EvalStatus Status;
7569  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
7570  if ((Arg->isGLValue() ? EvaluateLValue(Arg, LV, Info)
7571  : EvaluatePointer(Arg, LV, Info)) &&
7572  !Status.HasSideEffects)
7574  }
7575 
7576  // Anything else isn't considered to be sufficiently constant.
7577  return false;
7578 }
7579 
7580 /// Retrieves the "underlying object type" of the given expression,
7581 /// as used by __builtin_object_size.
7583  if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
7584  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
7585  return VD->getType();
7586  } else if (const Expr *E = B.get<const Expr*>()) {
7587  if (isa<CompoundLiteralExpr>(E))
7588  return E->getType();
7589  }
7590 
7591  return QualType();
7592 }
7593 
7594 /// A more selective version of E->IgnoreParenCasts for
7595 /// tryEvaluateBuiltinObjectSize. This ignores some casts/parens that serve only
7596 /// to change the type of E.
7597 /// Ex. For E = `(short*)((char*)(&foo))`, returns `&foo`
7598 ///
7599 /// Always returns an RValue with a pointer representation.
7600 static const Expr *ignorePointerCastsAndParens(const Expr *E) {
7601  assert(E->isRValue() && E->getType()->hasPointerRepresentation());
7602 
7603  auto *NoParens = E->IgnoreParens();
7604  auto *Cast = dyn_cast<CastExpr>(NoParens);
7605  if (Cast == nullptr)
7606  return NoParens;
7607 
7608  // We only conservatively allow a few kinds of casts, because this code is
7609  // inherently a simple solution that seeks to support the common case.
7610  auto CastKind = Cast->getCastKind();
7611  if (CastKind != CK_NoOp && CastKind != CK_BitCast &&
7612  CastKind != CK_AddressSpaceConversion)
7613  return NoParens;
7614 
7615  auto *SubExpr = Cast->getSubExpr();
7616  if (!SubExpr->getType()->hasPointerRepresentation() || !SubExpr->isRValue())
7617  return NoParens;
7618  return ignorePointerCastsAndParens(SubExpr);
7619 }
7620 
7621 /// Checks to see if the given LValue's Designator is at the end of the LValue's
7622 /// record layout. e.g.
7623 /// struct { struct { int a, b; } fst, snd; } obj;
7624 /// obj.fst // no
7625 /// obj.snd // yes
7626 /// obj.fst.a // no
7627 /// obj.fst.b // no
7628 /// obj.snd.a // no
7629 /// obj.snd.b // yes
7630 ///
7631 /// Please note: this function is specialized for how __builtin_object_size
7632 /// views "objects".
7633 ///
7634 /// If this encounters an invalid RecordDecl or otherwise cannot determine the
7635 /// correct result, it will always return true.
7636 static bool isDesignatorAtObjectEnd(const ASTContext &Ctx, const LValue &LVal) {
7637  assert(!LVal.Designator.Invalid);
7638 
7639  auto IsLastOrInvalidFieldDecl = [&Ctx](const FieldDecl *FD, bool &Invalid) {
7640  const RecordDecl *Parent = FD->getParent();
7641  Invalid = Parent->isInvalidDecl();
7642  if (Invalid || Parent->isUnion())
7643  return true;
7644  const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(Parent);
7645  return FD->getFieldIndex() + 1 == Layout.getFieldCount();
7646  };
7647 
7648  auto &Base = LVal.getLValueBase();
7649  if (auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<const Expr *>())) {
7650  if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
7651  bool Invalid;
7652  if (!IsLastOrInvalidFieldDecl(FD, Invalid))
7653  return Invalid;
7654  } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(ME->getMemberDecl())) {
7655  for (auto *FD : IFD->chain()) {
7656  bool Invalid;
7657  if (!IsLastOrInvalidFieldDecl(cast<FieldDecl>(FD), Invalid))
7658  return Invalid;
7659  }
7660  }
7661  }
7662 
7663  unsigned I = 0;
7664  QualType BaseType = getType(Base);
7665  if (LVal.Designator.FirstEntryIsAnUnsizedArray) {
7666  // If we don't know the array bound, conservatively assume we're looking at
7667  // the final array element.
7668  ++I;
7669  if (BaseType->isIncompleteArrayType())
7670  BaseType = Ctx.getAsArrayType(BaseType)->getElementType();
7671  else
7672  BaseType = BaseType->castAs<PointerType>()->getPointeeType();
7673  }
7674 
7675  for (unsigned E = LVal.Designator.Entries.size(); I != E; ++I) {
7676  const auto &Entry = LVal.Designator.Entries[I];
7677  if (BaseType->isArrayType()) {
7678  // Because __builtin_object_size treats arrays as objects, we can ignore
7679  // the index iff this is the last array in the Designator.
7680  if (I + 1 == E)
7681  return true;
7682  const auto *CAT = cast<ConstantArrayType>(Ctx.getAsArrayType(BaseType));
7683  uint64_t Index = Entry.ArrayIndex;
7684  if (Index + 1 != CAT->getSize())
7685  return false;
7686  BaseType = CAT->getElementType();
7687  } else if (BaseType->isAnyComplexType()) {
7688  const auto *CT = BaseType->castAs<ComplexType>();
7689  uint64_t Index = Entry.ArrayIndex;
7690  if (Index != 1)
7691  return false;
7692  BaseType = CT->getElementType();
7693  } else if (auto *FD = getAsField(Entry)) {
7694  bool Invalid;
7695  if (!IsLastOrInvalidFieldDecl(FD, Invalid))
7696  return Invalid;
7697  BaseType = FD->getType();
7698  } else {
7699  assert(getAsBaseClass(Entry) && "Expecting cast to a base class");
7700  return false;
7701  }
7702  }
7703  return true;
7704 }
7705 
7706 /// Tests to see if the LValue has a user-specified designator (that isn't
7707 /// necessarily valid). Note that this always returns 'true' if the LValue has
7708 /// an unsized array as its first designator entry, because there's currently no
7709 /// way to tell if the user typed *foo or foo[0].
7710 static bool refersToCompleteObject(const LValue &LVal) {
7711  if (LVal.Designator.Invalid)
7712  return false;
7713 
7714  if (!LVal.Designator.Entries.empty())
7715  return LVal.Designator.isMostDerivedAnUnsizedArray();
7716 
7717  if (!LVal.InvalidBase)
7718  return true;
7719 
7720  // If `E` is a MemberExpr, then the first part of the designator is hiding in
7721  // the LValueBase.
7722  const auto *E = LVal.Base.dyn_cast<const Expr *>();
7723  return !E || !isa<MemberExpr>(E);
7724 }
7725 
7726 /// Attempts to detect a user writing into a piece of memory that's impossible
7727 /// to figure out the size of by just using types.
7728 static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal) {
7729  const SubobjectDesignator &Designator = LVal.Designator;
7730  // Notes:
7731  // - Users can only write off of the end when we have an invalid base. Invalid
7732  // bases imply we don't know where the memory came from.
7733  // - We used to be a bit more aggressive here; we'd only be conservative if
7734  // the array at the end was flexible, or if it had 0 or 1 elements. This
7735  // broke some common standard library extensions (PR30346), but was
7736  // otherwise seemingly fine. It may be useful to reintroduce this behavior
7737  // with some sort of whitelist. OTOH, it seems that GCC is always
7738  // conservative with the last element in structs (if it's an array), so our
7739  // current behavior is more compatible than a whitelisting approach would
7740  // be.
7741  return LVal.InvalidBase &&
7742  Designator.Entries.size() == Designator.MostDerivedPathLength &&
7743  Designator.MostDerivedIsArrayElement &&
7744  isDesignatorAtObjectEnd(Ctx, LVal);
7745 }
7746 
7747 /// Converts the given APInt to CharUnits, assuming the APInt is unsigned.
7748 /// Fails if the conversion would cause loss of precision.
7749 static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int,
7750  CharUnits &Result) {
7752  if (Int.ugt(CharUnitsMax))
7753  return false;
7754  Result = CharUnits::fromQuantity(Int.getZExtValue());
7755  return true;
7756 }
7757 
7758 /// Helper for tryEvaluateBuiltinObjectSize -- Given an LValue, this will
7759 /// determine how many bytes exist from the beginning of the object to either
7760 /// the end of the current subobject, or the end of the object itself, depending
7761 /// on what the LValue looks like + the value of Type.
7762 ///
7763 /// If this returns false, the value of Result is undefined.
7764 static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc,
7765  unsigned Type, const LValue &LVal,
7766  CharUnits &EndOffset) {
7767  bool DetermineForCompleteObject = refersToCompleteObject(LVal);
7768 
7769  auto CheckedHandleSizeof = [&](QualType Ty, CharUnits &Result) {
7770  if (Ty.isNull() || Ty->isIncompleteType() || Ty->isFunctionType())
7771  return false;
7772  return HandleSizeof(Info, ExprLoc, Ty, Result);
7773  };
7774 
7775  // We want to evaluate the size of the entire object. This is a valid fallback
7776  // for when Type=1 and the designator is invalid, because we're asked for an
7777  // upper-bound.
7778  if (!(Type & 1) || LVal.Designator.Invalid || DetermineForCompleteObject) {
7779  // Type=3 wants a lower bound, so we can't fall back to this.
7780  if (Type == 3 && !DetermineForCompleteObject)
7781  return false;
7782 
7783  llvm::APInt APEndOffset;
7784  if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
7785  getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
7786  return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
7787 
7788  if (LVal.InvalidBase)
7789  return false;
7790 
7791  QualType BaseTy = getObjectType(LVal.getLValueBase());
7792  return CheckedHandleSizeof(BaseTy, EndOffset);
7793  }
7794 
7795  // We want to evaluate the size of a subobject.
7796  const SubobjectDesignator &Designator = LVal.Designator;
7797 
7798  // The following is a moderately common idiom in C:
7799  //
7800  // struct Foo { int a; char c[1]; };
7801  // struct Foo *F = (struct Foo *)malloc(sizeof(struct Foo) + strlen(Bar));
7802  // strcpy(&F->c[0], Bar);
7803  //
7804  // In order to not break too much legacy code, we need to support it.
7805  if (isUserWritingOffTheEnd(Info.Ctx, LVal)) {
7806  // If we can resolve this to an alloc_size call, we can hand that back,
7807  // because we know for certain how many bytes there are to write to.
7808  llvm::APInt APEndOffset;
7809  if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
7810  getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
7811  return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
7812 
7813  // If we cannot determine the size of the initial allocation, then we can't
7814  // given an accurate upper-bound. However, we are still able to give
7815  // conservative lower-bounds for Type=3.
7816  if (Type == 1)
7817  return false;
7818  }
7819 
7820  CharUnits BytesPerElem;
7821  if (!CheckedHandleSizeof(Designator.MostDerivedType, BytesPerElem))
7822  return false;
7823 
7824  // According to the GCC documentation, we want the size of the subobject
7825  // denoted by the pointer. But that's not quite right -- what we actually
7826  // want is the size of the immediately-enclosing array, if there is one.
7827  int64_t ElemsRemaining;
7828  if (Designator.MostDerivedIsArrayElement &&
7829  Designator.Entries.size() == Designator.MostDerivedPathLength) {
7830  uint64_t ArraySize = Designator.getMostDerivedArraySize();
7831  uint64_t ArrayIndex = Designator.Entries.back().ArrayIndex;
7832  ElemsRemaining = ArraySize <= ArrayIndex ? 0 : ArraySize - ArrayIndex;
7833  } else {
7834  ElemsRemaining = Designator.isOnePastTheEnd() ? 0 : 1;
7835  }
7836 
7837  EndOffset = LVal.getLValueOffset() + BytesPerElem * ElemsRemaining;
7838  return true;
7839 }
7840 
7841 /// Tries to evaluate the __builtin_object_size for @p E. If successful,
7842 /// returns true and stores the result in @p Size.
7843 ///
7844 /// If @p WasError is non-null, this will report whether the failure to evaluate
7845 /// is to be treated as an Error in IntExprEvaluator.
7846 static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type,
7847  EvalInfo &Info, uint64_t &Size) {
7848  // Determine the denoted object.
7849  LValue LVal;
7850  {
7851  // The operand of __builtin_object_size is never evaluated for side-effects.
7852  // If there are any, but we can determine the pointed-to object anyway, then
7853  // ignore the side-effects.
7854  SpeculativeEvaluationRAII SpeculativeEval(Info);
7855  FoldOffsetRAII Fold(Info);
7856 
7857  if (E->isGLValue()) {
7858  // It's possible for us to be given GLValues if we're called via
7859  // Expr::tryEvaluateObjectSize.
7860  APValue RVal;
7861  if (!EvaluateAsRValue(Info, E, RVal))
7862  return false;
7863  LVal.setFrom(Info.Ctx, RVal);
7864  } else if (!EvaluatePointer(ignorePointerCastsAndParens(E), LVal, Info,
7865  /*InvalidBaseOK=*/true))
7866  return false;
7867  }
7868 
7869  // If we point to before the start of the object, there are no accessible
7870  // bytes.
7871  if (LVal.getLValueOffset().isNegative()) {
7872  Size = 0;
7873  return true;
7874  }
7875 
7876  CharUnits EndOffset;
7877  if (!determineEndOffset(Info, E->getExprLoc(), Type, LVal, EndOffset))
7878  return false;
7879 
7880  // If we've fallen outside of the end offset, just pretend there's nothing to
7881  // write to/read from.
7882  if (EndOffset <= LVal.getLValueOffset())
7883  Size = 0;
7884  else
7885  Size = (EndOffset - LVal.getLValueOffset()).getQuantity();
7886  return true;
7887 }
7888 
7889 bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
7890  if (unsigned BuiltinOp = E->getBuiltinCallee())
7891  return VisitBuiltinCallExpr(E, BuiltinOp);
7892 
7893  return ExprEvaluatorBaseTy::VisitCallExpr(E);
7894 }
7895 
7896 bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
7897  unsigned BuiltinOp) {
7898  switch (unsigned BuiltinOp = E->getBuiltinCallee()) {
7899  default:
7900  return ExprEvaluatorBaseTy::VisitCallExpr(E);
7901 
7902  case Builtin::BI__builtin_object_size: {
7903  // The type was checked when we built the expression.
7904  unsigned Type =
7905  E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
7906  assert(Type <= 3 && "unexpected type");
7907 
7908  uint64_t Size;
7909  if (tryEvaluateBuiltinObjectSize(E->getArg(0), Type, Info, Size))
7910  return Success(Size, E);
7911 
7912  if (E->getArg(0)->HasSideEffects(Info.Ctx))
7913  return Success((Type & 2) ? 0 : -1, E);
7914 
7915  // Expression had no side effects, but we couldn't statically determine the
7916  // size of the referenced object.
7917  switch (Info.EvalMode) {
7918  case EvalInfo::EM_ConstantExpression:
7919  case EvalInfo::EM_PotentialConstantExpression:
7920  case EvalInfo::EM_ConstantFold:
7921  case EvalInfo::EM_EvaluateForOverflow:
7922  case EvalInfo::EM_IgnoreSideEffects:
7923  case EvalInfo::EM_OffsetFold:
7924  // Leave it to IR generation.
7925  return Error(E);
7926  case EvalInfo::EM_ConstantExpressionUnevaluated:
7927  case EvalInfo::EM_PotentialConstantExpressionUnevaluated:
7928  // Reduce it to a constant now.
7929  return Success((Type & 2) ? 0 : -1, E);
7930  }
7931 
7932  llvm_unreachable("unexpected EvalMode");
7933  }
7934 
7935  case Builtin::BI__builtin_bswap16:
7936  case Builtin::BI__builtin_bswap32:
7937  case Builtin::BI__builtin_bswap64: {
7938  APSInt Val;
7939  if (!EvaluateInteger(E->getArg(0), Val, Info))
7940  return false;
7941 
7942  return Success(Val.byteSwap(), E);
7943  }
7944 
7945  case Builtin::BI__builtin_classify_type:
7946  return Success((int)EvaluateBuiltinClassifyType(E, Info.getLangOpts()), E);
7947 
7948  // FIXME: BI__builtin_clrsb
7949  // FIXME: BI__builtin_clrsbl
7950  // FIXME: BI__builtin_clrsbll
7951 
7952  case Builtin::BI__builtin_clz:
7953  case Builtin::BI__builtin_clzl:
7954  case Builtin::BI__builtin_clzll:
7955  case Builtin::BI__builtin_clzs: {
7956  APSInt Val;
7957  if (!EvaluateInteger(E->getArg(0), Val, Info))
7958  return false;
7959  if (!Val)
7960  return Error(E);
7961 
7962  return Success(Val.countLeadingZeros(), E);
7963  }
7964 
7965  case Builtin::BI__builtin_constant_p:
7966  return Success(EvaluateBuiltinConstantP(Info.Ctx, E->getArg(0)), E);
7967 
7968  case Builtin::BI__builtin_ctz:
7969  case Builtin::BI__builtin_ctzl:
7970  case Builtin::BI__builtin_ctzll:
7971  case Builtin::BI__builtin_ctzs: {
7972  APSInt Val;
7973  if (!EvaluateInteger(E->getArg(0), Val, Info))
7974  return false;
7975  if (!Val)
7976  return Error(E);
7977 
7978  return Success(Val.countTrailingZeros(), E);
7979  }
7980 
7981  case Builtin::BI__builtin_eh_return_data_regno: {
7982  int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
7983  Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand);
7984  return Success(Operand, E);
7985  }
7986 
7987  case Builtin::BI__builtin_expect:
7988  return Visit(E->getArg(0));
7989 
7990  case Builtin::BI__builtin_ffs:
7991  case Builtin::BI__builtin_ffsl:
7992  case Builtin::BI__builtin_ffsll: {
7993  APSInt Val;
7994  if (!EvaluateInteger(E->getArg(0), Val, Info))
7995  return false;
7996 
7997  unsigned N = Val.countTrailingZeros();
7998  return Success(N == Val.getBitWidth() ? 0 : N + 1, E);
7999  }
8000 
8001  case Builtin::BI__builtin_fpclassify: {
8002  APFloat Val(0.0);
8003  if (!EvaluateFloat(E->getArg(5), Val, Info))
8004  return false;
8005  unsigned Arg;
8006  switch (Val.getCategory()) {
8007  case APFloat::fcNaN: Arg = 0; break;
8008  case APFloat::fcInfinity: Arg = 1; break;
8009  case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2; break;
8010  case APFloat::fcZero: Arg = 4; break;
8011  }
8012  return Visit(E->getArg(Arg));
8013  }
8014 
8015  case Builtin::BI__builtin_isinf_sign: {
8016  APFloat Val(0.0);
8017  return EvaluateFloat(E->getArg(0), Val, Info) &&
8018  Success(Val.isInfinity() ? (Val.isNegative() ? -1 : 1) : 0, E);
8019  }
8020 
8021  case Builtin::BI__builtin_isinf: {
8022  APFloat Val(0.0);
8023  return EvaluateFloat(E->getArg(0), Val, Info) &&
8024  Success(Val.isInfinity() ? 1 : 0, E);
8025  }
8026 
8027  case Builtin::BI__builtin_isfinite: {
8028  APFloat Val(0.0);
8029  return EvaluateFloat(E->getArg(0), Val, Info) &&
8030  Success(Val.isFinite() ? 1 : 0, E);
8031  }
8032 
8033  case Builtin::BI__builtin_isnan: {
8034  APFloat Val(0.0);
8035  return EvaluateFloat(E->getArg(0), Val, Info) &&
8036  Success(Val.isNaN() ? 1 : 0, E);
8037  }
8038 
8039  case Builtin::BI__builtin_isnormal: {
8040  APFloat Val(0.0);
8041  return EvaluateFloat(E->getArg(0), Val, Info) &&
8042  Success(Val.isNormal() ? 1 : 0, E);
8043  }
8044 
8045  case Builtin::BI__builtin_parity:
8046  case Builtin::BI__builtin_parityl:
8047  case Builtin::BI__builtin_parityll: {
8048  APSInt Val;
8049  if (!EvaluateInteger(E->getArg(0), Val, Info))
8050  return false;
8051 
8052  return Success(Val.countPopulation() % 2, E);
8053  }
8054 
8055  case Builtin::BI__builtin_popcount:
8056  case Builtin::BI__builtin_popcountl:
8057  case Builtin::BI__builtin_popcountll: {
8058  APSInt Val;
8059  if (!EvaluateInteger(E->getArg(0), Val, Info))
8060  return false;
8061 
8062  return Success(Val.countPopulation(), E);
8063  }
8064 
8065  case Builtin::BIstrlen:
8066  case Builtin::BIwcslen:
8067  // A call to strlen is not a constant expression.
8068  if (Info.getLangOpts().CPlusPlus11)
8069  Info.CCEDiag(E, diag::note_constexpr_invalid_function)
8070  << /*isConstexpr*/0 << /*isConstructor*/0
8071  << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
8072  else
8073  Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
8074  LLVM_FALLTHROUGH;
8075  case Builtin::BI__builtin_strlen:
8076  case Builtin::BI__builtin_wcslen: {
8077  // As an extension, we support __builtin_strlen() as a constant expression,
8078  // and support folding strlen() to a constant.
8079  LValue String;
8080  if (!EvaluatePointer(E->getArg(0), String, Info))
8081  return false;
8082 
8083  QualType CharTy = E->getArg(0)->getType()->getPointeeType();
8084 
8085  // Fast path: if it's a string literal, search the string value.
8086  if (const StringLiteral *S = dyn_cast_or_null<StringLiteral>(
8087  String.getLValueBase().dyn_cast<const Expr *>())) {
8088  // The string literal may have embedded null characters. Find the first
8089  // one and truncate there.
8090  StringRef Str = S->getBytes();
8091  int64_t Off = String.Offset.getQuantity();
8092  if (Off >= 0 && (uint64_t)Off <= (uint64_t)Str.size() &&
8093  S->getCharByteWidth() == 1 &&
8094  // FIXME: Add fast-path for wchar_t too.
8095  Info.Ctx.hasSameUnqualifiedType(CharTy, Info.Ctx.CharTy)) {
8096  Str = Str.substr(Off);
8097 
8098  StringRef::size_type Pos = Str.find(0);
8099  if (Pos != StringRef::npos)
8100  Str = Str.substr(0, Pos);
8101 
8102  return Success(Str.size(), E);
8103  }
8104 
8105  // Fall through to slow path to issue appropriate diagnostic.
8106  }
8107 
8108  // Slow path: scan the bytes of the string looking for the terminating 0.
8109  for (uint64_t Strlen = 0; /**/; ++Strlen) {
8110  APValue Char;
8111  if (!handleLValueToRValueConversion(Info, E, CharTy, String, Char) ||
8112  !Char.isInt())
8113  return false;
8114  if (!Char.getInt())
8115  return Success(Strlen, E);
8116  if (!HandleLValueArrayAdjustment(Info, E, String, CharTy, 1))
8117  return false;
8118  }
8119  }
8120 
8121  case Builtin::BIstrcmp:
8122  case Builtin::BIwcscmp:
8123  case Builtin::BIstrncmp:
8124  case Builtin::BIwcsncmp:
8125  case Builtin::BImemcmp:
8126  case Builtin::BIwmemcmp:
8127  // A call to strlen is not a constant expression.
8128  if (Info.getLangOpts().CPlusPlus11)
8129  Info.CCEDiag(E, diag::note_constexpr_invalid_function)
8130  << /*isConstexpr*/0 << /*isConstructor*/0
8131  << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
8132  else
8133  Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
8134  LLVM_FALLTHROUGH;
8135  case Builtin::BI__builtin_strcmp:
8136  case Builtin::BI__builtin_wcscmp:
8137  case Builtin::BI__builtin_strncmp:
8138  case Builtin::BI__builtin_wcsncmp:
8139  case Builtin::BI__builtin_memcmp:
8140  case Builtin::BI__builtin_wmemcmp: {
8141  LValue String1, String2;
8142  if (!EvaluatePointer(E->getArg(0), String1, Info) ||
8143  !EvaluatePointer(E->getArg(1), String2, Info))
8144  return false;
8145 
8146  QualType CharTy = E->getArg(0)->getType()->getPointeeType();
8147 
8148  uint64_t MaxLength = uint64_t(-1);
8149  if (BuiltinOp != Builtin::BIstrcmp &&
8150  BuiltinOp != Builtin::BIwcscmp &&
8151  BuiltinOp != Builtin::BI__builtin_strcmp &&
8152  BuiltinOp != Builtin::BI__builtin_wcscmp) {
8153  APSInt N;
8154  if (!EvaluateInteger(E->getArg(2), N, Info))
8155  return false;
8156  MaxLength = N.getExtValue();
8157  }
8158  bool StopAtNull = (BuiltinOp != Builtin::BImemcmp &&
8159  BuiltinOp != Builtin::BIwmemcmp &&
8160  BuiltinOp != Builtin::BI__builtin_memcmp &&
8161  BuiltinOp != Builtin::BI__builtin_wmemcmp);
8162  bool IsWide = BuiltinOp == Builtin::BIwcscmp ||
8163  BuiltinOp == Builtin::BIwcsncmp ||
8164  BuiltinOp == Builtin::BIwmemcmp ||
8165  BuiltinOp == Builtin::BI__builtin_wcscmp ||
8166  BuiltinOp == Builtin::BI__builtin_wcsncmp ||
8167  BuiltinOp == Builtin::BI__builtin_wmemcmp;
8168  for (; MaxLength; --MaxLength) {
8169  APValue Char1, Char2;
8170  if (!handleLValueToRValueConversion(Info, E, CharTy, String1, Char1) ||
8171  !handleLValueToRValueConversion(Info, E, CharTy, String2, Char2) ||
8172  !Char1.isInt() || !Char2.isInt())
8173  return false;
8174  if (Char1.getInt() != Char2.getInt()) {
8175  if (IsWide) // wmemcmp compares with wchar_t signedness.
8176  return Success(Char1.getInt() < Char2.getInt() ? -1 : 1, E);
8177  // memcmp always compares unsigned chars.
8178  return Success(Char1.getInt().ult(Char2.getInt()) ? -1 : 1, E);
8179  }
8180  if (StopAtNull && !Char1.getInt())
8181  return Success(0, E);
8182  assert(!(StopAtNull && !Char2.getInt()));
8183  if (!HandleLValueArrayAdjustment(Info, E, String1, CharTy, 1) ||
8184  !HandleLValueArrayAdjustment(Info, E, String2, CharTy, 1))
8185  return false;
8186  }
8187  // We hit the strncmp / memcmp limit.
8188  return Success(0, E);
8189  }
8190 
8191  case Builtin::BI__atomic_always_lock_free:
8192  case Builtin::BI__atomic_is_lock_free:
8193  case Builtin::BI__c11_atomic_is_lock_free: {
8194  APSInt SizeVal;
8195  if (!EvaluateInteger(E->getArg(0), SizeVal, Info))
8196  return false;
8197 
8198  // For __atomic_is_lock_free(sizeof(_Atomic(T))), if the size is a power
8199  // of two less than the maximum inline atomic width, we know it is
8200  // lock-free. If the size isn't a power of two, or greater than the
8201  // maximum alignment where we promote atomics, we know it is not lock-free
8202  // (at least not in the sense of atomic_is_lock_free). Otherwise,
8203  // the answer can only be determined at runtime; for example, 16-byte
8204  // atomics have lock-free implementations on some, but not all,
8205  // x86-64 processors.
8206 
8207  // Check power-of-two.
8208  CharUnits Size = CharUnits::fromQuantity(SizeVal.getZExtValue());
8209  if (Size.isPowerOfTwo()) {
8210  // Check against inlining width.
8211  unsigned InlineWidthBits =
8212  Info.Ctx.getTargetInfo().getMaxAtomicInlineWidth();
8213  if (Size <= Info.Ctx.toCharUnitsFromBits(InlineWidthBits)) {
8214  if (BuiltinOp == Builtin::BI__c11_atomic_is_lock_free ||
8215  Size == CharUnits::One() ||
8216  E->getArg(1)->isNullPointerConstant(Info.Ctx,
8218  // OK, we will inline appropriately-aligned operations of this size,
8219  // and _Atomic(T) is appropriately-aligned.
8220  return Success(1, E);
8221 
8222  QualType PointeeType = E->getArg(1)->IgnoreImpCasts()->getType()->
8223  castAs<PointerType>()->getPointeeType();
8224  if (!PointeeType->isIncompleteType() &&
8225  Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) {
8226  // OK, we will inline operations on this object.
8227  return Success(1, E);
8228  }
8229  }
8230  }
8231 
8232  return BuiltinOp == Builtin::BI__atomic_always_lock_free ?
8233  Success(0, E) : Error(E);
8234  }
8235  case Builtin::BIomp_is_initial_device:
8236  // We can decide statically which value the runtime would return if called.
8237  return Success(Info.getLangOpts().OpenMPIsDevice ? 0 : 1, E);
8238  case Builtin::BI__builtin_add_overflow:
8239  case Builtin::BI__builtin_sub_overflow:
8240  case Builtin::BI__builtin_mul_overflow:
8241  case Builtin::BI__builtin_sadd_overflow:
8242  case Builtin::BI__builtin_uadd_overflow:
8243  case Builtin::BI__builtin_uaddl_overflow:
8244  case Builtin::BI__builtin_uaddll_overflow:
8245  case Builtin::BI__builtin_usub_overflow:
8246  case Builtin::BI__builtin_usubl_overflow:
8247  case Builtin::BI__builtin_usubll_overflow:
8248  case Builtin::BI__builtin_umul_overflow:
8249  case Builtin::BI__builtin_umull_overflow:
8250  case Builtin::BI__builtin_umulll_overflow:
8251  case Builtin::BI__builtin_saddl_overflow:
8252  case Builtin::BI__builtin_saddll_overflow:
8253  case Builtin::BI__builtin_ssub_overflow:
8254  case Builtin::BI__builtin_ssubl_overflow:
8255  case Builtin::BI__builtin_ssubll_overflow:
8256  case Builtin::BI__builtin_smul_overflow:
8257  case Builtin::BI__builtin_smull_overflow:
8258  case Builtin::BI__builtin_smulll_overflow: {
8259  LValue ResultLValue;
8260  APSInt LHS, RHS;
8261 
8262  QualType ResultType = E->getArg(2)->getType()->getPointeeType();
8263  if (!EvaluateInteger(E->getArg(0), LHS, Info) ||
8264  !EvaluateInteger(E->getArg(1), RHS, Info) ||
8265  !EvaluatePointer(E->getArg(2), ResultLValue, Info))
8266  return false;
8267 
8268  APSInt Result;
8269  bool DidOverflow = false;
8270 
8271  // If the types don't have to match, enlarge all 3 to the largest of them.
8272  if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
8273  BuiltinOp == Builtin::BI__builtin_sub_overflow ||
8274  BuiltinOp == Builtin::BI__builtin_mul_overflow) {
8275  bool IsSigned = LHS.isSigned() || RHS.isSigned() ||
8276  ResultType->isSignedIntegerOrEnumerationType();
8277  bool AllSigned = LHS.isSigned() && RHS.isSigned() &&
8278  ResultType->isSignedIntegerOrEnumerationType();
8279  uint64_t LHSSize = LHS.getBitWidth();
8280  uint64_t RHSSize = RHS.getBitWidth();
8281  uint64_t ResultSize = Info.Ctx.getTypeSize(ResultType);
8282  uint64_t MaxBits = std::max(std::max(LHSSize, RHSSize), ResultSize);
8283 
8284  // Add an additional bit if the signedness isn't uniformly agreed to. We
8285  // could do this ONLY if there is a signed and an unsigned that both have
8286  // MaxBits, but the code to check that is pretty nasty. The issue will be
8287  // caught in the shrink-to-result later anyway.
8288  if (IsSigned && !AllSigned)
8289  ++MaxBits;
8290 
8291  LHS = APSInt(IsSigned ? LHS.sextOrSelf(MaxBits) : LHS.zextOrSelf(MaxBits),
8292  !IsSigned);
8293  RHS = APSInt(IsSigned ? RHS.sextOrSelf(MaxBits) : RHS.zextOrSelf(MaxBits),
8294  !IsSigned);
8295  Result = APSInt(MaxBits, !IsSigned);
8296  }
8297 
8298  // Find largest int.
8299  switch (BuiltinOp) {
8300  default:
8301  llvm_unreachable("Invalid value for BuiltinOp");
8302  case Builtin::BI__builtin_add_overflow:
8303  case Builtin::BI__builtin_sadd_overflow:
8304  case Builtin::BI__builtin_saddl_overflow:
8305  case Builtin::BI__builtin_saddll_overflow:
8306  case Builtin::BI__builtin_uadd_overflow:
8307  case Builtin::BI__builtin_uaddl_overflow:
8308  case Builtin::BI__builtin_uaddll_overflow:
8309  Result = LHS.isSigned() ? LHS.sadd_ov(RHS, DidOverflow)
8310  : LHS.uadd_ov(RHS, DidOverflow);
8311  break;
8312  case Builtin::BI__builtin_sub_overflow:
8313  case Builtin::BI__builtin_ssub_overflow:
8314  case Builtin::BI__builtin_ssubl_overflow:
8315  case Builtin::BI__builtin_ssubll_overflow:
8316  case Builtin::BI__builtin_usub_overflow:
8317  case Builtin::BI__builtin_usubl_overflow:
8318  case Builtin::BI__builtin_usubll_overflow:
8319  Result = LHS.isSigned() ? LHS.ssub_ov(RHS, DidOverflow)
8320  : LHS.usub_ov(RHS, DidOverflow);
8321  break;
8322  case Builtin::BI__builtin_mul_overflow:
8323  case Builtin::BI__builtin_smul_overflow:
8324  case Builtin::BI__builtin_smull_overflow:
8325  case Builtin::BI__builtin_smulll_overflow:
8326  case Builtin::BI__builtin_umul_overflow:
8327  case Builtin::BI__builtin_umull_overflow:
8328  case Builtin::BI__builtin_umulll_overflow:
8329  Result = LHS.isSigned() ? LHS.smul_ov(RHS, DidOverflow)
8330  : LHS.umul_ov(RHS, DidOverflow);
8331  break;
8332  }
8333 
8334  // In the case where multiple sizes are allowed, truncate and see if
8335  // the values are the same.
8336  if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
8337  BuiltinOp == Builtin::BI__builtin_sub_overflow ||
8338  BuiltinOp == Builtin::BI__builtin_mul_overflow) {
8339  // APSInt doesn't have a TruncOrSelf, so we use extOrTrunc instead,
8340  // since it will give us the behavior of a TruncOrSelf in the case where
8341  // its parameter <= its size. We previously set Result to be at least the
8342  // type-size of the result, so getTypeSize(ResultType) <= Result.BitWidth
8343  // will work exactly like TruncOrSelf.
8344  APSInt Temp = Result.extOrTrunc(Info.Ctx.getTypeSize(ResultType));
8345  Temp.setIsSigned(ResultType->isSignedIntegerOrEnumerationType());
8346 
8347  if (!APSInt::isSameValue(Temp, Result))
8348  DidOverflow = true;
8349  Result = Temp;
8350  }
8351 
8352  APValue APV{Result};
8353  if (!handleAssignment(Info, E, ResultLValue, ResultType, APV))
8354  return false;
8355  return Success(DidOverflow, E);
8356  }
8357  }
8358 }
8359 
8360 static bool HasSameBase(const LValue &A, const LValue &B) {
8361  if (!A.getLValueBase())
8362  return !B.getLValueBase();
8363  if (!B.getLValueBase())
8364  return false;
8365 
8366  if (A.getLValueBase().getOpaqueValue() !=
8367  B.getLValueBase().getOpaqueValue()) {
8368  const Decl *ADecl = GetLValueBaseDecl(A);
8369  if (!ADecl)
8370  return false;
8371  const Decl *BDecl = GetLValueBaseDecl(B);
8372  if (!BDecl || ADecl->getCanonicalDecl() != BDecl->getCanonicalDecl())
8373  return false;
8374  }
8375 
8376  return IsGlobalLValue(A.getLValueBase()) ||
8377  (A.getLValueCallIndex() == B.getLValueCallIndex() &&
8378  A.getLValueVersion() == B.getLValueVersion());
8379 }
8380 
8381 /// Determine whether this is a pointer past the end of the complete
8382 /// object referred to by the lvalue.
8384  const LValue &LV) {
8385  // A null pointer can be viewed as being "past the end" but we don't
8386  // choose to look at it that way here.
8387  if (!LV.getLValueBase())
8388  return false;
8389 
8390  // If the designator is valid and refers to a subobject, we're not pointing
8391  // past the end.
8392  if (!LV.getLValueDesignator().Invalid &&
8393  !LV.getLValueDesignator().isOnePastTheEnd())
8394  return false;
8395 
8396  // A pointer to an incomplete type might be past-the-end if the type's size is
8397  // zero. We cannot tell because the type is incomplete.
8398  QualType Ty = getType(LV.getLValueBase());
8399  if (Ty->isIncompleteType())
8400  return true;
8401 
8402  // We're a past-the-end pointer if we point to the byte after the object,
8403  // no matter what our type or path is.
8404  auto Size = Ctx.getTypeSizeInChars(Ty);
8405  return LV.getLValueOffset() == Size;
8406 }
8407 
8408 namespace {
8409 
8410 /// Data recursive integer evaluator of certain binary operators.
8411 ///
8412 /// We use a data recursive algorithm for binary operators so that we are able
8413 /// to handle extreme cases of chained binary operators without causing stack
8414 /// overflow.
8415 class DataRecursiveIntBinOpEvaluator {
8416  struct EvalResult {
8417  APValue Val;
8418  bool Failed;
8419 
8420  EvalResult() : Failed(false) { }
8421 
8422  void swap(EvalResult &RHS) {
8423  Val.swap(RHS.Val);
8424  Failed = RHS.Failed;
8425  RHS.Failed = false;
8426  }
8427  };
8428 
8429  struct Job {
8430  const Expr *E;
8431  EvalResult LHSResult; // meaningful only for binary operator expression.
8432  enum { AnyExprKind, BinOpKind, BinOpVisitedLHSKind } Kind;
8433 
8434  Job() = default;
8435  Job(Job &&) = default;
8436 
8437  void startSpeculativeEval(EvalInfo &Info) {
8438  SpecEvalRAII = SpeculativeEvaluationRAII(Info);
8439  }
8440 
8441  private:
8442  SpeculativeEvaluationRAII SpecEvalRAII;
8443  };
8444 
8445  SmallVector<Job, 16> Queue;
8446 
8447  IntExprEvaluator &IntEval;
8448  EvalInfo &Info;
8449  APValue &FinalResult;
8450 
8451 public:
8452  DataRecursiveIntBinOpEvaluator(IntExprEvaluator &IntEval, APValue &Result)
8453  : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { }
8454 
8455  /// True if \param E is a binary operator that we are going to handle
8456  /// data recursively.
8457  /// We handle binary operators that are comma, logical, or that have operands
8458  /// with integral or enumeration type.
8459  static bool shouldEnqueue(const BinaryOperator *E) {
8460  return E->getOpcode() == BO_Comma || E->isLogicalOp() ||
8461  (E->isRValue() && E->getType()->isIntegralOrEnumerationType() &&
8464  }
8465 
8466  bool Traverse(const BinaryOperator *E) {
8467  enqueue(E);
8468  EvalResult PrevResult;
8469  while (!Queue.empty())
8470  process(PrevResult);
8471 
8472  if (PrevResult.Failed) return false;
8473 
8474  FinalResult.swap(PrevResult.Val);
8475  return true;
8476  }
8477 
8478 private:
8479  bool Success(uint64_t Value, const Expr *E, APValue &Result) {
8480  return IntEval.Success(Value, E, Result);
8481  }
8482  bool Success(const APSInt &Value, const Expr *E, APValue &Result) {
8483  return IntEval.Success(Value, E, Result);
8484  }
8485  bool Error(const Expr *E) {
8486  return IntEval.Error(E);
8487  }
8488  bool Error(const Expr *E, diag::kind D) {
8489  return IntEval.Error(E, D);
8490  }
8491 
8492  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
8493  return Info.CCEDiag(E, D);
8494  }
8495 
8496  // Returns true if visiting the RHS is necessary, false otherwise.
8497  bool VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
8498  bool &SuppressRHSDiags);
8499 
8500  bool VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
8501  const BinaryOperator *E, APValue &Result);
8502 
8503  void EvaluateExpr(const Expr *E, EvalResult &Result) {
8504  Result.Failed = !Evaluate(Result.Val, Info, E);
8505  if (Result.Failed)
8506  Result.Val = APValue();
8507  }
8508 
8509  void process(EvalResult &Result);
8510 
8511  void enqueue(const Expr *E) {
8512  E = E->IgnoreParens();
8513  Queue.resize(Queue.size()+1);
8514  Queue.back().E = E;
8515  Queue.back().Kind = Job::AnyExprKind;
8516  }
8517 };
8518 
8519 }
8520 
8521 bool DataRecursiveIntBinOpEvaluator::
8522  VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
8523  bool &SuppressRHSDiags) {
8524  if (E->getOpcode() == BO_Comma) {
8525  // Ignore LHS but note if we could not evaluate it.
8526  if (LHSResult.Failed)
8527  return Info.noteSideEffect();
8528  return true;
8529  }
8530 
8531  if (E->isLogicalOp()) {
8532  bool LHSAsBool;
8533  if (!LHSResult.Failed && HandleConversionToBool(LHSResult.Val, LHSAsBool)) {
8534  // We were able to evaluate the LHS, see if we can get away with not
8535  // evaluating the RHS: 0 && X -> 0, 1 || X -> 1
8536  if (LHSAsBool == (E->getOpcode() == BO_LOr)) {
8537  Success(LHSAsBool, E, LHSResult.Val);
8538  return false; // Ignore RHS
8539  }
8540  } else {
8541  LHSResult.Failed = true;
8542 
8543  // Since we weren't able to evaluate the left hand side, it
8544  // might have had side effects.
8545  if (!Info.noteSideEffect())
8546  return false;
8547 
8548  // We can't evaluate the LHS; however, sometimes the result
8549  // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
8550  // Don't ignore RHS and suppress diagnostics from this arm.
8551  SuppressRHSDiags = true;
8552  }
8553 
8554  return true;
8555  }
8556 
8557  assert(E->getLHS()->getType()->isIntegralOrEnumerationType() &&
8559 
8560  if (LHSResult.Failed && !Info.noteFailure())
8561  return false; // Ignore RHS;
8562 
8563  return true;
8564 }
8565 
8566 static void addOrSubLValueAsInteger(APValue &LVal, const APSInt &Index,
8567  bool IsSub) {
8568  // Compute the new offset in the appropriate width, wrapping at 64 bits.
8569  // FIXME: When compiling for a 32-bit target, we should use 32-bit
8570  // offsets.
8571  assert(!LVal.hasLValuePath() && "have designator for integer lvalue");
8572  CharUnits &Offset = LVal.getLValueOffset();
8573  uint64_t Offset64 = Offset.getQuantity();
8574  uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
8575  Offset = CharUnits::fromQuantity(IsSub ? Offset64 - Index64
8576  : Offset64 + Index64);
8577 }
8578 
8579 bool DataRecursiveIntBinOpEvaluator::
8580  VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
8581  const BinaryOperator *E, APValue &Result) {
8582  if (E->getOpcode() == BO_Comma) {
8583  if (RHSResult.Failed)
8584  return false;
8585  Result = RHSResult.Val;
8586  return true;
8587  }
8588 
8589  if (E->isLogicalOp()) {
8590  bool lhsResult, rhsResult;
8591  bool LHSIsOK = HandleConversionToBool(LHSResult.Val, lhsResult);
8592  bool RHSIsOK = HandleConversionToBool(RHSResult.Val, rhsResult);
8593 
8594  if (LHSIsOK) {
8595  if (RHSIsOK) {
8596  if (E->getOpcode() == BO_LOr)
8597  return Success(lhsResult || rhsResult, E, Result);
8598  else
8599  return Success(lhsResult && rhsResult, E, Result);
8600  }
8601  } else {
8602  if (RHSIsOK) {
8603  // We can't evaluate the LHS; however, sometimes the result
8604  // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
8605  if (rhsResult == (E->getOpcode() == BO_LOr))
8606  return Success(rhsResult, E, Result);
8607  }
8608  }
8609 
8610  return false;
8611  }
8612 
8613  assert(E->getLHS()->getType()->isIntegralOrEnumerationType() &&
8615 
8616  if (LHSResult.Failed || RHSResult.Failed)
8617  return false;
8618 
8619  const APValue &LHSVal = LHSResult.Val;
8620  const APValue &RHSVal = RHSResult.Val;
8621 
8622  // Handle cases like (unsigned long)&a + 4.
8623  if (E->isAdditiveOp() && LHSVal.isLValue() && RHSVal.isInt()) {
8624  Result = LHSVal;
8625  addOrSubLValueAsInteger(Result, RHSVal.getInt(), E->getOpcode() == BO_Sub);
8626  return true;
8627  }
8628 
8629  // Handle cases like 4 + (unsigned long)&a
8630  if (E->getOpcode() == BO_Add &&
8631  RHSVal.isLValue() && LHSVal.isInt()) {
8632  Result = RHSVal;
8633  addOrSubLValueAsInteger(Result, LHSVal.getInt(), /*IsSub*/false);
8634  return true;
8635  }
8636 
8637  if (E->getOpcode() == BO_Sub && LHSVal.isLValue() && RHSVal.isLValue()) {
8638  // Handle (intptr_t)&&A - (intptr_t)&&B.
8639  if (!LHSVal.getLValueOffset().isZero() ||
8640  !RHSVal.getLValueOffset().isZero())
8641  return false;
8642  const Expr *LHSExpr = LHSVal.getLValueBase().dyn_cast<const Expr*>();
8643  const Expr *RHSExpr = RHSVal.getLValueBase().dyn_cast<const Expr*>();
8644  if (!LHSExpr || !RHSExpr)
8645  return false;
8646  const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
8647  const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
8648  if (!LHSAddrExpr || !RHSAddrExpr)
8649  return false;
8650  // Make sure both labels come from the same function.
8651  if (LHSAddrExpr->getLabel()->getDeclContext() !=
8652  RHSAddrExpr->getLabel()->getDeclContext())
8653  return false;
8654  Result = APValue(LHSAddrExpr, RHSAddrExpr);
8655  return true;
8656  }
8657 
8658  // All the remaining cases expect both operands to be an integer
8659  if (!LHSVal.isInt() || !RHSVal.isInt())
8660  return Error(E);
8661 
8662  // Set up the width and signedness manually, in case it can't be deduced
8663  // from the operation we're performing.
8664  // FIXME: Don't do this in the cases where we can deduce it.
8665  APSInt Value(Info.Ctx.getIntWidth(E->getType()),
8667  if (!handleIntIntBinOp(Info, E, LHSVal.getInt(), E->getOpcode(),
8668  RHSVal.getInt(), Value))
8669  return false;
8670  return Success(Value, E, Result);
8671 }
8672 
8673 void DataRecursiveIntBinOpEvaluator::process(EvalResult &Result) {
8674  Job &job = Queue.back();
8675 
8676  switch (job.Kind) {
8677  case Job::AnyExprKind: {
8678  if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(job.E)) {
8679  if (shouldEnqueue(Bop)) {
8680  job.Kind = Job::BinOpKind;
8681  enqueue(Bop->getLHS());
8682  return;
8683  }
8684  }
8685 
8686  EvaluateExpr(job.E, Result);
8687  Queue.pop_back();
8688  return;
8689  }
8690 
8691  case Job::BinOpKind: {
8692  const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
8693  bool SuppressRHSDiags = false;
8694  if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) {
8695  Queue.pop_back();
8696  return;
8697  }
8698  if (SuppressRHSDiags)
8699  job.startSpeculativeEval(Info);
8700  job.LHSResult.swap(Result);
8701  job.Kind = Job::BinOpVisitedLHSKind;
8702  enqueue(Bop->getRHS());
8703  return;
8704  }
8705 
8706  case Job::BinOpVisitedLHSKind: {
8707  const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
8708  EvalResult RHS;
8709  RHS.swap(Result);
8710  Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val);
8711  Queue.pop_back();
8712  return;
8713  }
8714  }
8715 
8716  llvm_unreachable("Invalid Job::Kind!");
8717 }
8718 
8719 namespace {
8720 /// Used when we determine that we should fail, but can keep evaluating prior to
8721 /// noting that we had a failure.
8722 class DelayedNoteFailureRAII {
8723  EvalInfo &Info;
8724  bool NoteFailure;
8725 
8726 public:
8727  DelayedNoteFailureRAII(EvalInfo &Info, bool NoteFailure = true)
8728  : Info(Info), NoteFailure(NoteFailure) {}
8729  ~DelayedNoteFailureRAII() {
8730  if (NoteFailure) {
8731  bool ContinueAfterFailure = Info.noteFailure();
8732  (void)ContinueAfterFailure;
8733  assert(ContinueAfterFailure &&
8734  "Shouldn't have kept evaluating on failure.");
8735  }
8736  }
8737 };
8738 }
8739 
8740 template <class SuccessCB, class AfterCB>
8741 static bool
8743  SuccessCB &&Success, AfterCB &&DoAfter) {
8744  assert(E->isComparisonOp() && "expected comparison operator");
8745  assert((E->getOpcode() == BO_Cmp ||
8747  "unsupported binary expression evaluation");
8748  auto Error = [&](const Expr *E) {
8749  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
8750  return false;
8751  };
8752 
8753  using CCR = ComparisonCategoryResult;
8754  bool IsRelational = E->isRelationalOp();
8755  bool IsEquality = E->isEqualityOp();
8756  if (E->getOpcode() == BO_Cmp) {
8757  const ComparisonCategoryInfo &CmpInfo =
8758  Info.Ctx.CompCategories.getInfoForType(E->getType());
8759  IsRelational = CmpInfo.isOrdered();
8760  IsEquality = CmpInfo.isEquality();
8761  }
8762 
8763  QualType LHSTy = E->getLHS()->getType();
8764  QualType RHSTy = E->getRHS()->getType();
8765 
8766  if (LHSTy->isIntegralOrEnumerationType() &&
8767  RHSTy->isIntegralOrEnumerationType()) {
8768  APSInt LHS, RHS;
8769  bool LHSOK = EvaluateInteger(E->getLHS(), LHS, Info);
8770  if (!LHSOK && !Info.noteFailure())
8771  return false;
8772  if (!EvaluateInteger(E->getRHS(), RHS, Info) || !LHSOK)
8773  return false;
8774  if (LHS < RHS)
8775  return Success(CCR::Less, E);
8776  if (LHS > RHS)
8777  return Success(CCR::Greater, E);
8778  return Success(CCR::Equal, E);
8779  }
8780 
8781  if (LHSTy->isAnyComplexType() || RHSTy->isAnyComplexType()) {
8782  ComplexValue LHS, RHS;
8783  bool LHSOK;
8784  if (E->isAssignmentOp()) {
8785  LValue LV;
8786  EvaluateLValue(E->getLHS(), LV, Info);
8787  LHSOK = false;
8788  } else if (LHSTy->isRealFloatingType()) {
8789  LHSOK = EvaluateFloat(E->getLHS(), LHS.FloatReal, Info);
8790  if (LHSOK) {
8791  LHS.makeComplexFloat();
8792  LHS.FloatImag = APFloat(LHS.FloatReal.getSemantics());
8793  }
8794  } else {
8795  LHSOK = EvaluateComplex(E->getLHS(), LHS, Info);
8796  }
8797  if (!LHSOK && !Info.noteFailure())
8798  return false;
8799 
8800  if (E->getRHS()->getType()->isRealFloatingType()) {
8801  if (!EvaluateFloat(E->getRHS(), RHS.FloatReal, Info) || !LHSOK)
8802  return false;
8803  RHS.makeComplexFloat();
8804  RHS.FloatImag = APFloat(RHS.FloatReal.getSemantics());
8805  } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
8806  return false;
8807 
8808  if (LHS.isComplexFloat()) {
8809  APFloat::cmpResult CR_r =
8810  LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal());
8811  APFloat::cmpResult CR_i =
8812  LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag());
8813  bool IsEqual = CR_r == APFloat::cmpEqual && CR_i == APFloat::cmpEqual;
8814  return Success(IsEqual ? CCR::Equal : CCR::Nonequal, E);
8815  } else {
8816  assert(IsEquality && "invalid complex comparison");
8817  bool IsEqual = LHS.getComplexIntReal() == RHS.getComplexIntReal() &&
8818  LHS.getComplexIntImag() == RHS.getComplexIntImag();
8819  return Success(IsEqual ? CCR::Equal : CCR::Nonequal, E);
8820  }
8821  }
8822 
8823  if (LHSTy->isRealFloatingType() &&
8824  RHSTy->isRealFloatingType()) {
8825  APFloat RHS(0.0), LHS(0.0);
8826 
8827  bool LHSOK = EvaluateFloat(E->getRHS(), RHS, Info);
8828  if (!LHSOK && !Info.noteFailure())
8829  return false;
8830 
8831  if (!EvaluateFloat(E->getLHS(), LHS, Info) || !LHSOK)
8832  return false;
8833 
8834  assert(E->isComparisonOp() && "Invalid binary operator!");
8835  auto GetCmpRes = [&]() {
8836  switch (LHS.compare(RHS)) {
8837  case APFloat::cmpEqual:
8838  return CCR::Equal;
8839  case APFloat::cmpLessThan:
8840  return CCR::Less;
8841  case APFloat::cmpGreaterThan:
8842  return CCR::Greater;
8843  case APFloat::cmpUnordered:
8844  return CCR::Unordered;
8845  }
8846  llvm_unreachable("Unrecognised APFloat::cmpResult enum");
8847  };
8848  return Success(GetCmpRes(), E);
8849  }
8850 
8851  if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
8852  LValue LHSValue, RHSValue;
8853 
8854  bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info);
8855  if (!LHSOK && !Info.noteFailure())
8856  return false;
8857 
8858  if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK)
8859  return false;
8860 
8861  // Reject differing bases from the normal codepath; we special-case
8862  // comparisons to null.
8863  if (!HasSameBase(LHSValue, RHSValue)) {
8864  // Inequalities and subtractions between unrelated pointers have
8865  // unspecified or undefined behavior.
8866  if (!IsEquality)
8867  return Error(E);
8868  // A constant address may compare equal to the address of a symbol.
8869  // The one exception is that address of an object cannot compare equal
8870  // to a null pointer constant.
8871  if ((!LHSValue.Base && !LHSValue.Offset.isZero()) ||
8872  (!RHSValue.Base && !RHSValue.Offset.isZero()))
8873  return Error(E);
8874  // It's implementation-defined whether distinct literals will have
8875  // distinct addresses. In clang, the result of such a comparison is
8876  // unspecified, so it is not a constant expression. However, we do know
8877  // that the address of a literal will be non-null.
8878  if ((IsLiteralLValue(LHSValue) || IsLiteralLValue(RHSValue)) &&
8879  LHSValue.Base && RHSValue.Base)
8880  return Error(E);
8881  // We can't tell whether weak symbols will end up pointing to the same
8882  // object.
8883  if (IsWeakLValue(LHSValue) || IsWeakLValue(RHSValue))
8884  return Error(E);
8885  // We can't compare the address of the start of one object with the
8886  // past-the-end address of another object, per C++ DR1652.
8887  if ((LHSValue.Base && LHSValue.Offset.isZero() &&
8888  isOnePastTheEndOfCompleteObject(Info.Ctx, RHSValue)) ||
8889  (RHSValue.Base && RHSValue.Offset.isZero() &&
8890  isOnePastTheEndOfCompleteObject(Info.Ctx, LHSValue)))
8891  return Error(E);
8892  // We can't tell whether an object is at the same address as another
8893  // zero sized object.
8894  if ((RHSValue.Base && isZeroSized(LHSValue)) ||
8895  (LHSValue.Base && isZeroSized(RHSValue)))
8896  return Error(E);
8897  return Success(CCR::Nonequal, E);
8898  }
8899 
8900  const CharUnits &LHSOffset = LHSValue.getLValueOffset();
8901  const CharUnits &RHSOffset = RHSValue.getLValueOffset();
8902 
8903  SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
8904  SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
8905 
8906  // C++11 [expr.rel]p3:
8907  // Pointers to void (after pointer conversions) can be compared, with a
8908  // result defined as follows: If both pointers represent the same
8909  // address or are both the null pointer value, the result is true if the
8910  // operator is <= or >= and false otherwise; otherwise the result is
8911  // unspecified.
8912  // We interpret this as applying to pointers to *cv* void.
8913  if (LHSTy->isVoidPointerType() && LHSOffset != RHSOffset && IsRelational)
8914  Info.CCEDiag(E, diag::note_constexpr_void_comparison);
8915 
8916  // C++11 [expr.rel]p2:
8917  // - If two pointers point to non-static data members of the same object,
8918  // or to subobjects or array elements fo such members, recursively, the
8919  // pointer to the later declared member compares greater provided the
8920  // two members have the same access control and provided their class is
8921  // not a union.
8922  // [...]
8923  // - Otherwise pointer comparisons are unspecified.
8924  if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && IsRelational) {
8925  bool WasArrayIndex;
8926  unsigned Mismatch = FindDesignatorMismatch(
8927  getType(LHSValue.Base), LHSDesignator, RHSDesignator, WasArrayIndex);
8928  // At the point where the designators diverge, the comparison has a
8929  // specified value if:
8930  // - we are comparing array indices
8931  // - we are comparing fields of a union, or fields with the same access
8932  // Otherwise, the result is unspecified and thus the comparison is not a
8933  // constant expression.
8934  if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() &&
8935  Mismatch < RHSDesignator.Entries.size()) {
8936  const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]);
8937  const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]);
8938  if (!LF && !RF)
8939  Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes);
8940  else if (!LF)
8941  Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
8942  << getAsBaseClass(LHSDesignator.Entries[Mismatch])
8943  << RF->getParent() << RF;
8944  else if (!RF)
8945  Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
8946  << getAsBaseClass(RHSDesignator.Entries[Mismatch])
8947  << LF->getParent() << LF;
8948  else if (!LF->getParent()->isUnion() &&
8949  LF->getAccess() != RF->getAccess())
8950  Info.CCEDiag(E,
8951  diag::note_constexpr_pointer_comparison_differing_access)
8952  << LF << LF->getAccess() << RF << RF->getAccess()
8953  << LF->getParent();
8954  }
8955  }
8956 
8957  // The comparison here must be unsigned, and performed with the same
8958  // width as the pointer.
8959  unsigned PtrSize = Info.Ctx.getTypeSize(LHSTy);
8960  uint64_t CompareLHS = LHSOffset.getQuantity();
8961  uint64_t CompareRHS = RHSOffset.getQuantity();
8962  assert(PtrSize <= 64 && "Unexpected pointer width");
8963  uint64_t Mask = ~0ULL >> (64 - PtrSize);
8964  CompareLHS &= Mask;
8965  CompareRHS &= Mask;
8966 
8967  // If there is a base and this is a relational operator, we can only
8968  // compare pointers within the object in question; otherwise, the result
8969  // depends on where the object is located in memory.
8970  if (!LHSValue.Base.isNull() && IsRelational) {
8971  QualType BaseTy = getType(LHSValue.Base);
8972  if (BaseTy->isIncompleteType())
8973  return Error(E);
8974  CharUnits Size = Info.Ctx.getTypeSizeInChars(BaseTy);
8975  uint64_t OffsetLimit = Size.getQuantity();
8976  if (CompareLHS > OffsetLimit || CompareRHS > OffsetLimit)
8977  return Error(E);
8978  }
8979 
8980  if (CompareLHS < CompareRHS)
8981  return Success(CCR::Less, E);
8982  if (CompareLHS > CompareRHS)
8983  return Success(CCR::Greater, E);
8984  return Success(CCR::Equal, E);
8985  }
8986 
8987  if (LHSTy->isMemberPointerType()) {
8988  assert(IsEquality && "unexpected member pointer operation");
8989  assert(RHSTy->isMemberPointerType() && "invalid comparison");
8990 
8991  MemberPtr LHSValue, RHSValue;
8992 
8993  bool LHSOK = EvaluateMemberPointer(E->getLHS(), LHSValue, Info);
8994  if (!LHSOK && !Info.noteFailure())
8995  return false;
8996 
8997  if (!EvaluateMemberPointer(E->getRHS(), RHSValue, Info) || !LHSOK)
8998  return false;
8999 
9000  // C++11 [expr.eq]p2:
9001  // If both operands are null, they compare equal. Otherwise if only one is
9002  // null, they compare unequal.
9003  if (!LHSValue.getDecl() || !RHSValue.getDecl()) {
9004  bool Equal = !LHSValue.getDecl() && !RHSValue.getDecl();
9005  return Success(Equal ? CCR::Equal : CCR::Nonequal, E);
9006  }
9007 
9008  // Otherwise if either is a pointer to a virtual member function, the
9009  // result is unspecified.
9010  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl()))
9011  if (MD->isVirtual())
9012  Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
9013  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl()))
9014  if (MD->isVirtual())
9015  Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
9016 
9017  // Otherwise they compare equal if and only if they would refer to the
9018  // same member of the same most derived object or the same subobject if
9019  // they were dereferenced with a hypothetical object of the associated
9020  // class type.
9021  bool Equal = LHSValue == RHSValue;
9022  return Success(Equal ? CCR::Equal : CCR::Nonequal, E);
9023  }
9024 
9025  if (LHSTy->isNullPtrType()) {
9026  assert(E->isComparisonOp() && "unexpected nullptr operation");
9027  assert(RHSTy->isNullPtrType() && "missing pointer conversion");
9028  // C++11 [expr.rel]p4, [expr.eq]p3: If two operands of type std::nullptr_t
9029  // are compared, the result is true of the operator is <=, >= or ==, and
9030  // false otherwise.
9031  return Success(CCR::Equal, E);
9032  }
9033 
9034  return DoAfter();
9035 }
9036 
9037 bool RecordExprEvaluator::VisitBinCmp(const BinaryOperator *E) {
9038  if (!CheckLiteralType(Info, E))
9039  return false;
9040 
9041  auto OnSuccess = [&](ComparisonCategoryResult ResKind,
9042  const BinaryOperator *E) {
9043  // Evaluation succeeded. Lookup the information for the comparison category
9044  // type and fetch the VarDecl for the result.
9045  const ComparisonCategoryInfo &CmpInfo =
9046  Info.Ctx.CompCategories.getInfoForType(E->getType());
9047  const VarDecl *VD =
9048  CmpInfo.getValueInfo(CmpInfo.makeWeakResult(ResKind))->VD;
9049  // Check and evaluate the result as a constant expression.
9050  LValue LV;
9051  LV.set(VD);
9052  if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
9053  return false;
9054  return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result);
9055  };
9056  return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
9057  return ExprEvaluatorBaseTy::VisitBinCmp(E);
9058  });
9059 }
9060 
9061 bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
9062  // We don't call noteFailure immediately because the assignment happens after
9063  // we evaluate LHS and RHS.
9064  if (!Info.keepEvaluatingAfterFailure() && E->isAssignmentOp())
9065  return Error(E);
9066 
9067  DelayedNoteFailureRAII MaybeNoteFailureLater(Info, E->isAssignmentOp());
9068  if (DataRecursiveIntBinOpEvaluator::shouldEnqueue(E))
9069  return DataRecursiveIntBinOpEvaluator(*this, Result).Traverse(E);
9070 
9071  assert((!E->getLHS()->getType()->isIntegralOrEnumerationType() ||
9073  "DataRecursiveIntBinOpEvaluator should have handled integral types");
9074 
9075  if (E->isComparisonOp()) {
9076  // Evaluate builtin binary comparisons by evaluating them as C++2a three-way
9077  // comparisons and then translating the result.
9078  auto OnSuccess = [&](ComparisonCategoryResult ResKind,
9079  const BinaryOperator *E) {
9080  using CCR = ComparisonCategoryResult;
9081  bool IsEqual = ResKind == CCR::Equal,
9082  IsLess = ResKind == CCR::Less,
9083  IsGreater = ResKind == CCR::Greater;
9084  auto Op = E->getOpcode();
9085  switch (Op) {
9086  default:
9087  llvm_unreachable("unsupported binary operator");
9088  case BO_EQ:
9089  case BO_NE:
9090  return Success(IsEqual == (Op == BO_EQ), E);
9091  case BO_LT: return Success(IsLess, E);
9092  case BO_GT: return Success(IsGreater, E);
9093  case BO_LE: return Success(IsEqual || IsLess, E);
9094  case BO_GE: return Success(IsEqual || IsGreater, E);
9095  }
9096  };
9097  return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
9098  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
9099  });
9100  }
9101 
9102  QualType LHSTy = E->getLHS()->getType();
9103  QualType RHSTy = E->getRHS()->getType();
9104 
9105  if (LHSTy->isPointerType() && RHSTy->isPointerType() &&
9106  E->getOpcode() == BO_Sub) {
9107  LValue LHSValue, RHSValue;
9108 
9109  bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info);
9110  if (!LHSOK && !Info.noteFailure())
9111  return false;
9112 
9113  if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK)
9114  return false;
9115 
9116  // Reject differing bases from the normal codepath; we special-case
9117  // comparisons to null.
9118  if (!HasSameBase(LHSValue, RHSValue)) {
9119  // Handle &&A - &&B.
9120  if (!LHSValue.Offset.isZero() || !RHSValue.Offset.isZero())
9121  return Error(E);
9122  const Expr *LHSExpr = LHSValue.Base.dyn_cast<const Expr *>();
9123  const Expr *RHSExpr = RHSValue.Base.dyn_cast<const Expr *>();
9124  if (!LHSExpr || !RHSExpr)
9125  return Error(E);
9126  const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
9127  const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
9128  if (!LHSAddrExpr || !RHSAddrExpr)
9129  return Error(E);
9130  // Make sure both labels come from the same function.
9131  if (LHSAddrExpr->getLabel()->getDeclContext() !=
9132  RHSAddrExpr->getLabel()->getDeclContext())
9133  return Error(E);
9134  return Success(APValue(LHSAddrExpr, RHSAddrExpr), E);
9135  }
9136  const CharUnits &LHSOffset = LHSValue.getLValueOffset();
9137  const CharUnits &RHSOffset = RHSValue.getLValueOffset();
9138 
9139  SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
9140  SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
9141 
9142  // C++11 [expr.add]p6:
9143  // Unless both pointers point to elements of the same array object, or
9144  // one past the last element of the array object, the behavior is
9145  // undefined.
9146  if (!LHSDesignator.Invalid && !RHSDesignator.Invalid &&
9147  !AreElementsOfSameArray(getType(LHSValue.Base), LHSDesignator,
9148  RHSDesignator))
9149  Info.CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array);
9150 
9151  QualType Type = E->getLHS()->getType();
9152  QualType ElementType = Type->getAs<PointerType>()->getPointeeType();
9153 
9154  CharUnits ElementSize;
9155  if (!HandleSizeof(Info, E->getExprLoc(), ElementType, ElementSize))
9156  return false;
9157 
9158  // As an extension, a type may have zero size (empty struct or union in
9159  // C, array of zero length). Pointer subtraction in such cases has
9160  // undefined behavior, so is not constant.
9161  if (ElementSize.isZero()) {
9162  Info.FFDiag(E, diag::note_constexpr_pointer_subtraction_zero_size)
9163  << ElementType;
9164  return false;
9165  }
9166 
9167  // FIXME: LLVM and GCC both compute LHSOffset - RHSOffset at runtime,
9168  // and produce incorrect results when it overflows. Such behavior
9169  // appears to be non-conforming, but is common, so perhaps we should
9170  // assume the standard intended for such cases to be undefined behavior
9171  // and check for them.
9172 
9173  // Compute (LHSOffset - RHSOffset) / Size carefully, checking for
9174  // overflow in the final conversion to ptrdiff_t.
9175  APSInt LHS(llvm::APInt(65, (int64_t)LHSOffset.getQuantity(), true), false);
9176  APSInt RHS(llvm::APInt(65, (int64_t)RHSOffset.getQuantity(), true), false);
9177  APSInt ElemSize(llvm::APInt(65, (int64_t)ElementSize.getQuantity(), true),
9178  false);
9179  APSInt TrueResult = (LHS - RHS) / ElemSize;
9180  APSInt Result = TrueResult.trunc(Info.Ctx.getIntWidth(E->getType()));
9181 
9182  if (Result.extend(65) != TrueResult &&
9183  !HandleOverflow(Info, E, TrueResult, E->getType()))
9184  return false;
9185  return Success(Result, E);
9186  }
9187 
9188  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
9189 }
9190 
9191 /// VisitUnaryExprOrTypeTraitExpr - Evaluate a sizeof, alignof or vec_step with
9192 /// a result as the expression's type.
9193 bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr(
9194  const UnaryExprOrTypeTraitExpr *E) {
9195  switch(E->getKind()) {
9196  case UETT_AlignOf: {
9197  if (E->isArgumentType())
9198  return Success(GetAlignOfType(Info, E->getArgumentType()), E);
9199  else
9200  return Success(GetAlignOfExpr(Info, E->getArgumentExpr()), E);
9201  }
9202 
9203  case UETT_VecStep: {
9204  QualType Ty = E->getTypeOfArgument();
9205 
9206  if (Ty->isVectorType()) {
9207  unsigned n = Ty->castAs<VectorType>()->getNumElements();
9208 
9209  // The vec_step built-in functions that take a 3-component
9210  // vector return 4. (OpenCL 1.1 spec 6.11.12)
9211  if (n == 3)
9212  n = 4;
9213 
9214  return Success(n, E);
9215  } else
9216  return Success(1, E);
9217  }
9218 
9219  case UETT_SizeOf: {
9220  QualType SrcTy = E->getTypeOfArgument();
9221  // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
9222  // the result is the size of the referenced type."
9223  if (const ReferenceType *Ref = SrcTy->getAs<ReferenceType>())
9224  SrcTy = Ref->getPointeeType();
9225 
9226  CharUnits Sizeof;
9227  if (!HandleSizeof(Info, E->getExprLoc(), SrcTy, Sizeof))
9228  return false;
9229  return Success(Sizeof, E);
9230  }
9232  assert(E->isArgumentType());
9233  return Success(
9234  Info.Ctx.toCharUnitsFromBits(
9235  Info.Ctx.getOpenMPDefaultSimdAlign(E->getArgumentType()))
9236  .getQuantity(),
9237  E);
9238  }
9239 
9240  llvm_unreachable("unknown expr/type trait");
9241 }
9242 
9243 bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *OOE) {
9244  CharUnits Result;
9245  unsigned n = OOE->getNumComponents();
9246  if (n == 0)
9247  return Error(OOE);
9248  QualType CurrentType = OOE->getTypeSourceInfo()->getType();
9249  for (unsigned i = 0; i != n; ++i) {
9250  OffsetOfNode ON = OOE->getComponent(i);
9251  switch (ON.getKind()) {
9252  case OffsetOfNode::Array: {
9253  const Expr *Idx = OOE->getIndexExpr(ON.getArrayExprIndex());
9254  APSInt IdxResult;
9255  if (!EvaluateInteger(Idx, IdxResult, Info))
9256  return false;
9257  const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType);
9258  if (!AT)
9259  return Error(OOE);
9260  CurrentType = AT->getElementType();
9261  CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType);
9262  Result += IdxResult.getSExtValue() * ElementSize;
9263  break;
9264  }
9265 
9266  case OffsetOfNode::Field: {
9267  FieldDecl *MemberDecl = ON.getField();
9268  const RecordType *RT = CurrentType->getAs<RecordType>();
9269  if (!RT)
9270  return Error(OOE);
9271  RecordDecl *RD = RT->getDecl();
9272  if (RD->isInvalidDecl()) return false;
9273  const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
9274  unsigned i = MemberDecl->getFieldIndex();
9275  assert(i < RL.getFieldCount() && "offsetof field in wrong type");
9276  Result += Info.Ctx.toCharUnitsFromBits(RL.getFieldOffset(i));
9277  CurrentType = MemberDecl->getType().getNonReferenceType();
9278  break;
9279  }
9280 
9282  llvm_unreachable("dependent __builtin_offsetof");
9283 
9284  case OffsetOfNode::Base: {
9285  CXXBaseSpecifier *BaseSpec = ON.getBase();
9286  if (BaseSpec->isVirtual())
9287  return Error(OOE);
9288 
9289  // Find the layout of the class whose base we are looking into.
9290  const RecordType *RT = CurrentType->getAs<RecordType>();
9291  if (!RT)
9292  return Error(OOE);
9293  RecordDecl *RD = RT->getDecl();
9294  if (RD->isInvalidDecl()) return false;
9295  const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
9296 
9297  // Find the base class itself.
9298  CurrentType = BaseSpec->getType();
9299  const RecordType *BaseRT = CurrentType->getAs<RecordType>();
9300  if (!BaseRT)
9301  return Error(OOE);
9302 
9303  // Add the offset to the base.
9304  Result += RL.getBaseClassOffset(cast<CXXRecordDecl>(BaseRT->getDecl()));
9305  break;
9306  }
9307  }
9308  }
9309  return Success(Result, OOE);
9310 }
9311 
9312 bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
9313  switch (E->getOpcode()) {
9314  default:
9315  // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
9316  // See C99 6.6p3.
9317  return Error(E);
9318  case UO_Extension:
9319  // FIXME: Should extension allow i-c-e extension expressions in its scope?
9320  // If so, we could clear the diagnostic ID.
9321  return Visit(E->getSubExpr());
9322  case UO_Plus:
9323  // The result is just the value.
9324  return Visit(E->getSubExpr());
9325  case UO_Minus: {
9326  if (!Visit(E->getSubExpr()))
9327  return false;
9328  if (!Result.isInt()) return Error(E);
9329  const APSInt &Value = Result.getInt();
9330  if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow() &&
9331  !HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1),
9332  E->getType()))
9333  return false;
9334  return Success(-Value, E);
9335  }
9336  case UO_Not: {
9337  if (!Visit(E->getSubExpr()))
9338  return false;
9339  if (!Result.isInt()) return Error(E);
9340  return Success(~Result.getInt(), E);
9341  }
9342  case UO_LNot: {
9343  bool bres;
9344  if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
9345  return false;
9346  return Success(!bres, E);
9347  }
9348  }
9349 }
9350 
9351 /// HandleCast - This is used to evaluate implicit or explicit casts where the
9352 /// result type is integer.
9353 bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
9354  const Expr *SubExpr = E->getSubExpr();
9355  QualType DestType = E->getType();
9356  QualType SrcType = SubExpr->getType();
9357 
9358  switch (E->getCastKind()) {
9359  case CK_BaseToDerived:
9360  case CK_DerivedToBase:
9361  case CK_UncheckedDerivedToBase:
9362  case CK_Dynamic:
9363  case CK_ToUnion:
9364  case CK_ArrayToPointerDecay:
9365  case CK_FunctionToPointerDecay:
9366  case CK_NullToPointer:
9367  case CK_NullToMemberPointer:
9368  case CK_BaseToDerivedMemberPointer:
9369  case CK_DerivedToBaseMemberPointer:
9370  case CK_ReinterpretMemberPointer:
9371  case CK_ConstructorConversion:
9372  case CK_IntegralToPointer:
9373  case CK_ToVoid:
9374  case CK_VectorSplat:
9375  case CK_IntegralToFloating:
9376  case CK_FloatingCast:
9377  case CK_CPointerToObjCPointerCast:
9378  case CK_BlockPointerToObjCPointerCast:
9379  case CK_AnyPointerToBlockPointerCast:
9380  case CK_ObjCObjectLValueCast:
9381  case CK_FloatingRealToComplex:
9382  case CK_FloatingComplexToReal:
9383  case CK_FloatingComplexCast:
9384  case CK_FloatingComplexToIntegralComplex:
9385  case CK_IntegralRealToComplex:
9386  case CK_IntegralComplexCast:
9387  case CK_IntegralComplexToFloatingComplex:
9388  case CK_BuiltinFnToFnPtr:
9389  case CK_ZeroToOCLEvent:
9390  case CK_ZeroToOCLQueue:
9391  case CK_NonAtomicToAtomic:
9392  case CK_AddressSpaceConversion:
9393  case CK_IntToOCLSampler:
9394  llvm_unreachable("invalid cast kind for integral value");
9395 
9396  case CK_BitCast:
9397  case CK_Dependent:
9398  case CK_LValueBitCast:
9399  case CK_ARCProduceObject:
9400  case CK_ARCConsumeObject:
9401  case CK_ARCReclaimReturnedObject:
9402  case CK_ARCExtendBlockObject:
9403  case CK_CopyAndAutoreleaseBlockObject:
9404  return Error(E);
9405 
9406  case CK_UserDefinedConversion:
9407  case CK_LValueToRValue:
9408  case CK_AtomicToNonAtomic:
9409  case CK_NoOp:
9410  return ExprEvaluatorBaseTy::VisitCastExpr(E);
9411 
9412  case CK_MemberPointerToBoolean:
9413  case CK_PointerToBoolean:
9414  case CK_IntegralToBoolean:
9415  case CK_FloatingToBoolean:
9416  case CK_BooleanToSignedIntegral:
9417  case CK_FloatingComplexToBoolean:
9418  case CK_IntegralComplexToBoolean: {
9419  bool BoolResult;
9420  if (!EvaluateAsBooleanCondition(SubExpr, BoolResult, Info))
9421  return false;
9422  uint64_t IntResult = BoolResult;
9423  if (BoolResult && E->getCastKind() == CK_BooleanToSignedIntegral)
9424  IntResult = (uint64_t)-1;
9425  return Success(IntResult, E);
9426  }
9427 
9428  case CK_IntegralCast: {
9429  if (!Visit(SubExpr))
9430  return false;
9431 
9432  if (!Result.isInt()) {
9433  // Allow casts of address-of-label differences if they are no-ops
9434  // or narrowing. (The narrowing case isn't actually guaranteed to
9435  // be constant-evaluatable except in some narrow cases which are hard
9436  // to detect here. We let it through on the assumption the user knows
9437  // what they are doing.)
9438  if (Result.isAddrLabelDiff())
9439  return Info.Ctx.getTypeSize(DestType) <= Info.Ctx.getTypeSize(SrcType);
9440  // Only allow casts of lvalues if they are lossless.
9441  return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
9442  }
9443 
9444  return Success(HandleIntToIntCast(Info, E, DestType, SrcType,
9445  Result.getInt()), E);
9446  }
9447 
9448  case CK_PointerToIntegral: {
9449  CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
9450 
9451  LValue LV;
9452  if (!EvaluatePointer(SubExpr, LV, Info))
9453  return false;
9454 
9455  if (LV.getLValueBase()) {
9456  // Only allow based lvalue casts if they are lossless.
9457  // FIXME: Allow a larger integer size than the pointer size, and allow
9458  // narrowing back down to pointer width in subsequent integral casts.
9459  // FIXME: Check integer type's active bits, not its type size.
9460  if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(SrcType))
9461  return Error(E);
9462 
9463  LV.Designator.setInvalid();
9464  LV.moveInto(Result);
9465  return true;
9466  }
9467 
9468  uint64_t V;
9469  if (LV.isNullPointer())
9470  V = Info.Ctx.getTargetNullPointerValue(SrcType);
9471  else
9472  V = LV.getLValueOffset().getQuantity();
9473 
9474  APSInt AsInt = Info.Ctx.MakeIntValue(V, SrcType);
9475  return Success(HandleIntToIntCast(Info, E, DestType, SrcType, AsInt), E);
9476  }
9477 
9478  case CK_IntegralComplexToReal: {
9479  ComplexValue C;
9480  if (!EvaluateComplex(SubExpr, C, Info))
9481  return false;
9482  return Success(C.getComplexIntReal(), E);
9483  }
9484 
9485  case CK_FloatingToIntegral: {
9486  APFloat F(0.0);
9487  if (!EvaluateFloat(SubExpr, F, Info))
9488  return false;
9489 
9490  APSInt Value;
9491  if (!HandleFloatToIntCast(Info, E, SrcType, F, DestType, Value))
9492  return false;
9493  return Success(Value, E);
9494  }
9495  }
9496 
9497  llvm_unreachable("unknown cast resulting in integral value");
9498 }
9499 
9500 bool IntExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
9501  if (E->getSubExpr()->getType()->isAnyComplexType()) {
9502  ComplexValue LV;
9503  if (!EvaluateComplex(E->getSubExpr(), LV, Info))
9504  return false;
9505  if (!LV.isComplexInt())
9506  return Error(E);
9507  return Success(LV.getComplexIntReal(), E);
9508  }
9509 
9510  return Visit(E->getSubExpr());
9511 }
9512 
9513 bool IntExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
9514  if (E->getSubExpr()->getType()->isComplexIntegerType()) {
9515  ComplexValue LV;
9516  if (!EvaluateComplex(E->getSubExpr(), LV, Info))
9517  return false;
9518  if (!LV.isComplexInt())
9519  return Error(E);
9520  return Success(LV.getComplexIntImag(), E);
9521  }
9522 
9523  VisitIgnoredValue(E->getSubExpr());
9524  return Success(0, E);
9525 }
9526 
9527 bool IntExprEvaluator::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
9528  return Success(E->getPackLength(), E);
9529 }
9530 
9531 bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
9532  return Success(E->getValue(), E);
9533 }
9534 
9535 bool FixedPointExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
9536  switch (E->getOpcode()) {
9537  default:
9538  // Invalid unary operators
9539  return Error(E);
9540  case UO_Plus:
9541  // The result is just the value.
9542  return Visit(E->getSubExpr());
9543  case UO_Minus: {
9544  if (!Visit(E->getSubExpr())) return false;
9545  if (!Result.isInt()) return Error(E);
9546  const APSInt &Value = Result.getInt();
9547  if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow()) {
9548  SmallString<64> S;
9549  FixedPointValueToString(S, Value,
9550  Info.Ctx.getTypeInfo(E->getType()).Width,
9551  /*Radix=*/10);
9552  Info.CCEDiag(E, diag::note_constexpr_overflow) << S << E->getType();
9553  if (Info.noteUndefinedBehavior()) return false;
9554  }
9555  return Success(-Value, E);
9556  }
9557  case UO_LNot: {
9558  bool bres;
9559  if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
9560  return false;
9561  return Success(!bres, E);
9562  }
9563  }
9564 }
9565 
9566 //===----------------------------------------------------------------------===//
9567 // Float Evaluation
9568 //===----------------------------------------------------------------------===//
9569 
9570 namespace {
9571 class FloatExprEvaluator
9572  : public ExprEvaluatorBase<FloatExprEvaluator> {
9573  APFloat &Result;
9574 public:
9575  FloatExprEvaluator(EvalInfo &info, APFloat &result)
9576  : ExprEvaluatorBaseTy(info), Result(result) {}
9577 
9578  bool Success(const APValue &V, const Expr *e) {
9579  Result = V.getFloat();
9580  return true;
9581  }
9582 
9583  bool ZeroInitialization(const Expr *E) {
9584  Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
9585  return true;
9586  }
9587 
9588  bool VisitCallExpr(const CallExpr *E);
9589 
9590  bool VisitUnaryOperator(const UnaryOperator *E);
9591  bool VisitBinaryOperator(const BinaryOperator *E);
9592  bool VisitFloatingLiteral(const FloatingLiteral *E);
9593  bool VisitCastExpr(const CastExpr *E);
9594 
9595  bool VisitUnaryReal(const UnaryOperator *E);
9596  bool VisitUnaryImag(const UnaryOperator *E);
9597 
9598  // FIXME: Missing: array subscript of vector, member of vector
9599 };
9600 } // end anonymous namespace
9601 
9602 static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
9603  assert(E->isRValue() && E->getType()->isRealFloatingType());
9604  return FloatExprEvaluator(Info, Result).Visit(E);
9605 }
9606 
9607 static bool TryEvaluateBuiltinNaN(const ASTContext &Context,
9608  QualType ResultTy,
9609  const Expr *Arg,
9610  bool SNaN,
9611  llvm::APFloat &Result) {
9612  const StringLiteral *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
9613  if (!S) return false;
9614 
9615  const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(ResultTy);
9616 
9617  llvm::APInt fill;
9618 
9619  // Treat empty strings as if they were zero.
9620  if (S->getString().empty())
9621  fill = llvm::APInt(32, 0);
9622  else if (S->getString().getAsInteger(0, fill))
9623  return false;
9624 
9625  if (Context.getTargetInfo().isNan2008()) {
9626  if (SNaN)
9627  Result = llvm::APFloat::getSNaN(Sem, false, &fill);
9628  else
9629  Result = llvm::APFloat::getQNaN(Sem, false, &fill);
9630  } else {
9631  // Prior to IEEE 754-2008, architectures were allowed to choose whether
9632  // the first bit of their significand was set for qNaN or sNaN. MIPS chose
9633  // a different encoding to what became a standard in 2008, and for pre-
9634  // 2008 revisions, MIPS interpreted sNaN-2008 as qNan and qNaN-2008 as
9635  // sNaN. This is now known as "legacy NaN" encoding.
9636  if (SNaN)
9637  Result = llvm::APFloat::getQNaN(Sem, false, &fill);
9638  else
9639  Result = llvm::APFloat::getSNaN(Sem, false, &fill);
9640  }
9641 
9642  return true;
9643 }
9644 
9645 bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) {
9646  switch (E->getBuiltinCallee()) {
9647  default:
9648  return ExprEvaluatorBaseTy::VisitCallExpr(E);
9649 
9650  case Builtin::BI__builtin_huge_val:
9651  case Builtin::BI__builtin_huge_valf:
9652  case Builtin::BI__builtin_huge_vall:
9653  case Builtin::BI__builtin_huge_valf128:
9654  case Builtin::BI__builtin_inf:
9655  case Builtin::BI__builtin_inff:
9656  case Builtin::BI__builtin_infl:
9657  case Builtin::BI__builtin_inff128: {
9658  const llvm::fltSemantics &Sem =
9659  Info.Ctx.getFloatTypeSemantics(E->getType());
9660  Result = llvm::APFloat::getInf(Sem);
9661  return true;
9662  }
9663 
9664  case Builtin::BI__builtin_nans:
9665  case Builtin::BI__builtin_nansf:
9666  case Builtin::BI__builtin_nansl:
9667  case Builtin::BI__builtin_nansf128:
9668  if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
9669  true, Result))
9670  return Error(E);
9671  return true;
9672 
9673  case Builtin::BI__builtin_nan:
9674  case Builtin::BI__builtin_nanf:
9675  case Builtin::BI__builtin_nanl:
9676  case Builtin::BI__builtin_nanf128:
9677  // If this is __builtin_nan() turn this into a nan, otherwise we
9678  // can't constant fold it.
9679  if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
9680  false, Result))
9681  return Error(E);
9682  return true;
9683 
9684  case Builtin::BI__builtin_fabs:
9685  case Builtin::BI__builtin_fabsf:
9686  case Builtin::BI__builtin_fabsl:
9687  case Builtin::BI__builtin_fabsf128:
9688  if (!EvaluateFloat(E->getArg(0), Result, Info))
9689  return false;
9690 
9691  if (Result.isNegative())
9692  Result.changeSign();
9693  return true;
9694 
9695  // FIXME: Builtin::BI__builtin_powi
9696  // FIXME: Builtin::BI__builtin_powif
9697  // FIXME: Builtin::BI__builtin_powil
9698 
9699  case Builtin::BI__builtin_copysign:
9700  case Builtin::BI__builtin_copysignf:
9701  case Builtin::BI__builtin_copysignl:
9702  case Builtin::BI__builtin_copysignf128: {
9703  APFloat RHS(0.);
9704  if (!EvaluateFloat(E->getArg(0), Result, Info) ||
9705  !EvaluateFloat(E->getArg(1), RHS, Info))
9706  return false;
9707  Result.copySign(RHS);
9708  return true;
9709  }
9710  }
9711 }
9712 
9713 bool FloatExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
9714  if (E->getSubExpr()->getType()->isAnyComplexType()) {
9715  ComplexValue CV;
9716  if (!EvaluateComplex(E->getSubExpr(), CV, Info))
9717  return false;
9718  Result = CV.FloatReal;
9719  return true;
9720  }
9721 
9722  return Visit(E->getSubExpr());
9723 }
9724 
9725 bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
9726  if (E->getSubExpr()->getType()->isAnyComplexType()) {
9727  ComplexValue CV;
9728  if (!EvaluateComplex(E->getSubExpr(), CV, Info))
9729  return false;
9730  Result = CV.FloatImag;
9731  return true;
9732  }
9733 
9734  VisitIgnoredValue(E->getSubExpr());
9735  const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType());
9736  Result = llvm::APFloat::getZero(Sem);
9737  return true;
9738 }
9739 
9740 bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
9741  switch (E->getOpcode()) {
9742  default: return Error(E);
9743  case UO_Plus:
9744  return EvaluateFloat(E->getSubExpr(), Result, Info);
9745  case UO_Minus:
9746  if (!EvaluateFloat(E->getSubExpr(), Result, Info))
9747  return false;
9748  Result.changeSign();
9749  return true;
9750  }
9751 }
9752 
9753 bool FloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
9754  if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
9755  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
9756 
9757  APFloat RHS(0.0);
9758  bool LHSOK = EvaluateFloat(E->getLHS(), Result, Info);
9759  if (!LHSOK && !Info.noteFailure())
9760  return false;
9761  return EvaluateFloat(E->getRHS(), RHS, Info) && LHSOK &&
9762  handleFloatFloatBinOp(Info, E, Result, E->getOpcode(), RHS);
9763 }
9764 
9765 bool FloatExprEvaluator::VisitFloatingLiteral(const FloatingLiteral *E) {
9766  Result = E->getValue();
9767  return true;
9768 }
9769 
9770 bool FloatExprEvaluator::VisitCastExpr(const CastExpr *E) {
9771  const Expr* SubExpr = E->getSubExpr();
9772 
9773  switch (E->getCastKind()) {
9774  default:
9775  return ExprEvaluatorBaseTy::VisitCastExpr(E);
9776 
9777  case CK_IntegralToFloating: {
9778  APSInt IntResult;
9779  return EvaluateInteger(SubExpr, IntResult, Info) &&
9780  HandleIntToFloatCast(Info, E, SubExpr->getType(), IntResult,
9781  E->getType(), Result);
9782  }
9783 
9784  case CK_FloatingCast: {
9785  if (!Visit(SubExpr))
9786  return false;
9787  return HandleFloatToFloatCast(Info, E, SubExpr->getType(), E->getType(),
9788  Result);
9789  }
9790 
9791  case CK_FloatingComplexToReal: {
9792  ComplexValue V;
9793  if (!EvaluateComplex(SubExpr, V, Info))
9794  return false;
9795  Result = V.getComplexFloatReal();
9796  return true;
9797  }
9798  }
9799 }
9800 
9801 //===----------------------------------------------------------------------===//
9802 // Complex Evaluation (for float and integer)
9803 //===----------------------------------------------------------------------===//
9804 
9805 namespace {
9806 class ComplexExprEvaluator
9807  : public ExprEvaluatorBase<ComplexExprEvaluator> {
9808  ComplexValue &Result;
9809 
9810 public:
9811  ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result)
9812  : ExprEvaluatorBaseTy(info), Result(Result) {}
9813 
9814  bool Success(const APValue &V, const Expr *e) {
9815  Result.setFrom(V);
9816  return true;
9817  }
9818 
9819  bool ZeroInitialization(const Expr *E);
9820 
9821  //===--------------------------------------------------------------------===//
9822  // Visitor Methods
9823  //===--------------------------------------------------------------------===//
9824 
9825  bool VisitImaginaryLiteral(const ImaginaryLiteral *E);
9826  bool VisitCastExpr(const CastExpr *E);
9827  bool VisitBinaryOperator(const BinaryOperator *E);
9828  bool VisitUnaryOperator(const UnaryOperator *E);
9829  bool VisitInitListExpr(const InitListExpr *E);
9830 };
9831 } // end anonymous namespace
9832 
9833 static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
9834  EvalInfo &Info) {
9835  assert(E->isRValue() && E->getType()->isAnyComplexType());
9836  return ComplexExprEvaluator(Info, Result).Visit(E);
9837 }
9838 
9839 bool ComplexExprEvaluator::ZeroInitialization(const Expr *E) {
9840  QualType ElemTy = E->getType()->castAs<ComplexType>()->getElementType();
9841  if (ElemTy->isRealFloatingType()) {
9842  Result.makeComplexFloat();
9843  APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy));
9844  Result.FloatReal = Zero;
9845  Result.FloatImag = Zero;
9846  } else {
9847  Result.makeComplexInt();
9848  APSInt Zero = Info.Ctx.MakeIntValue(0, ElemTy);
9849  Result.IntReal = Zero;
9850  Result.IntImag = Zero;
9851  }
9852  return true;
9853 }
9854 
9855 bool ComplexExprEvaluator::VisitImaginaryLiteral(const ImaginaryLiteral *E) {
9856  const Expr* SubExpr = E->getSubExpr();
9857 
9858  if (SubExpr->getType()->isRealFloatingType()) {
9859  Result.makeComplexFloat();
9860  APFloat &Imag = Result.FloatImag;
9861  if (!EvaluateFloat(SubExpr, Imag, Info))
9862  return false;
9863 
9864  Result.FloatReal = APFloat(Imag.getSemantics());
9865  return true;
9866  } else {
9867  assert(SubExpr->getType()->isIntegerType() &&
9868  "Unexpected imaginary literal.");
9869 
9870  Result.makeComplexInt();
9871  APSInt &Imag = Result.IntImag;
9872  if (!EvaluateInteger(SubExpr, Imag, Info))
9873  return false;
9874 
9875  Result.IntReal = APSInt(Imag.getBitWidth(), !Imag.isSigned());
9876  return true;
9877  }
9878 }
9879 
9880 bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
9881 
9882  switch (E->getCastKind()) {
9883  case CK_BitCast:
9884  case CK_BaseToDerived:
9885  case CK_DerivedToBase:
9886  case CK_UncheckedDerivedToBase:
9887  case CK_Dynamic:
9888  case CK_ToUnion:
9889  case CK_ArrayToPointerDecay:
9890  case CK_FunctionToPointerDecay:
9891  case CK_NullToPointer:
9892  case CK_NullToMemberPointer:
9893  case CK_BaseToDerivedMemberPointer:
9894  case CK_DerivedToBaseMemberPointer:
9895  case CK_MemberPointerToBoolean:
9896  case CK_ReinterpretMemberPointer:
9897  case CK_ConstructorConversion:
9898  case CK_IntegralToPointer:
9899  case CK_PointerToIntegral:
9900  case CK_PointerToBoolean:
9901  case CK_ToVoid:
9902  case CK_VectorSplat:
9903  case CK_IntegralCast:
9904  case CK_BooleanToSignedIntegral:
9905  case CK_IntegralToBoolean:
9906  case CK_IntegralToFloating:
9907  case CK_FloatingToIntegral:
9908  case CK_FloatingToBoolean:
9909  case CK_FloatingCast:
9910  case CK_CPointerToObjCPointerCast:
9911  case CK_BlockPointerToObjCPointerCast:
9912  case CK_AnyPointerToBlockPointerCast:
9913  case CK_ObjCObjectLValueCast:
9914  case CK_FloatingComplexToReal:
9915  case CK_FloatingComplexToBoolean:
9916  case CK_IntegralComplexToReal:
9917  case CK_IntegralComplexToBoolean:
9918  case CK_ARCProduceObject:
9919  case CK_ARCConsumeObject:
9920  case CK_ARCReclaimReturnedObject:
9921  case CK_ARCExtendBlockObject:
9922  case CK_CopyAndAutoreleaseBlockObject:
9923  case CK_BuiltinFnToFnPtr:
9924  case CK_ZeroToOCLEvent:
9925  case CK_ZeroToOCLQueue:
9926  case CK_NonAtomicToAtomic:
9927  case CK_AddressSpaceConversion:
9928  case CK_IntToOCLSampler:
9929  llvm_unreachable("invalid cast kind for complex value");
9930 
9931  case CK_LValueToRValue:
9932  case CK_AtomicToNonAtomic:
9933  case CK_NoOp:
9934  return ExprEvaluatorBaseTy::VisitCastExpr(E);
9935 
9936  case CK_Dependent:
9937  case CK_LValueBitCast:
9938  case CK_UserDefinedConversion:
9939  return Error(E);
9940 
9941  case CK_FloatingRealToComplex: {
9942  APFloat &Real = Result.FloatReal;
9943  if (!EvaluateFloat(E->getSubExpr(), Real, Info))
9944  return false;
9945 
9946  Result.makeComplexFloat();
9947  Result.FloatImag = APFloat(Real.getSemantics());
9948  return true;
9949  }
9950 
9951  case CK_FloatingComplexCast: {
9952  if (!Visit(E->getSubExpr()))
9953  return false;
9954 
9955  QualType To = E->getType()->getAs<ComplexType>()->getElementType();
9956  QualType From
9957  = E->getSubExpr()->getType()->getAs<ComplexType>()->getElementType();
9958 
9959  return HandleFloatToFloatCast(Info, E, From, To, Result.FloatReal) &&
9960  HandleFloatToFloatCast(Info, E, From, To, Result.FloatImag);
9961  }
9962 
9963  case CK_FloatingComplexToIntegralComplex: {
9964  if (!Visit(E->getSubExpr()))
9965  return false;
9966 
9967  QualType To = E->getType()->getAs<ComplexType>()->getElementType();
9968  QualType From
9969  = E->getSubExpr()->getType()->getAs<ComplexType>()->getElementType();
9970  Result.makeComplexInt();
9971  return HandleFloatToIntCast(Info, E, From, Result.FloatReal,
9972  To, Result.IntReal) &&
9973  HandleFloatToIntCast(Info, E, From, Result.FloatImag,
9974  To, Result.IntImag);
9975  }
9976 
9977  case CK_IntegralRealToComplex: {
9978  APSInt &Real = Result.IntReal;
9979  if (!EvaluateInteger(E->getSubExpr(), Real, Info))
9980  return false;
9981 
9982  Result.makeComplexInt();
9983  Result.IntImag = APSInt(Real.getBitWidth(), !Real.isSigned());
9984  return true;
9985  }
9986 
9987  case CK_IntegralComplexCast: {
9988  if (!Visit(E->getSubExpr()))
9989  return false;
9990 
9991  QualType To = E->getType()->getAs<ComplexType>()->getElementType();
9992  QualType From
9993  = E->getSubExpr()->getType()->getAs<ComplexType>()->getElementType();
9994 
9995  Result.IntReal = HandleIntToIntCast(Info, E, To, From, Result.IntReal);
9996  Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag);
9997  return true;
9998  }
9999 
10000  case CK_IntegralComplexToFloatingComplex: {
10001  if (!Visit(E->getSubExpr()))
10002  return false;
10003 
10004  QualType To = E->getType()->castAs<ComplexType>()->getElementType();
10005  QualType From
10006  = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
10007  Result.makeComplexFloat();
10008  return HandleIntToFloatCast(Info, E, From, Result.IntReal,
10009  To, Result.FloatReal) &&
10010  HandleIntToFloatCast(Info, E, From, Result.IntImag,
10011  To, Result.FloatImag);
10012  }
10013  }
10014 
10015  llvm_unreachable("unknown cast resulting in complex value");
10016 }
10017 
10018 bool ComplexExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
10019  if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
10020  return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
10021 
10022  // Track whether the LHS or RHS is real at the type system level. When this is
10023  // the case we can simplify our evaluation strategy.
10024  bool LHSReal = false, RHSReal = false;
10025 
10026  bool LHSOK;
10027  if (E->getLHS()->getType()->isRealFloatingType()) {
10028  LHSReal = true;
10029  APFloat &Real = Result.FloatReal;
10030  LHSOK = EvaluateFloat(E->getLHS(), Real, Info);
10031  if (LHSOK) {
10032  Result.makeComplexFloat();
10033  Result.FloatImag = APFloat(Real.getSemantics());
10034  }
10035  } else {
10036  LHSOK = Visit(E->getLHS());
10037  }
10038  if (!LHSOK && !Info.noteFailure())
10039  return false;
10040 
10041  ComplexValue RHS;
10042  if (E->getRHS()->getType()->isRealFloatingType()) {
10043  RHSReal = true;
10044  APFloat &Real = RHS.FloatReal;
10045  if (!EvaluateFloat(E->getRHS(), Real, Info) || !LHSOK)
10046  return false;
10047  RHS.makeComplexFloat();
10048  RHS.FloatImag = APFloat(Real.getSemantics());
10049  } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
10050  return false;
10051 
10052  assert(!(LHSReal && RHSReal) &&
10053  "Cannot have both operands of a complex operation be real.");
10054  switch (E->getOpcode()) {
10055  default: return Error(E);
10056  case BO_Add:
10057  if (Result.isComplexFloat()) {
10058  Result.getComplexFloatReal().add(RHS.getComplexFloatReal(),
10059  APFloat::rmNearestTiesToEven);
10060  if (LHSReal)
10061  Result.getComplexFloatImag() = RHS.getComplexFloatImag();
10062  else if (!RHSReal)
10063  Result.getComplexFloatImag().add(RHS.getComplexFloatImag(),
10064  APFloat::rmNearestTiesToEven);
10065  } else {
10066  Result.getComplexIntReal() += RHS.getComplexIntReal();
10067  Result.getComplexIntImag() += RHS.getComplexIntImag();
10068  }
10069  break;
10070  case BO_Sub:
10071  if (Result.isComplexFloat()) {
10072  Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(),
10073  APFloat::rmNearestTiesToEven);
10074  if (LHSReal) {
10075  Result.getComplexFloatImag() = RHS.getComplexFloatImag();
10076  Result.getComplexFloatImag().changeSign();
10077  } else if (!RHSReal) {
10078  Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(),
10079  APFloat::rmNearestTiesToEven);
10080  }
10081  } else {
10082  Result.getComplexIntReal() -= RHS.getComplexIntReal();
10083  Result.getComplexIntImag() -= RHS.getComplexIntImag();
10084  }
10085  break;
10086  case BO_Mul:
10087  if (Result.isComplexFloat()) {
10088  // This is an implementation of complex multiplication according to the
10089  // constraints laid out in C11 Annex G. The implemention uses the
10090  // following naming scheme:
10091  // (a + ib) * (c + id)
10092  ComplexValue LHS = Result;
10093  APFloat &A = LHS.getComplexFloatReal();
10094  APFloat &B = LHS.getComplexFloatImag();
10095  APFloat &C = RHS.getComplexFloatReal();
10096  APFloat &D = RHS.getComplexFloatImag();
10097  APFloat &ResR = Result.getComplexFloatReal();
10098  APFloat &ResI = Result.getComplexFloatImag();
10099  if (LHSReal) {
10100  assert(!RHSReal && "Cannot have two real operands for a complex op!");
10101  ResR = A * C;
10102  ResI = A * D;
10103  } else if (RHSReal) {
10104  ResR = C * A;
10105  ResI = C * B;
10106  } else {
10107  // In the fully general case, we need to handle NaNs and infinities
10108  // robustly.
10109  APFloat AC = A * C;
10110  APFloat BD = B * D;
10111  APFloat AD = A * D;
10112  APFloat BC = B * C;
10113  ResR = AC - BD;
10114  ResI = AD + BC;
10115  if (ResR.isNaN() && ResI.isNaN()) {
10116  bool Recalc = false;
10117  if (A.isInfinity() || B.isInfinity()) {
10118  A = APFloat::copySign(
10119  APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
10120  B = APFloat::copySign(
10121  APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
10122  if (C.isNaN())
10123  C = APFloat::copySign(APFloat(C.getSemantics()), C);
10124  if (D.isNaN())
10125  D = APFloat::copySign(APFloat(D.getSemantics()), D);
10126  Recalc = true;
10127  }
10128  if (C.isInfinity() || D.isInfinity()) {
10129  C = APFloat::copySign(
10130  APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
10131  D = APFloat::copySign(
10132  APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
10133  if (A.isNaN())
10134  A = APFloat::copySign(APFloat(A.getSemantics()), A);
10135  if (B.isNaN())
10136  B = APFloat::copySign(APFloat(B.getSemantics()), B);
10137  Recalc = true;
10138  }
10139  if (!Recalc && (AC.isInfinity() || BD.isInfinity() ||
10140  AD.isInfinity() || BC.isInfinity())) {
10141  if (A.isNaN())
10142  A = APFloat::copySign(APFloat(A.getSemantics()), A);
10143  if (B.isNaN())
10144  B = APFloat::copySign(APFloat(B.getSemantics()), B);
10145  if (C.isNaN())
10146  C = APFloat::copySign(APFloat(C.getSemantics()), C);
10147  if (D.isNaN())
10148  D = APFloat::copySign(APFloat(D.getSemantics()), D);
10149  Recalc = true;
10150  }
10151  if (Recalc) {
10152  ResR = APFloat::getInf(A.getSemantics()) * (A * C - B * D);
10153  ResI = APFloat::getInf(A.getSemantics()) * (A * D + B * C);
10154  }
10155  }
10156  }
10157  } else {
10158  ComplexValue LHS = Result;
10159  Result.getComplexIntReal() =
10160  (LHS.getComplexIntReal() * RHS.getComplexIntReal() -
10161  LHS.getComplexIntImag() * RHS.getComplexIntImag());
10162  Result.getComplexIntImag() =
10163  (LHS.getComplexIntReal() * RHS.getComplexIntImag() +
10164  LHS.getComplexIntImag() * RHS.getComplexIntReal());
10165  }
10166  break;
10167  case BO_Div:
10168  if (Result.isComplexFloat()) {
10169  // This is an implementation of complex division according to the
10170  // constraints laid out in C11 Annex G. The implemention uses the
10171  // following naming scheme:
10172  // (a + ib) / (c + id)
10173  ComplexValue LHS = Result;
10174  APFloat &A = LHS.getComplexFloatReal();
10175  APFloat &B = LHS.getComplexFloatImag();
10176  APFloat &C = RHS.getComplexFloatReal();
10177  APFloat &D = RHS.getComplexFloatImag();
10178  APFloat &ResR = Result.getComplexFloatReal();
10179  APFloat &ResI = Result.getComplexFloatImag();
10180  if (RHSReal) {
10181  ResR = A / C;
10182  ResI = B / C;
10183  } else {
10184  if (LHSReal) {
10185  // No real optimizations we can do here, stub out with zero.
10186  B = APFloat::getZero(A.getSemantics());
10187  }
10188  int DenomLogB = 0;
10189  APFloat MaxCD = maxnum(abs(C), abs(D));
10190  if (MaxCD.isFinite()) {
10191  DenomLogB = ilogb(MaxCD);
10192  C = scalbn(C, -DenomLogB, APFloat::rmNearestTiesToEven);
10193  D = scalbn(D, -DenomLogB, APFloat::rmNearestTiesToEven);
10194  }
10195  APFloat Denom = C * C + D * D;
10196  ResR = scalbn((A * C + B * D) / Denom, -DenomLogB,
10197  APFloat::rmNearestTiesToEven);
10198  ResI = scalbn((B * C - A * D) / Denom, -DenomLogB,
10199  APFloat::rmNearestTiesToEven);
10200  if (ResR.isNaN() && ResI.isNaN()) {
10201  if (Denom.isPosZero() && (!A.isNaN() || !B.isNaN())) {
10202  ResR = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * A;
10203  ResI = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * B;
10204  } else if ((A.isInfinity() || B.isInfinity()) && C.isFinite() &&
10205  D.isFinite()) {
10206  A = APFloat::copySign(
10207  APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
10208  B = APFloat::copySign(
10209  APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
10210  ResR = APFloat::getInf(ResR.getSemantics()) * (A * C + B * D);
10211  ResI = APFloat::getInf(ResI.getSemantics()) * (B * C - A * D);
10212  } else if (MaxCD.isInfinity() && A.isFinite() && B.isFinite()) {
10213  C = APFloat::copySign(
10214  APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
10215  D = APFloat::copySign(
10216  APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
10217  ResR = APFloat::getZero(ResR.getSemantics()) * (A * C + B * D);
10218  ResI = APFloat::getZero(ResI.getSemantics()) * (B * C - A * D);
10219  }
10220  }
10221  }
10222  } else {
10223  if (RHS.getComplexIntReal() == 0 && RHS.getComplexIntImag() == 0)
10224  return Error(E, diag::note_expr_divide_by_zero);
10225 
10226  ComplexValue LHS = Result;
10227  APSInt Den = RHS.getComplexIntReal() * RHS.getComplexIntReal() +
10228  RHS.getComplexIntImag() * RHS.getComplexIntImag();
10229  Result.getComplexIntReal() =
10230  (LHS.getComplexIntReal() * RHS.getComplexIntReal() +
10231  LHS.getComplexIntImag() * RHS.getComplexIntImag()) / Den;
10232  Result.getComplexIntImag() =
10233  (LHS.getComplexIntImag() * RHS.getComplexIntReal() -
10234  LHS.getComplexIntReal() * RHS.getComplexIntImag()) / Den;
10235  }
10236  break;
10237  }
10238 
10239  return true;
10240 }
10241 
10242 bool ComplexExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
10243  // Get the operand value into 'Result'.
10244  if (!Visit(E->getSubExpr()))
10245  return false;
10246 
10247  switch (E->getOpcode()) {
10248  default:
10249  return Error(E);
10250  case UO_Extension:
10251  return true;
10252  case UO_Plus:
10253  // The result is always just the subexpr.
10254  return true;
10255  case UO_Minus:
10256  if (Result.isComplexFloat()) {
10257  Result.getComplexFloatReal().changeSign();
10258  Result.getComplexFloatImag().changeSign();
10259  }
10260  else {
10261  Result.getComplexIntReal() = -Result.getComplexIntReal();
10262  Result.getComplexIntImag() = -Result.getComplexIntImag();
10263  }
10264  return true;
10265  case UO_Not:
10266  if (Result.isComplexFloat())
10267  Result.getComplexFloatImag().changeSign();
10268  else
10269  Result.getComplexIntImag() = -Result.getComplexIntImag();
10270  return true;
10271  }
10272 }
10273 
10274 bool ComplexExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
10275  if (E->getNumInits() == 2) {
10276  if (E->getType()->isComplexType()) {
10277  Result.makeComplexFloat();
10278  if (!EvaluateFloat(E->getInit(0), Result.FloatReal, Info))
10279  return false;
10280  if (!EvaluateFloat(E->getInit(1), Result.FloatImag, Info))
10281  return false;
10282  } else {
10283  Result.makeComplexInt();
10284  if (!EvaluateInteger(E->getInit(0), Result.IntReal, Info))
10285  return false;
10286  if (!EvaluateInteger(E->getInit(1), Result.IntImag, Info))
10287  return false;
10288  }
10289  return true;
10290  }
10291  return ExprEvaluatorBaseTy::VisitInitListExpr(E);
10292 }
10293 
10294 //===----------------------------------------------------------------------===//
10295 // Atomic expression evaluation, essentially just handling the NonAtomicToAtomic
10296 // implicit conversion.
10297 //===----------------------------------------------------------------------===//
10298 
10299 namespace {
10300 class AtomicExprEvaluator :
10301  public ExprEvaluatorBase<AtomicExprEvaluator> {
10302  const LValue *This;
10303  APValue &Result;
10304 public:
10305  AtomicExprEvaluator(EvalInfo &Info, const LValue *This, APValue &Result)
10306  : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
10307 
10308  bool Success(const APValue &V, const Expr *E) {
10309  Result = V;
10310  return true;
10311  }
10312 
10313  bool ZeroInitialization(const Expr *E) {
10315  E->getType()->castAs<AtomicType>()->getValueType());
10316  // For atomic-qualified class (and array) types in C++, initialize the
10317  // _Atomic-wrapped subobject directly, in-place.
10318  return This ? EvaluateInPlace(Result, Info, *This, &VIE)
10319  : Evaluate(Result, Info, &VIE);
10320  }
10321 
10322  bool VisitCastExpr(const CastExpr *E) {
10323  switch (E->getCastKind()) {
10324  default:
10325  return ExprEvaluatorBaseTy::VisitCastExpr(E);
10326  case CK_NonAtomicToAtomic:
10327  return This ? EvaluateInPlace(Result, Info, *This, E->getSubExpr())
10328  : Evaluate(Result, Info, E->getSubExpr());
10329  }
10330  }
10331 };
10332 } // end anonymous namespace
10333 
10334 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
10335  EvalInfo &Info) {
10336  assert(E->isRValue() && E->getType()->isAtomicType());
10337  return AtomicExprEvaluator(Info, This, Result).Visit(E);
10338 }
10339 
10340 //===----------------------------------------------------------------------===//
10341 // Void expression evaluation, primarily for a cast to void on the LHS of a
10342 // comma operator
10343 //===----------------------------------------------------------------------===//
10344 
10345 namespace {
10346 class VoidExprEvaluator
10347  : public ExprEvaluatorBase<VoidExprEvaluator> {
10348 public:
10349  VoidExprEvaluator(EvalInfo &Info) : ExprEvaluatorBaseTy(Info) {}
10350 
10351  bool Success(const APValue &V, const Expr *e) { return true; }
10352 
10353  bool ZeroInitialization(const Expr *E) { return true; }
10354 
10355  bool VisitCastExpr(const CastExpr *E) {
10356  switch (E->getCastKind()) {
10357  default:
10358  return ExprEvaluatorBaseTy::VisitCastExpr(E);
10359  case CK_ToVoid:
10360  VisitIgnoredValue(E->getSubExpr());
10361  return true;
10362  }
10363  }
10364 
10365  bool VisitCallExpr(const CallExpr *E) {
10366  switch (E->getBuiltinCallee()) {
10367  default:
10368  return ExprEvaluatorBaseTy::VisitCallExpr(E);
10369  case Builtin::BI__assume:
10370  case Builtin::BI__builtin_assume:
10371  // The argument is not evaluated!
10372  return true;
10373  }
10374  }
10375 };
10376 } // end anonymous namespace
10377 
10378 static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
10379  assert(E->isRValue() && E->getType()->isVoidType());
10380  return VoidExprEvaluator(Info).Visit(E);
10381 }
10382 
10383 //===----------------------------------------------------------------------===//
10384 // Top level Expr::EvaluateAsRValue method.
10385 //===----------------------------------------------------------------------===//
10386 
10387 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
10388  // In C, function designators are not lvalues, but we evaluate them as if they
10389  // are.
10390  QualType T = E->getType();
10391  if (E->isGLValue() || T->isFunctionType()) {
10392  LValue LV;
10393  if (!EvaluateLValue(E, LV, Info))
10394  return false;
10395  LV.moveInto(Result);
10396  } else if (T->isVectorType()) {
10397  if (!EvaluateVector(E, Result, Info))
10398  return false;
10399  } else if (T->isIntegralOrEnumerationType()) {
10400  if (!IntExprEvaluator(Info, Result).Visit(E))
10401  return false;
10402  } else if (T->hasPointerRepresentation()) {
10403  LValue LV;
10404  if (!EvaluatePointer(E, LV, Info))
10405  return false;
10406  LV.moveInto(Result);
10407  } else if (T->isRealFloatingType()) {
10408  llvm::APFloat F(0.0);
10409  if (!EvaluateFloat(E, F, Info))
10410  return false;
10411  Result = APValue(F);
10412  } else if (T->isAnyComplexType()) {
10413  ComplexValue C;
10414  if (!EvaluateComplex(E, C, Info))
10415  return false;
10416  C.moveInto(Result);
10417  } else if (T->isFixedPointType()) {
10418  if (!FixedPointExprEvaluator(Info, Result).Visit(E)) return false;
10419  } else if (T->isMemberPointerType()) {
10420  MemberPtr P;
10421  if (!EvaluateMemberPointer(E, P, Info))
10422  return false;
10423  P.moveInto(Result);
10424  return true;
10425  } else if (T->isArrayType()) {
10426  LValue LV;
10427  APValue &Value = createTemporary(E, false, LV, *Info.CurrentCall);
10428  if (!EvaluateArray(E, LV, Value, Info))
10429  return false;
10430  Result = Value;
10431  } else if (T->isRecordType()) {
10432  LValue LV;
10433  APValue &Value = createTemporary(E, false, LV, *Info.CurrentCall);
10434  if (!EvaluateRecord(E, LV, Value, Info))
10435  return false;
10436  Result = Value;
10437  } else if (T->isVoidType()) {
10438  if (!Info.getLangOpts().CPlusPlus11)
10439  Info.CCEDiag(E, diag::note_constexpr_nonliteral)
10440  << E->getType();
10441  if (!EvaluateVoid(E, Info))
10442  return false;
10443  } else if (T->isAtomicType()) {
10444  QualType Unqual = T.getAtomicUnqualifiedType();
10445  if (Unqual->isArrayType() || Unqual->isRecordType()) {
10446  LValue LV;
10447  APValue &Value = createTemporary(E, false, LV, *Info.CurrentCall);
10448  if (!EvaluateAtomic(E, &LV, Value, Info))
10449  return false;
10450  } else {
10451  if (!EvaluateAtomic(E, nullptr, Result, Info))
10452  return false;
10453  }
10454  } else if (Info.getLangOpts().CPlusPlus11) {
10455  Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();
10456  return false;
10457  } else {
10458  Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
10459  return false;
10460  }
10461 
10462  return true;
10463 }
10464 
10465 /// EvaluateInPlace - Evaluate an expression in-place in an APValue. In some
10466 /// cases, the in-place evaluation is essential, since later initializers for
10467 /// an object can indirectly refer to subobjects which were initialized earlier.
10468 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This,
10469  const Expr *E, bool AllowNonLiteralTypes) {
10470  assert(!E->isValueDependent());
10471 
10472  if (!AllowNonLiteralTypes && !CheckLiteralType(Info, E, &This))
10473  return false;
10474 
10475  if (E->isRValue()) {
10476  // Evaluate arrays and record types in-place, so that later initializers can
10477  // refer to earlier-initialized members of the object.
10478  QualType T = E->getType();
10479  if (T->isArrayType())
10480  return EvaluateArray(E, This, Result, Info);
10481  else if (T->isRecordType())
10482  return EvaluateRecord(E, This, Result, Info);
10483  else if (T->isAtomicType()) {
10484  QualType Unqual = T.getAtomicUnqualifiedType();
10485  if (Unqual->isArrayType() || Unqual->isRecordType())
10486  return EvaluateAtomic(E, &This, Result, Info);
10487  }
10488  }
10489 
10490  // For any other type, in-place evaluation is unimportant.
10491  return Evaluate(Result, Info, E);
10492 }
10493 
10494 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
10495 /// lvalue-to-rvalue cast if it is an lvalue.
10496 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
10497  if (E->getType().isNull())
10498  return false;
10499 
10500  if (!CheckLiteralType(Info, E))
10501  return false;
10502 
10503  if (!::Evaluate(Result, Info, E))
10504  return false;
10505 
10506  if (E->isGLValue()) {
10507  LValue LV;
10508  LV.setFrom(Info.Ctx, Result);
10509  if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
10510  return false;
10511  }
10512 
10513  // Check this core constant expression is a constant expression.
10514  return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result);
10515 }
10516 
10517 static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result,
10518  const ASTContext &Ctx, bool &IsConst) {
10519  // Fast-path evaluations of integer literals, since we sometimes see files
10520  // containing vast quantities of these.
10521  if (const IntegerLiteral *L = dyn_cast<IntegerLiteral>(Exp)) {
10522  Result.Val = APValue(APSInt(L->getValue(),
10523  L->getType()->isUnsignedIntegerType()));
10524  IsConst = true;
10525  return true;
10526  }
10527 
10528  // This case should be rare, but we need to check it before we check on
10529  // the type below.
10530  if (Exp->getType().isNull()) {
10531  IsConst = false;
10532  return true;
10533  }
10534 
10535  // FIXME: Evaluating values of large array and record types can cause
10536  // performance problems. Only do so in C++11 for now.
10537  if (Exp->isRValue() && (Exp->getType()->isArrayType() ||
10538  Exp->getType()->isRecordType()) &&
10539  !Ctx.getLangOpts().CPlusPlus11) {
10540  IsConst = false;
10541  return true;
10542  }
10543  return false;
10544 }
10545 
10546 
10547 /// EvaluateAsRValue - Return true if this is a constant which we can fold using
10548 /// any crazy technique (that has nothing to do with language standards) that
10549 /// we want to. If this function returns true, it returns the folded constant
10550 /// in Result. If this expression is a glvalue, an lvalue-to-rvalue conversion
10551 /// will be applied to the result.
10552 bool Expr::EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const {
10553  bool IsConst;
10554  if (FastEvaluateAsRValue(this, Result, Ctx, IsConst))
10555  return IsConst;
10556 
10557  EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
10558  return ::EvaluateAsRValue(Info, this, Result.Val);
10559 }
10560 
10562  const ASTContext &Ctx) const {
10563  EvalResult Scratch;
10564  return EvaluateAsRValue(Scratch, Ctx) &&
10565  HandleConversionToBool(Scratch.Val, Result);
10566 }
10567 
10569  Expr::SideEffectsKind SEK) {
10570  return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) ||
10572 }
10573 
10574 bool Expr::EvaluateAsInt(APSInt &Result, const ASTContext &Ctx,
10575  SideEffectsKind AllowSideEffects) const {
10576  if (!getType()->isIntegralOrEnumerationType())
10577  return false;
10578 
10580  if (!EvaluateAsRValue(ExprResult, Ctx) || !ExprResult.Val.isInt() ||
10581  hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
10582  return false;
10583 
10584  Result = ExprResult.Val.getInt();
10585  return true;
10586 }
10587 
10588 bool Expr::EvaluateAsFloat(APFloat &Result, const ASTContext &Ctx,
10589  SideEffectsKind AllowSideEffects) const {
10590  if (!getType()->isRealFloatingType())
10591  return false;
10592 
10594  if (!EvaluateAsRValue(ExprResult, Ctx) || !ExprResult.Val.isFloat() ||
10595  hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
10596  return false;
10597 
10598  Result = ExprResult.Val.getFloat();
10599  return true;
10600 }
10601 
10602 bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const {
10603  EvalInfo Info(Ctx, Result, EvalInfo::EM_ConstantFold);
10604 
10605  LValue LV;
10606  if (!EvaluateLValue(this, LV, Info) || Result.HasSideEffects ||
10607  !CheckLValueConstantExpression(Info, getExprLoc(),
10608  Ctx.getLValueReferenceType(getType()), LV,
10610  return false;
10611 
10612  LV.moveInto(Result.Val);
10613  return true;
10614 }
10615 
10617  const ASTContext &Ctx) const {
10618  EvalInfo::EvaluationMode EM = EvalInfo::EM_ConstantExpression;
10619  EvalInfo Info(Ctx, Result, EM);
10620  if (!::Evaluate(Result.Val, Info, this))
10621  return false;
10622 
10623  return CheckConstantExpression(Info, getExprLoc(), getType(), Result.Val,
10624  Usage);
10625 }
10626 
10628  const VarDecl *VD,
10629  SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
10630  // FIXME: Evaluating initializers for large array and record types can cause
10631  // performance problems. Only do so in C++11 for now.
10632  if (isRValue() && (getType()->isArrayType() || getType()->isRecordType()) &&
10633  !Ctx.getLangOpts().CPlusPlus11)
10634  return false;
10635 
10636  Expr::EvalStatus EStatus;
10637  EStatus.Diag = &Notes;
10638 
10639  EvalInfo InitInfo(Ctx, EStatus, VD->isConstexpr()
10640  ? EvalInfo::EM_ConstantExpression
10641  : EvalInfo::EM_ConstantFold);
10642  InitInfo.setEvaluatingDecl(VD, Value);
10643 
10644  LValue LVal;
10645  LVal.set(VD);
10646 
10647  // C++11 [basic.start.init]p2:
10648  // Variables with static storage duration or thread storage duration shall be
10649  // zero-initialized before any other initialization takes place.
10650  // This behavior is not present in C.
10651  if (Ctx.getLangOpts().CPlusPlus && !VD->hasLocalStorage() &&
10652  !VD->getType()->isReferenceType()) {
10653  ImplicitValueInitExpr VIE(VD->getType());
10654  if (!EvaluateInPlace(Value, InitInfo, LVal, &VIE,
10655  /*AllowNonLiteralTypes=*/true))
10656  return false;
10657  }
10658 
10659  if (!EvaluateInPlace(Value, InitInfo, LVal, this,
10660  /*AllowNonLiteralTypes=*/true) ||
10661  EStatus.HasSideEffects)
10662  return false;
10663 
10664  return CheckConstantExpression(InitInfo, VD->getLocation(), VD->getType(),
10665  Value);
10666 }
10667 
10668 /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
10669 /// constant folded, but discard the result.
10670 bool Expr::isEvaluatable(const ASTContext &Ctx, SideEffectsKind SEK) const {
10672  return EvaluateAsRValue(Result, Ctx) &&
10673  !hasUnacceptableSideEffect(Result, SEK);
10674 }
10675 
10679  EvalResult.Diag = Diag;
10680  bool Result = EvaluateAsRValue(EvalResult, Ctx);
10681  (void)Result;
10682  assert(Result && "Could not evaluate expression");
10683  assert(EvalResult.Val.isInt() && "Expression did not evaluate to integer");
10684 
10685  return EvalResult.Val.getInt();
10686 }
10687 
10688 void Expr::EvaluateForOverflow(const ASTContext &Ctx) const {
10689  bool IsConst;
10691  if (!FastEvaluateAsRValue(this, EvalResult, Ctx, IsConst)) {
10692  EvalInfo Info(Ctx, EvalResult, EvalInfo::EM_EvaluateForOverflow);
10693  (void)::EvaluateAsRValue(Info, this, EvalResult.Val);
10694  }
10695 }
10696 
10698  assert(Val.isLValue());
10699  return IsGlobalLValue(Val.getLValueBase());
10700 }
10701 
10702 
10703 /// isIntegerConstantExpr - this recursive routine will test if an expression is
10704 /// an integer constant expression.
10705 
10706 /// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
10707 /// comma, etc
10708 
10709 // CheckICE - This function does the fundamental ICE checking: the returned
10710 // ICEDiag contains an ICEKind indicating whether the expression is an ICE,
10711 // and a (possibly null) SourceLocation indicating the location of the problem.
10712 //
10713 // Note that to reduce code duplication, this helper does no evaluation
10714 // itself; the caller checks whether the expression is evaluatable, and
10715 // in the rare cases where CheckICE actually cares about the evaluated
10716 // value, it calls into Evaluate.
10717 
10718 namespace {
10719 
10720 enum ICEKind {
10721  /// This expression is an ICE.
10722  IK_ICE,
10723  /// This expression is not an ICE, but if it isn't evaluated, it's
10724  /// a legal subexpression for an ICE. This return value is used to handle
10725  /// the comma operator in C99 mode, and non-constant subexpressions.
10726  IK_ICEIfUnevaluated,
10727  /// This expression is not an ICE, and is not a legal subexpression for one.
10728  IK_NotICE
10729 };
10730 
10731 struct ICEDiag {
10732  ICEKind Kind;
10733  SourceLocation Loc;
10734 
10735  ICEDiag(ICEKind IK, SourceLocation l) : Kind(IK), Loc(l) {}
10736 };
10737 
10738 }
10739 
10740 static ICEDiag NoDiag() { return ICEDiag(IK_ICE, SourceLocation()); }
10741 
10742 static ICEDiag Worst(ICEDiag A, ICEDiag B) { return A.Kind >= B.Kind ? A : B; }
10743 
10744 static ICEDiag CheckEvalInICE(const Expr* E, const ASTContext &Ctx) {
10745  Expr::EvalResult EVResult;
10746  if (!E->EvaluateAsRValue(EVResult, Ctx) || EVResult.HasSideEffects ||
10747  !EVResult.Val.isInt())
10748  return ICEDiag(IK_NotICE, E->getLocStart());
10749 
10750  return NoDiag();
10751 }
10752 
10753 static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
10754  assert(!E->isValueDependent() && "Should not see value dependent exprs!");
10755  if (!E->getType()->isIntegralOrEnumerationType())
10756  return ICEDiag(IK_NotICE, E->getLocStart());
10757 
10758  switch (E->getStmtClass()) {
10759 #define ABSTRACT_STMT(Node)
10760 #define STMT(Node, Base) case Expr::Node##Class:
10761 #define EXPR(Node, Base)
10762 #include "clang/AST/StmtNodes.inc"
10763  case Expr::PredefinedExprClass:
10764  case Expr::FloatingLiteralClass:
10765  case Expr::ImaginaryLiteralClass:
10766  case Expr::StringLiteralClass:
10767  case Expr::ArraySubscriptExprClass:
10768  case Expr::OMPArraySectionExprClass:
10769  case Expr::MemberExprClass:
10770  case Expr::CompoundAssignOperatorClass:
10771  case Expr::CompoundLiteralExprClass:
10772  case Expr::ExtVectorElementExprClass:
10773  case Expr::DesignatedInitExprClass:
10774  case Expr::ArrayInitLoopExprClass:
10775  case Expr::ArrayInitIndexExprClass:
10776  case Expr::NoInitExprClass:
10777  case Expr::DesignatedInitUpdateExprClass:
10778  case Expr::ImplicitValueInitExprClass:
10779  case Expr::ParenListExprClass:
10780  case Expr::VAArgExprClass:
10781  case Expr::AddrLabelExprClass:
10782  case Expr::StmtExprClass:
10783  case Expr::CXXMemberCallExprClass:
10784  case Expr::CUDAKernelCallExprClass:
10785  case Expr::CXXDynamicCastExprClass:
10786  case Expr::CXXTypeidExprClass:
10787  case Expr::CXXUuidofExprClass:
10788  case Expr::MSPropertyRefExprClass:
10789  case Expr::MSPropertySubscriptExprClass:
10790  case Expr::CXXNullPtrLiteralExprClass:
10791  case Expr::UserDefinedLiteralClass:
10792  case Expr::CXXThisExprClass:
10793  case Expr::CXXThrowExprClass:
10794  case Expr::CXXNewExprClass:
10795  case Expr::CXXDeleteExprClass:
10796  case Expr::CXXPseudoDestructorExprClass:
10797  case Expr::UnresolvedLookupExprClass:
10798  case Expr::TypoExprClass:
10799  case Expr::DependentScopeDeclRefExprClass:
10800  case Expr::CXXConstructExprClass:
10801  case Expr::CXXInheritedCtorInitExprClass:
10802  case Expr::CXXStdInitializerListExprClass:
10803  case Expr::CXXBindTemporaryExprClass:
10804  case Expr::ExprWithCleanupsClass:
10805  case Expr::CXXTemporaryObjectExprClass:
10806  case Expr::CXXUnresolvedConstructExprClass:
10807  case Expr::CXXDependentScopeMemberExprClass:
10808  case Expr::UnresolvedMemberExprClass:
10809  case Expr::ObjCStringLiteralClass:
10810  case Expr::ObjCBoxedExprClass:
10811  case Expr::ObjCArrayLiteralClass:
10812  case Expr::ObjCDictionaryLiteralClass:
10813  case Expr::ObjCEncodeExprClass:
10814  case Expr::ObjCMessageExprClass:
10815  case Expr::ObjCSelectorExprClass:
10816  case Expr::ObjCProtocolExprClass:
10817  case Expr::ObjCIvarRefExprClass:
10818  case Expr::ObjCPropertyRefExprClass:
10819  case Expr::ObjCSubscriptRefExprClass:
10820  case Expr::ObjCIsaExprClass:
10821  case Expr::ObjCAvailabilityCheckExprClass:
10822  case Expr::ShuffleVectorExprClass:
10823  case Expr::ConvertVectorExprClass:
10824  case Expr::BlockExprClass:
10825  case Expr::NoStmtClass:
10826  case Expr::OpaqueValueExprClass:
10827  case Expr::PackExpansionExprClass:
10828  case Expr::SubstNonTypeTemplateParmPackExprClass:
10829  case Expr::FunctionParmPackExprClass:
10830  case Expr::AsTypeExprClass:
10831  case Expr::ObjCIndirectCopyRestoreExprClass:
10832  case Expr::MaterializeTemporaryExprClass:
10833  case Expr::PseudoObjectExprClass:
10834  case Expr::AtomicExprClass:
10835  case Expr::LambdaExprClass:
10836  case Expr::CXXFoldExprClass:
10837  case Expr::CoawaitExprClass:
10838  case Expr::DependentCoawaitExprClass:
10839  case Expr::CoyieldExprClass:
10840  return ICEDiag(IK_NotICE, E->getLocStart());
10841 
10842  case Expr::InitListExprClass: {
10843  // C++03 [dcl.init]p13: If T is a scalar type, then a declaration of the
10844  // form "T x = { a };" is equivalent to "T x = a;".
10845  // Unless we're initializing a reference, T is a scalar as it is known to be
10846  // of integral or enumeration type.
10847  if (E->isRValue())
10848  if (cast<InitListExpr>(E)->getNumInits() == 1)
10849  return CheckICE(cast<InitListExpr>(E)->getInit(0), Ctx);
10850  return ICEDiag(IK_NotICE, E->getLocStart());
10851  }
10852 
10853  case Expr::SizeOfPackExprClass:
10854  case Expr::GNUNullExprClass:
10855  // GCC considers the GNU __null value to be an integral constant expression.
10856  return NoDiag();
10857 
10858  case Expr::SubstNonTypeTemplateParmExprClass:
10859  return
10860  CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), Ctx);
10861 
10862  case Expr::ParenExprClass:
10863  return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
10864  case Expr::GenericSelectionExprClass:
10865  return CheckICE(cast<GenericSelectionExpr>(E)->getResultExpr(), Ctx);
10866  case Expr::IntegerLiteralClass:
10867  case Expr::FixedPointLiteralClass:
10868  case Expr::CharacterLiteralClass:
10869  case Expr::ObjCBoolLiteralExprClass:
10870  case Expr::CXXBoolLiteralExprClass:
10871  case Expr::CXXScalarValueInitExprClass:
10872  case Expr::TypeTraitExprClass:
10873  case Expr::ArrayTypeTraitExprClass:
10874  case Expr::ExpressionTraitExprClass:
10875  case Expr::CXXNoexceptExprClass:
10876  return NoDiag();
10877  case Expr::CallExprClass:
10878  case Expr::CXXOperatorCallExprClass: {
10879  // C99 6.6/3 allows function calls within unevaluated subexpressions of
10880  // constant expressions, but they can never be ICEs because an ICE cannot
10881  // contain an operand of (pointer to) function type.
10882  const CallExpr *CE = cast<CallExpr>(E);
10883  if (CE->getBuiltinCallee())
10884  return CheckEvalInICE(E, Ctx);
10885  return ICEDiag(IK_NotICE, E->getLocStart());
10886  }
10887  case Expr::DeclRefExprClass: {
10888  if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
10889  return NoDiag();
10890  const ValueDecl *D = cast<DeclRefExpr>(E)->getDecl();
10891  if (Ctx.getLangOpts().CPlusPlus &&
10892  D && IsConstNonVolatile(D->getType())) {
10893  // Parameter variables are never constants. Without this check,
10894  // getAnyInitializer() can find a default argument, which leads
10895  // to chaos.
10896  if (isa<ParmVarDecl>(D))
10897  return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
10898 
10899  // C++ 7.1.5.1p2
10900  // A variable of non-volatile const-qualified integral or enumeration
10901  // type initialized by an ICE can be used in ICEs.
10902  if (const VarDecl *Dcl = dyn_cast<VarDecl>(D)) {
10903  if (!Dcl->getType()->isIntegralOrEnumerationType())
10904  return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
10905 
10906  const VarDecl *VD;
10907  // Look for a declaration of this variable that has an initializer, and
10908  // check whether it is an ICE.
10909  if (Dcl->getAnyInitializer(VD) && VD->checkInitIsICE())
10910  return NoDiag();
10911  else
10912  return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
10913  }
10914  }
10915  return ICEDiag(IK_NotICE, E->getLocStart());
10916  }
10917  case Expr::UnaryOperatorClass: {
10918  const UnaryOperator *Exp = cast<UnaryOperator>(E);
10919  switch (Exp->getOpcode()) {
10920  case UO_PostInc:
10921  case UO_PostDec:
10922  case UO_PreInc:
10923  case UO_PreDec:
10924  case UO_AddrOf:
10925  case UO_Deref:
10926  case UO_Coawait:
10927  // C99 6.6/3 allows increment and decrement within unevaluated
10928  // subexpressions of constant expressions, but they can never be ICEs
10929  // because an ICE cannot contain an lvalue operand.
10930  return ICEDiag(IK_NotICE, E->getLocStart());
10931  case UO_Extension:
10932  case UO_LNot:
10933  case UO_Plus:
10934  case UO_Minus:
10935  case UO_Not:
10936  case UO_Real:
10937  case UO_Imag:
10938  return CheckICE(Exp->getSubExpr(), Ctx);
10939  }
10940 
10941  // OffsetOf falls through here.
10942  LLVM_FALLTHROUGH;
10943  }
10944  case Expr::OffsetOfExprClass: {
10945  // Note that per C99, offsetof must be an ICE. And AFAIK, using
10946  // EvaluateAsRValue matches the proposed gcc behavior for cases like
10947  // "offsetof(struct s{int x[4];}, x[1.0])". This doesn't affect
10948  // compliance: we should warn earlier for offsetof expressions with
10949  // array subscripts that aren't ICEs, and if the array subscripts
10950  // are ICEs, the value of the offsetof must be an integer constant.
10951  return CheckEvalInICE(E, Ctx);
10952  }
10953  case Expr::UnaryExprOrTypeTraitExprClass: {
10954  const UnaryExprOrTypeTraitExpr *Exp = cast<UnaryExprOrTypeTraitExpr>(E);
10955  if ((Exp->getKind() == UETT_SizeOf) &&
10957  return ICEDiag(IK_NotICE, E->getLocStart());
10958  return NoDiag();
10959  }
10960  case Expr::BinaryOperatorClass: {
10961  const BinaryOperator *Exp = cast<BinaryOperator>(E);
10962  switch (Exp->getOpcode()) {
10963  case BO_PtrMemD:
10964  case BO_PtrMemI:
10965  case BO_Assign:
10966  case BO_MulAssign:
10967  case BO_DivAssign:
10968  case BO_RemAssign:
10969  case BO_AddAssign:
10970  case BO_SubAssign:
10971  case BO_ShlAssign:
10972  case BO_ShrAssign:
10973  case BO_AndAssign:
10974  case BO_XorAssign:
10975  case BO_OrAssign:
10976  // C99 6.6/3 allows assignments within unevaluated subexpressions of
10977  // constant expressions, but they can never be ICEs because an ICE cannot
10978  // contain an lvalue operand.
10979  return ICEDiag(IK_NotICE, E->getLocStart());
10980 
10981  case BO_Mul:
10982  case BO_Div:
10983  case BO_Rem:
10984  case BO_Add:
10985  case BO_Sub:
10986  case BO_Shl:
10987  case BO_Shr:
10988  case BO_LT:
10989  case BO_GT:
10990  case BO_LE:
10991  case BO_GE:
10992  case BO_EQ:
10993  case BO_NE:
10994  case BO_And:
10995  case BO_Xor:
10996  case BO_Or:
10997  case BO_Comma:
10998  case BO_Cmp: {
10999  ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
11000  ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
11001  if (Exp->getOpcode() == BO_Div ||
11002  Exp->getOpcode() == BO_Rem) {
11003  // EvaluateAsRValue gives an error for undefined Div/Rem, so make sure
11004  // we don't evaluate one.
11005  if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) {
11006  llvm::APSInt REval = Exp->getRHS()->EvaluateKnownConstInt(Ctx);
11007  if (REval == 0)
11008  return ICEDiag(IK_ICEIfUnevaluated, E->getLocStart());
11009  if (REval.isSigned() && REval.isAllOnesValue()) {
11010  llvm::APSInt LEval = Exp->getLHS()->EvaluateKnownConstInt(Ctx);
11011  if (LEval.isMinSignedValue())
11012  return ICEDiag(IK_ICEIfUnevaluated, E->getLocStart());
11013  }
11014  }
11015  }
11016  if (Exp->getOpcode() == BO_Comma) {
11017  if (Ctx.getLangOpts().C99) {
11018  // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
11019  // if it isn't evaluated.
11020  if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE)
11021  return ICEDiag(IK_ICEIfUnevaluated, E->getLocStart());
11022  } else {
11023  // In both C89 and C++, commas in ICEs are illegal.
11024  return ICEDiag(IK_NotICE, E->getLocStart());
11025  }
11026  }
11027  return Worst(LHSResult, RHSResult);
11028  }
11029  case BO_LAnd:
11030  case BO_LOr: {
11031  ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
11032  ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
11033  if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICEIfUnevaluated) {
11034  // Rare case where the RHS has a comma "side-effect"; we need
11035  // to actually check the condition to see whether the side
11036  // with the comma is evaluated.
11037  if ((Exp->getOpcode() == BO_LAnd) !=
11038  (Exp->getLHS()->EvaluateKnownConstInt(Ctx) == 0))
11039  return RHSResult;
11040  return NoDiag();
11041  }
11042 
11043  return Worst(LHSResult, RHSResult);
11044  }
11045  }
11046  LLVM_FALLTHROUGH;
11047  }
11048  case Expr::ImplicitCastExprClass:
11049  case Expr::CStyleCastExprClass:
11050  case Expr::CXXFunctionalCastExprClass:
11051  case Expr::CXXStaticCastExprClass:
11052  case Expr::CXXReinterpretCastExprClass:
11053  case Expr::CXXConstCastExprClass:
11054  case Expr::ObjCBridgedCastExprClass: {
11055  const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
11056  if (isa<ExplicitCastExpr>(E)) {
11057  if (const FloatingLiteral *FL
11058  = dyn_cast<FloatingLiteral>(SubExpr->IgnoreParenImpCasts())) {
11059  unsigned DestWidth = Ctx.getIntWidth(E->getType());
11060  bool DestSigned = E->getType()->isSignedIntegerOrEnumerationType();
11061  APSInt IgnoredVal(DestWidth, !DestSigned);
11062  bool Ignored;
11063  // If the value does not fit in the destination type, the behavior is
11064  // undefined, so we are not required to treat it as a constant
11065  // expression.
11066  if (FL->getValue().convertToInteger(IgnoredVal,
11067  llvm::APFloat::rmTowardZero,
11068  &Ignored) & APFloat::opInvalidOp)
11069  return ICEDiag(IK_NotICE, E->getLocStart());
11070  return NoDiag();
11071  }
11072  }
11073  switch (cast<CastExpr>(E)->getCastKind()) {
11074  case CK_LValueToRValue:
11075  case CK_AtomicToNonAtomic:
11076  case CK_NonAtomicToAtomic:
11077  case CK_NoOp:
11078  case CK_IntegralToBoolean:
11079  case CK_IntegralCast:
11080  return CheckICE(SubExpr, Ctx);
11081  default:
11082  return ICEDiag(IK_NotICE, E->getLocStart());
11083  }
11084  }
11085  case Expr::BinaryConditionalOperatorClass: {
11086  const BinaryConditionalOperator *Exp = cast<BinaryConditionalOperator>(E);
11087  ICEDiag CommonResult = CheckICE(Exp->getCommon(), Ctx);
11088  if (CommonResult.Kind == IK_NotICE) return CommonResult;
11089  ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
11090  if (FalseResult.Kind == IK_NotICE) return FalseResult;
11091  if (CommonResult.Kind == IK_ICEIfUnevaluated) return CommonResult;
11092  if (FalseResult.Kind == IK_ICEIfUnevaluated &&
11093  Exp->getCommon()->EvaluateKnownConstInt(Ctx) != 0) return NoDiag();
11094  return FalseResult;
11095  }
11096  case Expr::ConditionalOperatorClass: {
11097  const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
11098  // If the condition (ignoring parens) is a __builtin_constant_p call,
11099  // then only the true side is actually considered in an integer constant
11100  // expression, and it is fully evaluated. This is an important GNU
11101  // extension. See GCC PR38377 for discussion.
11102  if (const CallExpr *CallCE
11103  = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
11104  if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
11105  return CheckEvalInICE(E, Ctx);
11106  ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
11107  if (CondResult.Kind == IK_NotICE)
11108  return CondResult;
11109 
11110  ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
11111  ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
11112 
11113  if (TrueResult.Kind == IK_NotICE)
11114  return TrueResult;
11115  if (FalseResult.Kind == IK_NotICE)
11116  return FalseResult;
11117  if (CondResult.Kind == IK_ICEIfUnevaluated)
11118  return CondResult;
11119  if (TrueResult.Kind == IK_ICE && FalseResult.Kind == IK_ICE)
11120  return NoDiag();
11121  // Rare case where the diagnostics depend on which side is evaluated
11122  // Note that if we get here, CondResult is 0, and at least one of
11123  // TrueResult and FalseResult is non-zero.
11124  if (Exp->getCond()->EvaluateKnownConstInt(Ctx) == 0)
11125  return FalseResult;
11126  return TrueResult;
11127  }
11128  case Expr::CXXDefaultArgExprClass:
11129  return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
11130  case Expr::CXXDefaultInitExprClass:
11131  return CheckICE(cast<CXXDefaultInitExpr>(E)->getExpr(), Ctx);
11132  case Expr::ChooseExprClass: {
11133  return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(), Ctx);
11134  }
11135  }
11136 
11137  llvm_unreachable("Invalid StmtClass!");
11138 }
11139 
11140 /// Evaluate an expression as a C++11 integral constant expression.
11142  const Expr *E,
11143  llvm::APSInt *Value,
11144  SourceLocation *Loc) {
11146  if (Loc) *Loc = E->getExprLoc();
11147  return false;
11148  }
11149 
11150  APValue Result;
11151  if (!E->isCXX11ConstantExpr(Ctx, &Result, Loc))
11152  return false;
11153 
11154  if (!Result.isInt()) {
11155  if (Loc) *Loc = E->getExprLoc();
11156  return false;
11157  }
11158 
11159  if (Value) *Value = Result.getInt();
11160  return true;
11161 }
11162 
11164  SourceLocation *Loc) const {
11165  if (Ctx.getLangOpts().CPlusPlus11)
11166  return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, nullptr, Loc);
11167 
11168  ICEDiag D = CheckICE(this, Ctx);
11169  if (D.Kind != IK_ICE) {
11170  if (Loc) *Loc = D.Loc;
11171  return false;
11172  }
11173  return true;
11174 }
11175 
11176 bool Expr::isIntegerConstantExpr(llvm::APSInt &Value, const ASTContext &Ctx,
11177  SourceLocation *Loc, bool isEvaluated) const {
11178  if (Ctx.getLangOpts().CPlusPlus11)
11179  return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc);
11180 
11181  if (!isIntegerConstantExpr(Ctx, Loc))
11182  return false;
11183  // The only possible side-effects here are due to UB discovered in the
11184  // evaluation (for instance, INT_MAX + 1). In such a case, we are still
11185  // required to treat the expression as an ICE, so we produce the folded
11186  // value.
11187  if (!EvaluateAsInt(Value, Ctx, SE_AllowSideEffects))
11188  llvm_unreachable("ICE cannot be evaluated!");
11189  return true;
11190 }
11191 
11193  return CheckICE(this, Ctx).Kind == IK_ICE;
11194 }
11195 
11197  SourceLocation *Loc) const {
11198  // We support this checking in C++98 mode in order to diagnose compatibility
11199  // issues.
11200  assert(Ctx.getLangOpts().CPlusPlus);
11201 
11202  // Build evaluation settings.
11203  Expr::EvalStatus Status;
11205  Status.Diag = &Diags;
11206  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
11207 
11208  APValue Scratch;
11209  bool IsConstExpr = ::EvaluateAsRValue(Info, this, Result ? *Result : Scratch);
11210 
11211  if (!Diags.empty()) {
11212  IsConstExpr = false;
11213  if (Loc) *Loc = Diags[0].first;
11214  } else if (!IsConstExpr) {
11215  // FIXME: This shouldn't happen.
11216  if (Loc) *Loc = getExprLoc();
11217  }
11218 
11219  return IsConstExpr;
11220 }
11221 
11223  const FunctionDecl *Callee,
11224  ArrayRef<const Expr*> Args,
11225  const Expr *This) const {
11226  Expr::EvalStatus Status;
11227  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpressionUnevaluated);
11228 
11229  LValue ThisVal;
11230  const LValue *ThisPtr = nullptr;
11231  if (This) {
11232 #ifndef NDEBUG
11233  auto *MD = dyn_cast<CXXMethodDecl>(Callee);
11234  assert(MD && "Don't provide `this` for non-methods.");
11235  assert(!MD->isStatic() && "Don't provide `this` for static methods.");
11236 #endif
11237  if (EvaluateObjectArgument(Info, This, ThisVal))
11238  ThisPtr = &ThisVal;
11239  if (Info.EvalStatus.HasSideEffects)
11240  return false;
11241  }
11242 
11243  ArgVector ArgValues(Args.size());
11244  for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end();
11245  I != E; ++I) {
11246  if ((*I)->isValueDependent() ||
11247  !Evaluate(ArgValues[I - Args.begin()], Info, *I))
11248  // If evaluation fails, throw away the argument entirely.
11249  ArgValues[I - Args.begin()] = APValue();
11250  if (Info.EvalStatus.HasSideEffects)
11251  return false;
11252  }
11253 
11254  // Build fake call to Callee.
11255  CallStackFrame Frame(Info, Callee->getLocation(), Callee, ThisPtr,
11256  ArgValues.data());
11257  return Evaluate(Value, Info, this) && !Info.EvalStatus.HasSideEffects;
11258 }
11259 
11262  PartialDiagnosticAt> &Diags) {
11263  // FIXME: It would be useful to check constexpr function templates, but at the
11264  // moment the constant expression evaluator cannot cope with the non-rigorous
11265  // ASTs which we build for dependent expressions.
11266  if (FD->isDependentContext())
11267  return true;
11268 
11269  Expr::EvalStatus Status;
11270  Status.Diag = &Diags;
11271 
11272  EvalInfo Info(FD->getASTContext(), Status,
11273  EvalInfo::EM_PotentialConstantExpression);
11274 
11275  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
11276  const CXXRecordDecl *RD = MD ? MD->getParent()->getCanonicalDecl() : nullptr;
11277 
11278  // Fabricate an arbitrary expression on the stack and pretend that it
11279  // is a temporary being used as the 'this' pointer.
11280  LValue This;
11281  ImplicitValueInitExpr VIE(RD ? Info.Ctx.getRecordType(RD) : Info.Ctx.IntTy);
11282  This.set({&VIE, Info.CurrentCall->Index});
11283 
11284  ArrayRef<const Expr*> Args;
11285 
11286  APValue Scratch;
11287  if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
11288  // Evaluate the call as a constant initializer, to allow the construction
11289  // of objects of non-literal types.
11290  Info.setEvaluatingDecl(This.getLValueBase(), Scratch);
11291  HandleConstructorCall(&VIE, This, Args, CD, Info, Scratch);
11292  } else {
11293  SourceLocation Loc = FD->getLocation();
11294  HandleFunctionCall(Loc, FD, (MD && MD->isInstance()) ? &This : nullptr,
11295  Args, FD->getBody(), Info, Scratch, nullptr);
11296  }
11297 
11298  return Diags.empty();
11299 }
11300 
11302  const FunctionDecl *FD,
11304  PartialDiagnosticAt> &Diags) {
11305  Expr::EvalStatus Status;
11306  Status.Diag = &Diags;
11307 
11308  EvalInfo Info(FD->getASTContext(), Status,
11309  EvalInfo::EM_PotentialConstantExpressionUnevaluated);
11310 
11311  // Fabricate a call stack frame to give the arguments a plausible cover story.
11312  ArrayRef<const Expr*> Args;
11313  ArgVector ArgValues(0);
11314  bool Success = EvaluateArgs(Args, ArgValues, Info);
11315  (void)Success;
11316  assert(Success &&
11317  "Failed to set up arguments for potential constant evaluation");
11318  CallStackFrame Frame(Info, SourceLocation(), FD, nullptr, ArgValues.data());
11319 
11320  APValue ResultScratch;
11321  Evaluate(ResultScratch, Info, E);
11322  return Diags.empty();
11323 }
11324 
11325 bool Expr::tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
11326  unsigned Type) const {
11327  if (!getType()->isPointerType())
11328  return false;
11329 
11330  Expr::EvalStatus Status;
11331  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
11332  return tryEvaluateBuiltinObjectSize(this, Type, Info, Result);
11333 }
Expr * getInc()
Definition: Stmt.h:1290
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
Definition: Expr.h:4154
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:5065
bool path_empty() const
Definition: Expr.h:2910
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:593
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:3877
Represents a function declaration or definition.
Definition: Decl.h:1716
bool getValue() const
Definition: ExprObjC.h:96
bool getValue() const
Definition: ExprCXX.h:2464
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition: Type.h:6387
Expr ** getArgs()
Retrieve the call arguments.
Definition: Expr.h:2376
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.
const Stmt * getElse() const
Definition: Stmt.h:1014
body_iterator body_end()
Definition: Stmt.h:649
static bool IsGlobalLValue(APValue::LValueBase B)
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2393
A (possibly-)qualified type.
Definition: Type.h:655
uint64_t getValue() const
Definition: ExprCXX.h:2558
Static storage duration.
Definition: Specifiers.h:280
base_class_range bases()
Definition: DeclCXX.h:825
bool isArrayType() const
Definition: Type.h:6162
bool isMemberPointerType() const
Definition: Type.h:6144
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2596
static Opcode getOpForCompoundAssignment(Opcode Opc)
Definition: Expr.h:3279
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2385
bool hasCaptures() const
True if this block (or its nested blocks) captures anything of local storage from its enclosing scope...
Definition: Decl.h:3982
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:1904
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:819
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:77
bool operator==(CanQual< T > x, CanQual< U > y)
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:195
Expr * getCond()
Definition: Stmt.h:1176
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:2421
CompoundStmt * getSubStmt()
Definition: Expr.h:3670
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4098
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
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:2373
Kind getKind() const
Definition: Type.h:2274
IfStmt - This represents an if/then/else.
Definition: Stmt.h:974
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:497
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:2741
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:1941
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.h:754
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:2050
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:840
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:824
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2090
bool isRecordType() const
Definition: Type.h:6186
void FixedPointValueToString(SmallVectorImpl< char > &Str, const llvm::APSInt &Val, unsigned Scale, unsigned Radix)
Definition: Type.cpp:4034
static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result, EvalInfo &Info)
Expr * getBase() const
Definition: Expr.h:2590
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:86
__DEVICE__ long long abs(long long __n)
llvm::APFloat getValue() const
Definition: Expr.h:1475
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition: Expr.h:4735
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2112
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
Definition: DeclCXX.h:247
ConstExprUsage
Indicates how the constant expression will be used.
Definition: Expr.h:662
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:2008
Opcode getOpcode() const
Definition: Expr.h:3184
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:3727
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1751
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:6062
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:322
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
Definition: Decl.h:2718
The base class of the type hierarchy.
Definition: Type.h:1428
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called...
Definition: ExprCXX.h:1382
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:2668
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1292
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Definition: ExprCXX.h:2507
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:679
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:5800
llvm::DenseMap< Stmt *, Stmt * > MapTy
Definition: ParentMap.cpp:23
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclBase.h:414
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to...
Definition: Decl.h:1209
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:2240
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:2477
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4150
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:4956
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:2703
const Expr * getSubExpr() const
Definition: Expr.h:1547
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "while" statement, if any.
Definition: Stmt.cpp:901
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2293
Expr * getIndexExpr(unsigned Idx)
Definition: Expr.h:2090
static bool EvaluateDecl(EvalInfo &Info, const Decl *D)
const CXXBaseSpecifier *const * path_const_iterator
Definition: Expr.h:2909
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:1888
This file provides some common utility functions for processing Lambda related AST Constructs...
bool EvaluateAsInt(llvm::APSInt &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...
Represents a variable declaration or definition.
Definition: Decl.h:814
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:2271
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2752
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:4695
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6526
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
Definition: Type.h:6475
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type...
Definition: Type.h:6598
ArrayRef< LValuePathEntry > getLValuePath() const
Definition: APValue.cpp:615
bool field_empty() const
Definition: Decl.h:3794
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:549
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:1490
bool isStatic() const
Definition: DeclCXX.cpp:1838
Expr * getExprOperand() const
Definition: ExprCXX.h:728
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3092
static bool isAssignmentOp(Opcode Opc)
Definition: Expr.h:3268
Represents a parameter to a function.
Definition: Decl.h:1535
static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int, CharUnits &Result)
Converts the given APInt to CharUnits, assuming the APInt is unsigned.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "switch" statement, if any.
Definition: Stmt.cpp:867
The collection of all-type qualifiers we support.
Definition: Type.h:154
bool isVariableArrayType() const
Definition: Type.h:6174
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Definition: ExprCXX.cpp:1014
bool isLValueOnePastTheEnd() const
Definition: APValue.cpp:600
static bool HasSameBase(const LValue &A, const LValue &B)
const ValueDecl * getMemberPointerDecl() const
Definition: APValue.cpp:660
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:3016
Represents a struct/union/class.
Definition: Decl.h:3570
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1331
unsigned getVersion() const
Definition: APValue.h:94
Stmt * getBody()
Definition: Stmt.h:1226
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4191
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:3472
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:2729
FieldDecl * getField() const
For a field offsetof node, returns the field.
Definition: Expr.h:1985
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:150
static bool EvaluateVector(const Expr *E, APValue &Result, EvalInfo &Info)
bool isFileScope() const
Definition: Expr.h:2782
field_range fields() const
Definition: Decl.h:3786
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:2534
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:1979
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:3918
bool isReferenceType() const
Definition: Type.h:6125
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2673
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition: Expr.h:936
unsigned getArraySize() const
Definition: APValue.h:348
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6307
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:2892
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:1667
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:6440
static bool isRelationalOp(Opcode Opc)
Definition: Expr.h:3229
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:4050
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:671
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:2612
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:1256
unsigned getLength() const
Definition: Expr.h:1666
static bool isEqualityOp(Opcode Opc)
Definition: Expr.h:3232
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:2596
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2662
bool isElidable() const
Whether this construction is elidable.
Definition: ExprCXX.h:1361
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.
uint32_t Offset
Definition: CacheTokens.cpp:43
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:2802
path_iterator path_begin()
Definition: Expr.h:2916
Stmt * getBody()
Definition: Stmt.h:1291
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)
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3143
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5959
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:1270
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:130
bool isComplexInt() const
Definition: APValue.h:236
bool isArrow() const
Definition: Expr.h:2695
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1383
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:2544
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:40
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5889
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:730
field_iterator field_begin() const
Definition: Decl.cpp:4040
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3717
Expr * getCond()
Definition: Stmt.h:1289
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:2827
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:832
Helper class for OffsetOfExpr.
Definition: Expr.h:1921
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
#define UINT_MAX
Definition: limits.h:72
bool isEquality() const
True iff the comparison category is an equality comparison.
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:839
const ValueInfo * getValueInfo(ComparisonCategoryResult ValueKind) const
APSInt & getComplexIntReal()
Definition: APValue.h:268
A binding in a decomposition declaration.
Definition: DeclCXX.h:3803
bool hasConst() const
Definition: Type.h:271
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2537
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1087
Stmt * getInit()
Definition: Stmt.h:1007
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:877
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:6421
Represents the this expression in C++.
Definition: ExprCXX.h:986
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:1188
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:1776
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:2165
NodeId Parent
Definition: ASTDiff.cpp:192
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3429
StringRef getString() const
Definition: Expr.h:1633
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:616
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1627
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:473
bool isUnion() const
Definition: APValue.h:242
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1355
bool hasLValuePath() const
Definition: APValue.cpp:610
QualType getComputationLHSType() const
Definition: Expr.h:3374
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:705
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2134
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
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:2526
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
unsigned getValue() const
Definition: Expr.h:1442
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:3033
bool hasArrayFiller() const
Definition: APValue.h:333
capture_const_iterator captures_end() const
Definition: DeclCXX.h:1260
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1873
Expr * getCond() const
Definition: Expr.h:3463
QualType getElementType() const
Definition: Type.h:2346
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr...
Definition: Decl.cpp:4280
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
Expr - 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:2313
DeclStmt * getEndStmt()
Definition: StmtCXX.h:160
SourceLocation End
Allow any unmodeled side effect.
Definition: Expr.h:598
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:2060
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
Definition: Expr.h:1995
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:1035
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:3907
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6589
static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object, LValue &This)
Build an lvalue for the object argument of a member function call.
const Stmt * getThen() const
Definition: Stmt.h:1012
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5051
unsigned getNumInits() const
Definition: Expr.h:4080
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3405
Expr * getSubExpr() const
Get the initializer to use for each array element.
Definition: Expr.h:4700
const Expr * getCallee() const
Definition: Expr.h:2356
bool isNullPtrType() const
Definition: Type.h:6365
field_iterator field_end() const
Definition: Decl.h:3789
QualType getArgumentType() const
Definition: Expr.h:2171
#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:1179
DeclContext * getDeclContext()
Definition: DeclBase.h:428
uint32_t getCodeUnit(size_t i) const
Definition: Expr.h:1655
Expr * getRHS()
Definition: Stmt.h:792
AccessKinds
Kinds of access we can perform on an object, for diagnostics.
bool isAnyComplexType() const
Definition: Type.h:6194
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:2069
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:3830
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
static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result, EvalInfo &Info)
void removeLocalConst()
Definition: Type.h:5983
Defines the clang::TypeLoc interface and its subclasses.
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.h:2395
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:1848
Kind getKind() const
Determine what kind of offsetof node this is.
Definition: Expr.h:1975
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:2121
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:2197
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:675
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:1343
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:4194
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?
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:1805
Represents a GCC generic vector type.
Definition: Type.h:3024
bool isNullPointer() const
Definition: APValue.cpp:631
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3946
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1040
const OffsetOfNode & getComponent(unsigned Idx) const
Definition: Expr.h:2076
Allow UB that we can give a value, but not arbitrary unmodeled side effects.
Definition: Expr.h:596
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6484
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2238
ValueDecl * getDecl()
Definition: Expr.h:1059
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:2052
const Expr * getSubExpr() const
Definition: Expr.h:1767
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:720
Stmt *const * const_body_iterator
Definition: Stmt.h:661
bool getValue() const
Definition: ExprCXX.h:569
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:1535
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5922
DoStmt - This represents a &#39;do/while&#39; stmt.
Definition: Stmt.h:1205
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:6407
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
Definition: Expr.cpp:1314
SideEffectsKind
Definition: Expr.h:594
bool isVoidPointerType() const
Definition: Type.cpp:461
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5948
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:4145
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
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:2289
bool getValue() const
Definition: ExprCXX.h:3729
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:347
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:875
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:1930
QualType getCanonicalType() const
Definition: Type.h:5928
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1455
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:2911
const LValueBase getLValueBase() const
Definition: APValue.cpp:595
virtual bool isNan2008() const
Returns true if NaN encoding is IEEE 754-2008.
Definition: TargetInfo.h:936
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:3368
Encodes a location in the source.
body_range body()
Definition: Stmt.h:647
static ICEDiag NoDiag()
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6005
Expr * getSubExpr() const
Definition: Expr.h:1832
CastKind getCastKind() const
Definition: Expr.h:2886
const SwitchCase * getSwitchCaseList() const
Definition: Stmt.h:1094
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2290
APValue & getUnionValue()
Definition: APValue.h:380
Expr * getLHS()
Definition: Stmt.h:791
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.h:401
static bool EvalPointerValueAsBool(const APValue &Value, bool &Result)
static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E, QualType DestType, QualType SrcType, const APSInt &Value)
QualType getElementType() const
Definition: Type.h:3059
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:503
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3780
static bool IsLiteralLValue(const LValue &Value)
APFloat & getFloat()
Definition: APValue.h:260
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:2045
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:1845
#define ilogb(__x)
Definition: tgmath.h:867
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2254
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:1864
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2165
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
Definition: DeclCXX.cpp:1325
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
static bool EvaluateRecord(const Expr *E, const LValue &This, APValue &Result, EvalInfo &Info)
static bool isLogicalOp(Opcode Opc)
Definition: Expr.h:3265
Expr * getSubExpr()
Definition: ExprObjC.h:139
An expression trait intrinsic.
Definition: ExprCXX.h:2579
static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E, QualType SrcType, QualType DestType, APFloat &Result)
bool isVectorType() const
Definition: Type.h:6198
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3654
static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E)
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:121
bool isArgumentType() const
Definition: Expr.h:2170
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:4144
bool isMemberPointerToDerivedMember() const
Definition: APValue.cpp:667
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
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:2778
Expr * getLHS() const
Definition: Expr.h:3187
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3351
CXXConstructorDecl * getConstructor() const
Definition: DeclCXX.h:2464
Represents a C11 generic selection.
Definition: Expr.h:4880
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:3608
static bool EvaluateVoid(const Expr *E, EvalInfo &Info)
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Definition: Expr.h:3547
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "if" statement, if any.
Definition: Stmt.cpp:804
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:3563
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:1330
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1208
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:571
static bool isZeroSized(const LValue &Value)
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1251
bool isImplicit() const
Definition: ExprCXX.h:1010
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:2780
AccessSpecifier getAccess() const
Definition: DeclBase.h:463
const Expr * getInit() const
Definition: Decl.h:1219
A decomposition declaration.
Definition: DeclCXX.h:3851
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition: ExprCXX.h:394
StmtClass getStmtClass() const
Definition: Stmt.h:391
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:2165
const Expr * getExpr() const
Definition: ExprCXX.h:1122
bool isBooleanType() const
Definition: Type.h:6453
unsigned getArrayInitializedElts() const
Definition: APValue.h:344
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:739
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2612
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:1392
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:648
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Definition: APValue.cpp:674
bool isPtrMemOp() const
predicates to categorize the respective opcodes.
Definition: Expr.h:3216
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:1608
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2631
const Stmt * getBody() const
Definition: Stmt.h:1093
llvm::APInt getValue() const
Definition: Expr.h:1302
LabelDecl * getLabel() const
Definition: Expr.h:3632
path_iterator path_end()
Definition: Expr.h:2917
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3702
SwitchStmt - This represents a &#39;switch&#39; stmt.
Definition: Stmt.h:1054
bool isStringLiteralInit() const
Definition: Expr.cpp:1994
bool isArray() const
Definition: APValue.h:240
unsigned getIntWidth(QualType T) const
bool isIncompleteArrayType() const
Definition: Type.h:6170
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:4135
Complex values, per C99 6.2.5p11.
Definition: Type.h:2333
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:2024
bool body_empty() const
Definition: Stmt.h:641
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:2310
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2226
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:1375
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6374
bool isStruct() const
Definition: APValue.h:241
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:396
static CharUnits GetAlignOfType(EvalInfo &Info, QualType T)
T * getAttr() const
Definition: DeclBase.h:534
An implicit indirection through a C++ base class, when the field found is in a base class...
Definition: Expr.h:1933
const llvm::APInt & getSize() const
Definition: Type.h:2746
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:6223
static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E, QualType SrcType, const APSInt &Value, QualType DestType, APFloat &Result)
bool isFunctionType() const
Definition: Type.h:6109
Stmt * getInit()
Definition: Stmt.h:1089
Opcode getOpcode() const
Definition: Expr.h:1829
static bool isAdditiveOp(Opcode Opc)
Definition: Expr.h:3221
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1418
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2529
static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info)
decl_range decls()
Definition: Stmt.h:551
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)
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:3180
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:2052
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2034
DeclStmt * getRangeStmt()
Definition: StmtCXX.h:156
static bool isIncrementOp(Opcode Op)
Definition: Expr.h:1861
unsigned getConstexprBacktraceLimit() const
Retrieve the maximum number of constexpr evaluation notes to emit along with a given diagnostic...
Definition: Diagnostic.h:580
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:1160
A template argument list.
Definition: DeclTemplate.h:210
const SwitchCase * getNextSwitchCase() const
Definition: Stmt.h:738
bool hasMutableFields() const
Determine whether this class, or any of its class subobjects, contains a mutable field.
Definition: DeclCXX.h:1360
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:1223
ValueKind getKind() const
Definition: APValue.h:232
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2500
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:314
APFloat & getComplexFloatImag()
Definition: APValue.h:292
Represents a C++ struct/union/class.
Definition: DeclCXX.h:302
#define scalbn(__x, __y)
Definition: tgmath.h:1181
static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info)
Expr * getTrueExpr() const
Definition: Expr.h:3467
Represents a loop initializing the elements of an array.
Definition: Expr.h:4678
bool isVoidType() const
Definition: Type.h:6340
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:3836
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:3504
An index into an array.
Definition: Expr.h:1926
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5916
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:1147
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:834
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:2250
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:266
CheckSubobjectKind
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1585
Defines the clang::TargetInfo interface.
bool isComplexIntegerType() const
Definition: Type.cpp:479
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2316
bool hasVolatile() const
Definition: Type.h:278
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:3060
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:84
unsigned getNumComponents() const
Definition: Expr.h:2086
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1942
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:974
bool isUnion() const
Definition: Decl.h:3239
Expr * getRHS() const
Definition: Expr.h:3189
Designator - A designator in a C99 designated initializer.
Definition: Designator.h:37
bool isPointerType() const
Definition: Type.h:6113
__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:1256
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:4162
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
Definition: Decl.h:1104
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:163
QualType getType() const
Definition: Decl.h:648
unsigned getNumArgs() const
Definition: ExprCXX.h:1415
bool isFloatingType() const
Definition: Type.cpp:1925
const Expr * getCond() const
Definition: Stmt.h:1010
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:556
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Definition: Expr.h:2027
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:895
Automatic storage duration (most local variables).
Definition: Specifiers.h:278
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:3544
DeclStmt * getBeginStmt()
Definition: StmtCXX.h:157
const Expr * getCond() const
Definition: Stmt.h:1092
bool isFunctionPointerType() const
Definition: Type.h:6137
static bool isComparisonOp(Opcode Opc)
Definition: Expr.h:3235
const LangOptions & getLangOpts() const
Definition: ASTContext.h:696
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2728
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:968
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4772
static void describeCall(CallStackFrame *Frame, raw_ostream &Out)
Produce a string describing the given constexpr call.
SourceLocation getLocation() const
Definition: DeclBase.h:419
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:97
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:2513
ComparisonCategoryResult makeWeakResult(ComparisonCategoryResult Res) const
Converts the specified result kind into the the correct result kind for this category.
CharUnits & getLValueOffset()
Definition: APValue.cpp:605
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:293
unsigned getVectorLength() const
Definition: APValue.h:320