Bug Summary

File:tools/clang/lib/AST/ExprConstant.cpp
Warning:line 5127, column 32
Access to field 'Index' results in a dereference of a null pointer (loaded from field 'CurrentCall')

Annotated Source Code

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"
38#include "clang/AST/ASTDiagnostic.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
51using namespace clang;
52using llvm::APSInt;
53using llvm::APFloat;
54
55static bool IsGlobalLValue(APValue::LValueBase B);
56
57namespace {
58 struct LValue;
59 struct CallStackFrame;
60 struct EvalInfo;
61
62 static QualType getType(APValue::LValueBase B) {
63 if (!B) return QualType();
64 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>())
65 return D->getType();
66
67 const Expr *Base = B.get<const Expr*>();
68
69 // For a materialized temporary, the type of the temporary we materialized
70 // may not be the type of the expression.
71 if (const MaterializeTemporaryExpr *MTE =
72 dyn_cast<MaterializeTemporaryExpr>(Base)) {
73 SmallVector<const Expr *, 2> CommaLHSs;
74 SmallVector<SubobjectAdjustment, 2> Adjustments;
75 const Expr *Temp = MTE->GetTemporaryExpr();
76 const Expr *Inner = Temp->skipRValueSubobjectAdjustments(CommaLHSs,
77 Adjustments);
78 // Keep any cv-qualifiers from the reference if we generated a temporary
79 // for it directly. Otherwise use the type after adjustment.
80 if (!Adjustments.empty())
81 return Inner->getType();
82 }
83
84 return Base->getType();
85 }
86
87 /// Get an LValue path entry, which is known to not be an array index, as a
88 /// field or base class.
89 static
90 APValue::BaseOrMemberType getAsBaseOrMember(APValue::LValuePathEntry E) {
91 APValue::BaseOrMemberType Value;
92 Value.setFromOpaqueValue(E.BaseOrMember);
93 return Value;
94 }
95
96 /// Get an LValue path entry, which is known to not be an array index, as a
97 /// field declaration.
98 static const FieldDecl *getAsField(APValue::LValuePathEntry E) {
99 return dyn_cast<FieldDecl>(getAsBaseOrMember(E).getPointer());
100 }
101 /// Get an LValue path entry, which is known to not be an array index, as a
102 /// base class declaration.
103 static const CXXRecordDecl *getAsBaseClass(APValue::LValuePathEntry E) {
104 return dyn_cast<CXXRecordDecl>(getAsBaseOrMember(E).getPointer());
105 }
106 /// Determine whether this LValue path entry for a base class names a virtual
107 /// base class.
108 static bool isVirtualBaseClass(APValue::LValuePathEntry E) {
109 return getAsBaseOrMember(E).getInt();
110 }
111
112 /// Given a CallExpr, try to get the alloc_size attribute. May return null.
113 static const AllocSizeAttr *getAllocSizeAttr(const CallExpr *CE) {
114 const FunctionDecl *Callee = CE->getDirectCallee();
115 return Callee ? Callee->getAttr<AllocSizeAttr>() : nullptr;
116 }
117
118 /// Attempts to unwrap a CallExpr (with an alloc_size attribute) from an Expr.
119 /// This will look through a single cast.
120 ///
121 /// Returns null if we couldn't unwrap a function with alloc_size.
122 static const CallExpr *tryUnwrapAllocSizeCall(const Expr *E) {
123 if (!E->getType()->isPointerType())
124 return nullptr;
125
126 E = E->IgnoreParens();
127 // If we're doing a variable assignment from e.g. malloc(N), there will
128 // probably be a cast of some kind. Ignore it.
129 if (const auto *Cast = dyn_cast<CastExpr>(E))
130 E = Cast->getSubExpr()->IgnoreParens();
131
132 if (const auto *CE = dyn_cast<CallExpr>(E))
133 return getAllocSizeAttr(CE) ? CE : nullptr;
134 return nullptr;
135 }
136
137 /// Determines whether or not the given Base contains a call to a function
138 /// with the alloc_size attribute.
139 static bool isBaseAnAllocSizeCall(APValue::LValueBase Base) {
140 const auto *E = Base.dyn_cast<const Expr *>();
141 return E && E->getType()->isPointerType() && tryUnwrapAllocSizeCall(E);
142 }
143
144 /// Determines if an LValue with the given LValueBase will have an unsized
145 /// array in its designator.
146 /// Find the path length and type of the most-derived subobject in the given
147 /// path, and find the size of the containing array, if any.
148 static unsigned
149 findMostDerivedSubobject(ASTContext &Ctx, APValue::LValueBase Base,
150 ArrayRef<APValue::LValuePathEntry> Path,
151 uint64_t &ArraySize, QualType &Type, bool &IsArray) {
152 // This only accepts LValueBases from APValues, and APValues don't support
153 // arrays that lack size info.
154 assert(!isBaseAnAllocSizeCall(Base) &&((!isBaseAnAllocSizeCall(Base) && "Unsized arrays shouldn't appear here"
) ? static_cast<void> (0) : __assert_fail ("!isBaseAnAllocSizeCall(Base) && \"Unsized arrays shouldn't appear here\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 155, __PRETTY_FUNCTION__))
155 "Unsized arrays shouldn't appear here")((!isBaseAnAllocSizeCall(Base) && "Unsized arrays shouldn't appear here"
) ? static_cast<void> (0) : __assert_fail ("!isBaseAnAllocSizeCall(Base) && \"Unsized arrays shouldn't appear here\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 155, __PRETTY_FUNCTION__))
;
156 unsigned MostDerivedLength = 0;
157 Type = getType(Base);
158
159 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
160 if (Type->isArrayType()) {
161 const ConstantArrayType *CAT =
162 cast<ConstantArrayType>(Ctx.getAsArrayType(Type));
163 Type = CAT->getElementType();
164 ArraySize = CAT->getSize().getZExtValue();
165 MostDerivedLength = I + 1;
166 IsArray = true;
167 } else if (Type->isAnyComplexType()) {
168 const ComplexType *CT = Type->castAs<ComplexType>();
169 Type = CT->getElementType();
170 ArraySize = 2;
171 MostDerivedLength = I + 1;
172 IsArray = true;
173 } else if (const FieldDecl *FD = getAsField(Path[I])) {
174 Type = FD->getType();
175 ArraySize = 0;
176 MostDerivedLength = I + 1;
177 IsArray = false;
178 } else {
179 // Path[I] describes a base class.
180 ArraySize = 0;
181 IsArray = false;
182 }
183 }
184 return MostDerivedLength;
185 }
186
187 // The order of this enum is important for diagnostics.
188 enum CheckSubobjectKind {
189 CSK_Base, CSK_Derived, CSK_Field, CSK_ArrayToPointer, CSK_ArrayIndex,
190 CSK_This, CSK_Real, CSK_Imag
191 };
192
193 /// A path from a glvalue to a subobject of that glvalue.
194 struct SubobjectDesignator {
195 /// True if the subobject was named in a manner not supported by C++11. Such
196 /// lvalues can still be folded, but they are not core constant expressions
197 /// and we cannot perform lvalue-to-rvalue conversions on them.
198 unsigned Invalid : 1;
199
200 /// Is this a pointer one past the end of an object?
201 unsigned IsOnePastTheEnd : 1;
202
203 /// Indicator of whether the first entry is an unsized array.
204 unsigned FirstEntryIsAnUnsizedArray : 1;
205
206 /// Indicator of whether the most-derived object is an array element.
207 unsigned MostDerivedIsArrayElement : 1;
208
209 /// The length of the path to the most-derived object of which this is a
210 /// subobject.
211 unsigned MostDerivedPathLength : 28;
212
213 /// The size of the array of which the most-derived object is an element.
214 /// This will always be 0 if the most-derived object is not an array
215 /// element. 0 is not an indicator of whether or not the most-derived object
216 /// is an array, however, because 0-length arrays are allowed.
217 ///
218 /// If the current array is an unsized array, the value of this is
219 /// undefined.
220 uint64_t MostDerivedArraySize;
221
222 /// The type of the most derived object referred to by this address.
223 QualType MostDerivedType;
224
225 typedef APValue::LValuePathEntry PathEntry;
226
227 /// The entries on the path from the glvalue to the designated subobject.
228 SmallVector<PathEntry, 8> Entries;
229
230 SubobjectDesignator() : Invalid(true) {}
231
232 explicit SubobjectDesignator(QualType T)
233 : Invalid(false), IsOnePastTheEnd(false),
234 FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
235 MostDerivedPathLength(0), MostDerivedArraySize(0),
236 MostDerivedType(T) {}
237
238 SubobjectDesignator(ASTContext &Ctx, const APValue &V)
239 : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false),
240 FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
241 MostDerivedPathLength(0), MostDerivedArraySize(0) {
242 assert(V.isLValue() && "Non-LValue used to make an LValue designator?")((V.isLValue() && "Non-LValue used to make an LValue designator?"
) ? static_cast<void> (0) : __assert_fail ("V.isLValue() && \"Non-LValue used to make an LValue designator?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 242, __PRETTY_FUNCTION__))
;
243 if (!Invalid) {
244 IsOnePastTheEnd = V.isLValueOnePastTheEnd();
245 ArrayRef<PathEntry> VEntries = V.getLValuePath();
246 Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());
247 if (V.getLValueBase()) {
248 bool IsArray = false;
249 MostDerivedPathLength = findMostDerivedSubobject(
250 Ctx, V.getLValueBase(), V.getLValuePath(), MostDerivedArraySize,
251 MostDerivedType, IsArray);
252 MostDerivedIsArrayElement = IsArray;
253 }
254 }
255 }
256
257 void setInvalid() {
258 Invalid = true;
259 Entries.clear();
260 }
261
262 /// Determine whether the most derived subobject is an array without a
263 /// known bound.
264 bool isMostDerivedAnUnsizedArray() const {
265 assert(!Invalid && "Calling this makes no sense on invalid designators")((!Invalid && "Calling this makes no sense on invalid designators"
) ? static_cast<void> (0) : __assert_fail ("!Invalid && \"Calling this makes no sense on invalid designators\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 265, __PRETTY_FUNCTION__))
;
266 return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;
267 }
268
269 /// Determine what the most derived array's size is. Results in an assertion
270 /// failure if the most derived array lacks a size.
271 uint64_t getMostDerivedArraySize() const {
272 assert(!isMostDerivedAnUnsizedArray() && "Unsized array has no size")((!isMostDerivedAnUnsizedArray() && "Unsized array has no size"
) ? static_cast<void> (0) : __assert_fail ("!isMostDerivedAnUnsizedArray() && \"Unsized array has no size\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 272, __PRETTY_FUNCTION__))
;
273 return MostDerivedArraySize;
274 }
275
276 /// Determine whether this is a one-past-the-end pointer.
277 bool isOnePastTheEnd() const {
278 assert(!Invalid)((!Invalid) ? static_cast<void> (0) : __assert_fail ("!Invalid"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 278, __PRETTY_FUNCTION__))
;
279 if (IsOnePastTheEnd)
280 return true;
281 if (!isMostDerivedAnUnsizedArray() && MostDerivedIsArrayElement &&
282 Entries[MostDerivedPathLength - 1].ArrayIndex == MostDerivedArraySize)
283 return true;
284 return false;
285 }
286
287 /// Check that this refers to a valid subobject.
288 bool isValidSubobject() const {
289 if (Invalid)
290 return false;
291 return !isOnePastTheEnd();
292 }
293 /// Check that this refers to a valid subobject, and if not, produce a
294 /// relevant diagnostic and set the designator as invalid.
295 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK);
296
297 /// Update this designator to refer to the first element within this array.
298 void addArrayUnchecked(const ConstantArrayType *CAT) {
299 PathEntry Entry;
300 Entry.ArrayIndex = 0;
301 Entries.push_back(Entry);
302
303 // This is a most-derived object.
304 MostDerivedType = CAT->getElementType();
305 MostDerivedIsArrayElement = true;
306 MostDerivedArraySize = CAT->getSize().getZExtValue();
307 MostDerivedPathLength = Entries.size();
308 }
309 /// Update this designator to refer to the first element within the array of
310 /// elements of type T. This is an array of unknown size.
311 void addUnsizedArrayUnchecked(QualType ElemTy) {
312 PathEntry Entry;
313 Entry.ArrayIndex = 0;
314 Entries.push_back(Entry);
315
316 MostDerivedType = ElemTy;
317 MostDerivedIsArrayElement = true;
318 // The value in MostDerivedArraySize is undefined in this case. So, set it
319 // to an arbitrary value that's likely to loudly break things if it's
320 // used.
321 MostDerivedArraySize = std::numeric_limits<uint64_t>::max() / 2;
322 MostDerivedPathLength = Entries.size();
323 }
324 /// Update this designator to refer to the given base or member of this
325 /// object.
326 void addDeclUnchecked(const Decl *D, bool Virtual = false) {
327 PathEntry Entry;
328 APValue::BaseOrMemberType Value(D, Virtual);
329 Entry.BaseOrMember = Value.getOpaqueValue();
330 Entries.push_back(Entry);
331
332 // If this isn't a base class, it's a new most-derived object.
333 if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
334 MostDerivedType = FD->getType();
335 MostDerivedIsArrayElement = false;
336 MostDerivedArraySize = 0;
337 MostDerivedPathLength = Entries.size();
338 }
339 }
340 /// Update this designator to refer to the given complex component.
341 void addComplexUnchecked(QualType EltTy, bool Imag) {
342 PathEntry Entry;
343 Entry.ArrayIndex = Imag;
344 Entries.push_back(Entry);
345
346 // This is technically a most-derived object, though in practice this
347 // is unlikely to matter.
348 MostDerivedType = EltTy;
349 MostDerivedIsArrayElement = true;
350 MostDerivedArraySize = 2;
351 MostDerivedPathLength = Entries.size();
352 }
353 void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
354 const APSInt &N);
355 /// Add N to the address of this subobject.
356 void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
357 if (Invalid || !N) return;
358 uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
359 if (isMostDerivedAnUnsizedArray()) {
360 // Can't verify -- trust that the user is doing the right thing (or if
361 // not, trust that the caller will catch the bad behavior).
362 // FIXME: Should we reject if this overflows, at least?
363 Entries.back().ArrayIndex += TruncatedN;
364 return;
365 }
366
367 // [expr.add]p4: For the purposes of these operators, a pointer to a
368 // nonarray object behaves the same as a pointer to the first element of
369 // an array of length one with the type of the object as its element type.
370 bool IsArray = MostDerivedPathLength == Entries.size() &&
371 MostDerivedIsArrayElement;
372 uint64_t ArrayIndex =
373 IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd;
374 uint64_t ArraySize =
375 IsArray ? getMostDerivedArraySize() : (uint64_t)1;
376
377 if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
378 // Calculate the actual index in a wide enough type, so we can include
379 // it in the note.
380 N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
381 (llvm::APInt&)N += ArrayIndex;
382 assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index")((N.ugt(ArraySize) && "bounds check failed for in-bounds index"
) ? static_cast<void> (0) : __assert_fail ("N.ugt(ArraySize) && \"bounds check failed for in-bounds index\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 382, __PRETTY_FUNCTION__))
;
383 diagnosePointerArithmetic(Info, E, N);
384 setInvalid();
385 return;
386 }
387
388 ArrayIndex += TruncatedN;
389 assert(ArrayIndex <= ArraySize &&((ArrayIndex <= ArraySize && "bounds check succeeded for out-of-bounds index"
) ? static_cast<void> (0) : __assert_fail ("ArrayIndex <= ArraySize && \"bounds check succeeded for out-of-bounds index\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 390, __PRETTY_FUNCTION__))
390 "bounds check succeeded for out-of-bounds index")((ArrayIndex <= ArraySize && "bounds check succeeded for out-of-bounds index"
) ? static_cast<void> (0) : __assert_fail ("ArrayIndex <= ArraySize && \"bounds check succeeded for out-of-bounds index\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 390, __PRETTY_FUNCTION__))
;
391
392 if (IsArray)
393 Entries.back().ArrayIndex = ArrayIndex;
394 else
395 IsOnePastTheEnd = (ArrayIndex != 0);
396 }
397 };
398
399 /// A stack frame in the constexpr call stack.
400 struct CallStackFrame {
401 EvalInfo &Info;
402
403 /// Parent - The caller of this stack frame.
404 CallStackFrame *Caller;
405
406 /// Callee - The function which was called.
407 const FunctionDecl *Callee;
408
409 /// This - The binding for the this pointer in this call, if any.
410 const LValue *This;
411
412 /// Arguments - Parameter bindings for this function call, indexed by
413 /// parameters' function scope indices.
414 APValue *Arguments;
415
416 // Note that we intentionally use std::map here so that references to
417 // values are stable.
418 typedef std::map<const void*, APValue> MapTy;
419 typedef MapTy::const_iterator temp_iterator;
420 /// Temporaries - Temporary lvalues materialized within this stack frame.
421 MapTy Temporaries;
422
423 /// CallLoc - The location of the call expression for this call.
424 SourceLocation CallLoc;
425
426 /// Index - The call index of this call.
427 unsigned Index;
428
429 // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact
430 // on the overall stack usage of deeply-recursing constexpr evaluataions.
431 // (We should cache this map rather than recomputing it repeatedly.)
432 // But let's try this and see how it goes; we can look into caching the map
433 // as a later change.
434
435 /// LambdaCaptureFields - Mapping from captured variables/this to
436 /// corresponding data members in the closure class.
437 llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
438 FieldDecl *LambdaThisCaptureField;
439
440 CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
441 const FunctionDecl *Callee, const LValue *This,
442 APValue *Arguments);
443 ~CallStackFrame();
444
445 APValue *getTemporary(const void *Key) {
446 MapTy::iterator I = Temporaries.find(Key);
447 return I == Temporaries.end() ? nullptr : &I->second;
448 }
449 APValue &createTemporary(const void *Key, bool IsLifetimeExtended);
450 };
451
452 /// Temporarily override 'this'.
453 class ThisOverrideRAII {
454 public:
455 ThisOverrideRAII(CallStackFrame &Frame, const LValue *NewThis, bool Enable)
456 : Frame(Frame), OldThis(Frame.This) {
457 if (Enable)
458 Frame.This = NewThis;
459 }
460 ~ThisOverrideRAII() {
461 Frame.This = OldThis;
462 }
463 private:
464 CallStackFrame &Frame;
465 const LValue *OldThis;
466 };
467
468 /// A partial diagnostic which we might know in advance that we are not going
469 /// to emit.
470 class OptionalDiagnostic {
471 PartialDiagnostic *Diag;
472
473 public:
474 explicit OptionalDiagnostic(PartialDiagnostic *Diag = nullptr)
475 : Diag(Diag) {}
476
477 template<typename T>
478 OptionalDiagnostic &operator<<(const T &v) {
479 if (Diag)
480 *Diag << v;
481 return *this;
482 }
483
484 OptionalDiagnostic &operator<<(const APSInt &I) {
485 if (Diag) {
486 SmallVector<char, 32> Buffer;
487 I.toString(Buffer);
488 *Diag << StringRef(Buffer.data(), Buffer.size());
489 }
490 return *this;
491 }
492
493 OptionalDiagnostic &operator<<(const APFloat &F) {
494 if (Diag) {
495 // FIXME: Force the precision of the source value down so we don't
496 // print digits which are usually useless (we don't really care here if
497 // we truncate a digit by accident in edge cases). Ideally,
498 // APFloat::toString would automatically print the shortest
499 // representation which rounds to the correct value, but it's a bit
500 // tricky to implement.
501 unsigned precision =
502 llvm::APFloat::semanticsPrecision(F.getSemantics());
503 precision = (precision * 59 + 195) / 196;
504 SmallVector<char, 32> Buffer;
505 F.toString(Buffer, precision);
506 *Diag << StringRef(Buffer.data(), Buffer.size());
507 }
508 return *this;
509 }
510 };
511
512 /// A cleanup, and a flag indicating whether it is lifetime-extended.
513 class Cleanup {
514 llvm::PointerIntPair<APValue*, 1, bool> Value;
515
516 public:
517 Cleanup(APValue *Val, bool IsLifetimeExtended)
518 : Value(Val, IsLifetimeExtended) {}
519
520 bool isLifetimeExtended() const { return Value.getInt(); }
521 void endLifetime() {
522 *Value.getPointer() = APValue();
523 }
524 };
525
526 /// EvalInfo - This is a private struct used by the evaluator to capture
527 /// information about a subexpression as it is folded. It retains information
528 /// about the AST context, but also maintains information about the folded
529 /// expression.
530 ///
531 /// If an expression could be evaluated, it is still possible it is not a C
532 /// "integer constant expression" or constant expression. If not, this struct
533 /// captures information about how and why not.
534 ///
535 /// One bit of information passed *into* the request for constant folding
536 /// indicates whether the subexpression is "evaluated" or not according to C
537 /// rules. For example, the RHS of (0 && foo()) is not evaluated. We can
538 /// evaluate the expression regardless of what the RHS is, but C only allows
539 /// certain things in certain situations.
540 struct LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8)alignas(8) EvalInfo {
541 ASTContext &Ctx;
542
543 /// EvalStatus - Contains information about the evaluation.
544 Expr::EvalStatus &EvalStatus;
545
546 /// CurrentCall - The top of the constexpr call stack.
547 CallStackFrame *CurrentCall;
548
549 /// CallStackDepth - The number of calls in the call stack right now.
550 unsigned CallStackDepth;
551
552 /// NextCallIndex - The next call index to assign.
553 unsigned NextCallIndex;
554
555 /// StepsLeft - The remaining number of evaluation steps we're permitted
556 /// to perform. This is essentially a limit for the number of statements
557 /// we will evaluate.
558 unsigned StepsLeft;
559
560 /// BottomFrame - The frame in which evaluation started. This must be
561 /// initialized after CurrentCall and CallStackDepth.
562 CallStackFrame BottomFrame;
563
564 /// A stack of values whose lifetimes end at the end of some surrounding
565 /// evaluation frame.
566 llvm::SmallVector<Cleanup, 16> CleanupStack;
567
568 /// EvaluatingDecl - This is the declaration whose initializer is being
569 /// evaluated, if any.
570 APValue::LValueBase EvaluatingDecl;
571
572 /// EvaluatingDeclValue - This is the value being constructed for the
573 /// declaration whose initializer is being evaluated, if any.
574 APValue *EvaluatingDeclValue;
575
576 /// The current array initialization index, if we're performing array
577 /// initialization.
578 uint64_t ArrayInitIndex = -1;
579
580 /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further
581 /// notes attached to it will also be stored, otherwise they will not be.
582 bool HasActiveDiagnostic;
583
584 /// \brief Have we emitted a diagnostic explaining why we couldn't constant
585 /// fold (not just why it's not strictly a constant expression)?
586 bool HasFoldFailureDiagnostic;
587
588 /// \brief Whether or not we're currently speculatively evaluating.
589 bool IsSpeculativelyEvaluating;
590
591 enum EvaluationMode {
592 /// Evaluate as a constant expression. Stop if we find that the expression
593 /// is not a constant expression.
594 EM_ConstantExpression,
595
596 /// Evaluate as a potential constant expression. Keep going if we hit a
597 /// construct that we can't evaluate yet (because we don't yet know the
598 /// value of something) but stop if we hit something that could never be
599 /// a constant expression.
600 EM_PotentialConstantExpression,
601
602 /// Fold the expression to a constant. Stop if we hit a side-effect that
603 /// we can't model.
604 EM_ConstantFold,
605
606 /// Evaluate the expression looking for integer overflow and similar
607 /// issues. Don't worry about side-effects, and try to visit all
608 /// subexpressions.
609 EM_EvaluateForOverflow,
610
611 /// Evaluate in any way we know how. Don't worry about side-effects that
612 /// can't be modeled.
613 EM_IgnoreSideEffects,
614
615 /// Evaluate as a constant expression. Stop if we find that the expression
616 /// is not a constant expression. Some expressions can be retried in the
617 /// optimizer if we don't constant fold them here, but in an unevaluated
618 /// context we try to fold them immediately since the optimizer never
619 /// gets a chance to look at it.
620 EM_ConstantExpressionUnevaluated,
621
622 /// Evaluate as a potential constant expression. Keep going if we hit a
623 /// construct that we can't evaluate yet (because we don't yet know the
624 /// value of something) but stop if we hit something that could never be
625 /// a constant expression. Some expressions can be retried in the
626 /// optimizer if we don't constant fold them here, but in an unevaluated
627 /// context we try to fold them immediately since the optimizer never
628 /// gets a chance to look at it.
629 EM_PotentialConstantExpressionUnevaluated,
630
631 /// Evaluate as a constant expression. In certain scenarios, if:
632 /// - we find a MemberExpr with a base that can't be evaluated, or
633 /// - we find a variable initialized with a call to a function that has
634 /// the alloc_size attribute on it
635 /// then we may consider evaluation to have succeeded.
636 ///
637 /// In either case, the LValue returned shall have an invalid base; in the
638 /// former, the base will be the invalid MemberExpr, in the latter, the
639 /// base will be either the alloc_size CallExpr or a CastExpr wrapping
640 /// said CallExpr.
641 EM_OffsetFold,
642 } EvalMode;
643
644 /// Are we checking whether the expression is a potential constant
645 /// expression?
646 bool checkingPotentialConstantExpression() const {
647 return EvalMode == EM_PotentialConstantExpression ||
648 EvalMode == EM_PotentialConstantExpressionUnevaluated;
649 }
650
651 /// Are we checking an expression for overflow?
652 // FIXME: We should check for any kind of undefined or suspicious behavior
653 // in such constructs, not just overflow.
654 bool checkingForOverflow() { return EvalMode == EM_EvaluateForOverflow; }
655
656 EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
657 : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
658 CallStackDepth(0), NextCallIndex(1),
659 StepsLeft(getLangOpts().ConstexprStepLimit),
660 BottomFrame(*this, SourceLocation(), nullptr, nullptr, nullptr),
661 EvaluatingDecl((const ValueDecl *)nullptr),
662 EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
663 HasFoldFailureDiagnostic(false), IsSpeculativelyEvaluating(false),
664 EvalMode(Mode) {}
665
666 void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value) {
667 EvaluatingDecl = Base;
668 EvaluatingDeclValue = &Value;
669 }
670
671 const LangOptions &getLangOpts() const { return Ctx.getLangOpts(); }
672
673 bool CheckCallLimit(SourceLocation Loc) {
674 // Don't perform any constexpr calls (other than the call we're checking)
675 // when checking a potential constant expression.
676 if (checkingPotentialConstantExpression() && CallStackDepth > 1)
677 return false;
678 if (NextCallIndex == 0) {
679 // NextCallIndex has wrapped around.
680 FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);
681 return false;
682 }
683 if (CallStackDepth <= getLangOpts().ConstexprCallDepth)
684 return true;
685 FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded)
686 << getLangOpts().ConstexprCallDepth;
687 return false;
688 }
689
690 CallStackFrame *getCallFrame(unsigned CallIndex) {
691 assert(CallIndex && "no call index in getCallFrame")((CallIndex && "no call index in getCallFrame") ? static_cast
<void> (0) : __assert_fail ("CallIndex && \"no call index in getCallFrame\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 691, __PRETTY_FUNCTION__))
;
692 // We will eventually hit BottomFrame, which has Index 1, so Frame can't
693 // be null in this loop.
694 CallStackFrame *Frame = CurrentCall;
695 while (Frame->Index > CallIndex)
696 Frame = Frame->Caller;
697 return (Frame->Index == CallIndex) ? Frame : nullptr;
698 }
699
700 bool nextStep(const Stmt *S) {
701 if (!StepsLeft) {
702 FFDiag(S->getLocStart(), diag::note_constexpr_step_limit_exceeded);
703 return false;
704 }
705 --StepsLeft;
706 return true;
707 }
708
709 private:
710 /// Add a diagnostic to the diagnostics list.
711 PartialDiagnostic &addDiag(SourceLocation Loc, diag::kind DiagId) {
712 PartialDiagnostic PD(DiagId, Ctx.getDiagAllocator());
713 EvalStatus.Diag->push_back(std::make_pair(Loc, PD));
714 return EvalStatus.Diag->back().second;
715 }
716
717 /// Add notes containing a call stack to the current point of evaluation.
718 void addCallStack(unsigned Limit);
719
720 private:
721 OptionalDiagnostic Diag(SourceLocation Loc, diag::kind DiagId,
722 unsigned ExtraNotes, bool IsCCEDiag) {
723
724 if (EvalStatus.Diag) {
725 // If we have a prior diagnostic, it will be noting that the expression
726 // isn't a constant expression. This diagnostic is more important,
727 // unless we require this evaluation to produce a constant expression.
728 //
729 // FIXME: We might want to show both diagnostics to the user in
730 // EM_ConstantFold mode.
731 if (!EvalStatus.Diag->empty()) {
732 switch (EvalMode) {
733 case EM_ConstantFold:
734 case EM_IgnoreSideEffects:
735 case EM_EvaluateForOverflow:
736 if (!HasFoldFailureDiagnostic)
737 break;
738 // We've already failed to fold something. Keep that diagnostic.
739 case EM_ConstantExpression:
740 case EM_PotentialConstantExpression:
741 case EM_ConstantExpressionUnevaluated:
742 case EM_PotentialConstantExpressionUnevaluated:
743 case EM_OffsetFold:
744 HasActiveDiagnostic = false;
745 return OptionalDiagnostic();
746 }
747 }
748
749 unsigned CallStackNotes = CallStackDepth - 1;
750 unsigned Limit = Ctx.getDiagnostics().getConstexprBacktraceLimit();
751 if (Limit)
752 CallStackNotes = std::min(CallStackNotes, Limit + 1);
753 if (checkingPotentialConstantExpression())
754 CallStackNotes = 0;
755
756 HasActiveDiagnostic = true;
757 HasFoldFailureDiagnostic = !IsCCEDiag;
758 EvalStatus.Diag->clear();
759 EvalStatus.Diag->reserve(1 + ExtraNotes + CallStackNotes);
760 addDiag(Loc, DiagId);
761 if (!checkingPotentialConstantExpression())
762 addCallStack(Limit);
763 return OptionalDiagnostic(&(*EvalStatus.Diag)[0].second);
764 }
765 HasActiveDiagnostic = false;
766 return OptionalDiagnostic();
767 }
768 public:
769 // Diagnose that the evaluation could not be folded (FF => FoldFailure)
770 OptionalDiagnostic
771 FFDiag(SourceLocation Loc,
772 diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
773 unsigned ExtraNotes = 0) {
774 return Diag(Loc, DiagId, ExtraNotes, false);
775 }
776
777 OptionalDiagnostic FFDiag(const Expr *E, diag::kind DiagId
778 = diag::note_invalid_subexpr_in_const_expr,
779 unsigned ExtraNotes = 0) {
780 if (EvalStatus.Diag)
781 return Diag(E->getExprLoc(), DiagId, ExtraNotes, /*IsCCEDiag*/false);
782 HasActiveDiagnostic = false;
783 return OptionalDiagnostic();
784 }
785
786 /// Diagnose that the evaluation does not produce a C++11 core constant
787 /// expression.
788 ///
789 /// FIXME: Stop evaluating if we're in EM_ConstantExpression or
790 /// EM_PotentialConstantExpression mode and we produce one of these.
791 OptionalDiagnostic CCEDiag(SourceLocation Loc, diag::kind DiagId
792 = diag::note_invalid_subexpr_in_const_expr,
793 unsigned ExtraNotes = 0) {
794 // Don't override a previous diagnostic. Don't bother collecting
795 // diagnostics if we're evaluating for overflow.
796 if (!EvalStatus.Diag || !EvalStatus.Diag->empty()) {
797 HasActiveDiagnostic = false;
798 return OptionalDiagnostic();
799 }
800 return Diag(Loc, DiagId, ExtraNotes, true);
801 }
802 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind DiagId
803 = diag::note_invalid_subexpr_in_const_expr,
804 unsigned ExtraNotes = 0) {
805 return CCEDiag(E->getExprLoc(), DiagId, ExtraNotes);
806 }
807 /// Add a note to a prior diagnostic.
808 OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId) {
809 if (!HasActiveDiagnostic)
810 return OptionalDiagnostic();
811 return OptionalDiagnostic(&addDiag(Loc, DiagId));
812 }
813
814 /// Add a stack of notes to a prior diagnostic.
815 void addNotes(ArrayRef<PartialDiagnosticAt> Diags) {
816 if (HasActiveDiagnostic) {
817 EvalStatus.Diag->insert(EvalStatus.Diag->end(),
818 Diags.begin(), Diags.end());
819 }
820 }
821
822 /// Should we continue evaluation after encountering a side-effect that we
823 /// couldn't model?
824 bool keepEvaluatingAfterSideEffect() {
825 switch (EvalMode) {
826 case EM_PotentialConstantExpression:
827 case EM_PotentialConstantExpressionUnevaluated:
828 case EM_EvaluateForOverflow:
829 case EM_IgnoreSideEffects:
830 return true;
831
832 case EM_ConstantExpression:
833 case EM_ConstantExpressionUnevaluated:
834 case EM_ConstantFold:
835 case EM_OffsetFold:
836 return false;
837 }
838 llvm_unreachable("Missed EvalMode case")::llvm::llvm_unreachable_internal("Missed EvalMode case", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 838)
;
839 }
840
841 /// Note that we have had a side-effect, and determine whether we should
842 /// keep evaluating.
843 bool noteSideEffect() {
844 EvalStatus.HasSideEffects = true;
845 return keepEvaluatingAfterSideEffect();
846 }
847
848 /// Should we continue evaluation after encountering undefined behavior?
849 bool keepEvaluatingAfterUndefinedBehavior() {
850 switch (EvalMode) {
851 case EM_EvaluateForOverflow:
852 case EM_IgnoreSideEffects:
853 case EM_ConstantFold:
854 case EM_OffsetFold:
855 return true;
856
857 case EM_PotentialConstantExpression:
858 case EM_PotentialConstantExpressionUnevaluated:
859 case EM_ConstantExpression:
860 case EM_ConstantExpressionUnevaluated:
861 return false;
862 }
863 llvm_unreachable("Missed EvalMode case")::llvm::llvm_unreachable_internal("Missed EvalMode case", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 863)
;
864 }
865
866 /// Note that we hit something that was technically undefined behavior, but
867 /// that we can evaluate past it (such as signed overflow or floating-point
868 /// division by zero.)
869 bool noteUndefinedBehavior() {
870 EvalStatus.HasUndefinedBehavior = true;
871 return keepEvaluatingAfterUndefinedBehavior();
872 }
873
874 /// Should we continue evaluation as much as possible after encountering a
875 /// construct which can't be reduced to a value?
876 bool keepEvaluatingAfterFailure() {
877 if (!StepsLeft)
878 return false;
879
880 switch (EvalMode) {
881 case EM_PotentialConstantExpression:
882 case EM_PotentialConstantExpressionUnevaluated:
883 case EM_EvaluateForOverflow:
884 return true;
885
886 case EM_ConstantExpression:
887 case EM_ConstantExpressionUnevaluated:
888 case EM_ConstantFold:
889 case EM_IgnoreSideEffects:
890 case EM_OffsetFold:
891 return false;
892 }
893 llvm_unreachable("Missed EvalMode case")::llvm::llvm_unreachable_internal("Missed EvalMode case", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 893)
;
894 }
895
896 /// Notes that we failed to evaluate an expression that other expressions
897 /// directly depend on, and determine if we should keep evaluating. This
898 /// should only be called if we actually intend to keep evaluating.
899 ///
900 /// Call noteSideEffect() instead if we may be able to ignore the value that
901 /// we failed to evaluate, e.g. if we failed to evaluate Foo() in:
902 ///
903 /// (Foo(), 1) // use noteSideEffect
904 /// (Foo() || true) // use noteSideEffect
905 /// Foo() + 1 // use noteFailure
906 LLVM_NODISCARD[[clang::warn_unused_result]] bool noteFailure() {
907 // Failure when evaluating some expression often means there is some
908 // subexpression whose evaluation was skipped. Therefore, (because we
909 // don't track whether we skipped an expression when unwinding after an
910 // evaluation failure) every evaluation failure that bubbles up from a
911 // subexpression implies that a side-effect has potentially happened. We
912 // skip setting the HasSideEffects flag to true until we decide to
913 // continue evaluating after that point, which happens here.
914 bool KeepGoing = keepEvaluatingAfterFailure();
915 EvalStatus.HasSideEffects |= KeepGoing;
916 return KeepGoing;
917 }
918
919 class ArrayInitLoopIndex {
920 EvalInfo &Info;
921 uint64_t OuterIndex;
922
923 public:
924 ArrayInitLoopIndex(EvalInfo &Info)
925 : Info(Info), OuterIndex(Info.ArrayInitIndex) {
926 Info.ArrayInitIndex = 0;
927 }
928 ~ArrayInitLoopIndex() { Info.ArrayInitIndex = OuterIndex; }
929
930 operator uint64_t&() { return Info.ArrayInitIndex; }
931 };
932 };
933
934 /// Object used to treat all foldable expressions as constant expressions.
935 struct FoldConstant {
936 EvalInfo &Info;
937 bool Enabled;
938 bool HadNoPriorDiags;
939 EvalInfo::EvaluationMode OldMode;
940
941 explicit FoldConstant(EvalInfo &Info, bool Enabled)
942 : Info(Info),
943 Enabled(Enabled),
944 HadNoPriorDiags(Info.EvalStatus.Diag &&
945 Info.EvalStatus.Diag->empty() &&
946 !Info.EvalStatus.HasSideEffects),
947 OldMode(Info.EvalMode) {
948 if (Enabled &&
949 (Info.EvalMode == EvalInfo::EM_ConstantExpression ||
950 Info.EvalMode == EvalInfo::EM_ConstantExpressionUnevaluated))
951 Info.EvalMode = EvalInfo::EM_ConstantFold;
952 }
953 void keepDiagnostics() { Enabled = false; }
954 ~FoldConstant() {
955 if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
956 !Info.EvalStatus.HasSideEffects)
957 Info.EvalStatus.Diag->clear();
958 Info.EvalMode = OldMode;
959 }
960 };
961
962 /// RAII object used to treat the current evaluation as the correct pointer
963 /// offset fold for the current EvalMode
964 struct FoldOffsetRAII {
965 EvalInfo &Info;
966 EvalInfo::EvaluationMode OldMode;
967 explicit FoldOffsetRAII(EvalInfo &Info)
968 : Info(Info), OldMode(Info.EvalMode) {
969 if (!Info.checkingPotentialConstantExpression())
970 Info.EvalMode = EvalInfo::EM_OffsetFold;
971 }
972
973 ~FoldOffsetRAII() { Info.EvalMode = OldMode; }
974 };
975
976 /// RAII object used to optionally suppress diagnostics and side-effects from
977 /// a speculative evaluation.
978 class SpeculativeEvaluationRAII {
979 /// Pair of EvalInfo, and a bit that stores whether or not we were
980 /// speculatively evaluating when we created this RAII.
981 llvm::PointerIntPair<EvalInfo *, 1, bool> InfoAndOldSpecEval;
982 Expr::EvalStatus Old;
983
984 void moveFromAndCancel(SpeculativeEvaluationRAII &&Other) {
985 InfoAndOldSpecEval = Other.InfoAndOldSpecEval;
986 Old = Other.Old;
987 Other.InfoAndOldSpecEval.setPointer(nullptr);
988 }
989
990 void maybeRestoreState() {
991 EvalInfo *Info = InfoAndOldSpecEval.getPointer();
992 if (!Info)
993 return;
994
995 Info->EvalStatus = Old;
996 Info->IsSpeculativelyEvaluating = InfoAndOldSpecEval.getInt();
997 }
998
999 public:
1000 SpeculativeEvaluationRAII() = default;
1001
1002 SpeculativeEvaluationRAII(
1003 EvalInfo &Info, SmallVectorImpl<PartialDiagnosticAt> *NewDiag = nullptr)
1004 : InfoAndOldSpecEval(&Info, Info.IsSpeculativelyEvaluating),
1005 Old(Info.EvalStatus) {
1006 Info.EvalStatus.Diag = NewDiag;
1007 Info.IsSpeculativelyEvaluating = true;
1008 }
1009
1010 SpeculativeEvaluationRAII(const SpeculativeEvaluationRAII &Other) = delete;
1011 SpeculativeEvaluationRAII(SpeculativeEvaluationRAII &&Other) {
1012 moveFromAndCancel(std::move(Other));
1013 }
1014
1015 SpeculativeEvaluationRAII &operator=(SpeculativeEvaluationRAII &&Other) {
1016 maybeRestoreState();
1017 moveFromAndCancel(std::move(Other));
1018 return *this;
1019 }
1020
1021 ~SpeculativeEvaluationRAII() { maybeRestoreState(); }
1022 };
1023
1024 /// RAII object wrapping a full-expression or block scope, and handling
1025 /// the ending of the lifetime of temporaries created within it.
1026 template<bool IsFullExpression>
1027 class ScopeRAII {
1028 EvalInfo &Info;
1029 unsigned OldStackSize;
1030 public:
1031 ScopeRAII(EvalInfo &Info)
1032 : Info(Info), OldStackSize(Info.CleanupStack.size()) {}
1033 ~ScopeRAII() {
1034 // Body moved to a static method to encourage the compiler to inline away
1035 // instances of this class.
1036 cleanup(Info, OldStackSize);
1037 }
1038 private:
1039 static void cleanup(EvalInfo &Info, unsigned OldStackSize) {
1040 unsigned NewEnd = OldStackSize;
1041 for (unsigned I = OldStackSize, N = Info.CleanupStack.size();
1042 I != N; ++I) {
1043 if (IsFullExpression && Info.CleanupStack[I].isLifetimeExtended()) {
1044 // Full-expression cleanup of a lifetime-extended temporary: nothing
1045 // to do, just move this cleanup to the right place in the stack.
1046 std::swap(Info.CleanupStack[I], Info.CleanupStack[NewEnd]);
1047 ++NewEnd;
1048 } else {
1049 // End the lifetime of the object.
1050 Info.CleanupStack[I].endLifetime();
1051 }
1052 }
1053 Info.CleanupStack.erase(Info.CleanupStack.begin() + NewEnd,
1054 Info.CleanupStack.end());
1055 }
1056 };
1057 typedef ScopeRAII<false> BlockScopeRAII;
1058 typedef ScopeRAII<true> FullExpressionRAII;
1059}
1060
1061bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
1062 CheckSubobjectKind CSK) {
1063 if (Invalid)
1064 return false;
1065 if (isOnePastTheEnd()) {
1066 Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
1067 << CSK;
1068 setInvalid();
1069 return false;
1070 }
1071 return true;
1072}
1073
1074void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
1075 const Expr *E,
1076 const APSInt &N) {
1077 // If we're complaining, we must be able to statically determine the size of
1078 // the most derived array.
1079 if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)
1080 Info.CCEDiag(E, diag::note_constexpr_array_index)
1081 << N << /*array*/ 0
1082 << static_cast<unsigned>(getMostDerivedArraySize());
1083 else
1084 Info.CCEDiag(E, diag::note_constexpr_array_index)
1085 << N << /*non-array*/ 1;
1086 setInvalid();
1087}
1088
1089CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
1090 const FunctionDecl *Callee, const LValue *This,
1091 APValue *Arguments)
1092 : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This),
1093 Arguments(Arguments), CallLoc(CallLoc), Index(Info.NextCallIndex++) {
1094 Info.CurrentCall = this;
1095 ++Info.CallStackDepth;
1096}
1097
1098CallStackFrame::~CallStackFrame() {
1099 assert(Info.CurrentCall == this && "calls retired out of order")((Info.CurrentCall == this && "calls retired out of order"
) ? static_cast<void> (0) : __assert_fail ("Info.CurrentCall == this && \"calls retired out of order\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1099, __PRETTY_FUNCTION__))
;
1100 --Info.CallStackDepth;
1101 Info.CurrentCall = Caller;
1102}
1103
1104APValue &CallStackFrame::createTemporary(const void *Key,
1105 bool IsLifetimeExtended) {
1106 APValue &Result = Temporaries[Key];
1107 assert(Result.isUninit() && "temporary created multiple times")((Result.isUninit() && "temporary created multiple times"
) ? static_cast<void> (0) : __assert_fail ("Result.isUninit() && \"temporary created multiple times\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1107, __PRETTY_FUNCTION__))
;
1108 Info.CleanupStack.push_back(Cleanup(&Result, IsLifetimeExtended));
1109 return Result;
1110}
1111
1112static void describeCall(CallStackFrame *Frame, raw_ostream &Out);
1113
1114void EvalInfo::addCallStack(unsigned Limit) {
1115 // Determine which calls to skip, if any.
1116 unsigned ActiveCalls = CallStackDepth - 1;
1117 unsigned SkipStart = ActiveCalls, SkipEnd = SkipStart;
1118 if (Limit && Limit < ActiveCalls) {
1119 SkipStart = Limit / 2 + Limit % 2;
1120 SkipEnd = ActiveCalls - Limit / 2;
1121 }
1122
1123 // Walk the call stack and add the diagnostics.
1124 unsigned CallIdx = 0;
1125 for (CallStackFrame *Frame = CurrentCall; Frame != &BottomFrame;
1126 Frame = Frame->Caller, ++CallIdx) {
1127 // Skip this call?
1128 if (CallIdx >= SkipStart && CallIdx < SkipEnd) {
1129 if (CallIdx == SkipStart) {
1130 // Note that we're skipping calls.
1131 addDiag(Frame->CallLoc, diag::note_constexpr_calls_suppressed)
1132 << unsigned(ActiveCalls - Limit);
1133 }
1134 continue;
1135 }
1136
1137 // Use a different note for an inheriting constructor, because from the
1138 // user's perspective it's not really a function at all.
1139 if (auto *CD = dyn_cast_or_null<CXXConstructorDecl>(Frame->Callee)) {
1140 if (CD->isInheritingConstructor()) {
1141 addDiag(Frame->CallLoc, diag::note_constexpr_inherited_ctor_call_here)
1142 << CD->getParent();
1143 continue;
1144 }
1145 }
1146
1147 SmallVector<char, 128> Buffer;
1148 llvm::raw_svector_ostream Out(Buffer);
1149 describeCall(Frame, Out);
1150 addDiag(Frame->CallLoc, diag::note_constexpr_call_here) << Out.str();
1151 }
1152}
1153
1154namespace {
1155 struct ComplexValue {
1156 private:
1157 bool IsInt;
1158
1159 public:
1160 APSInt IntReal, IntImag;
1161 APFloat FloatReal, FloatImag;
1162
1163 ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
1164
1165 void makeComplexFloat() { IsInt = false; }
1166 bool isComplexFloat() const { return !IsInt; }
1167 APFloat &getComplexFloatReal() { return FloatReal; }
1168 APFloat &getComplexFloatImag() { return FloatImag; }
1169
1170 void makeComplexInt() { IsInt = true; }
1171 bool isComplexInt() const { return IsInt; }
1172 APSInt &getComplexIntReal() { return IntReal; }
1173 APSInt &getComplexIntImag() { return IntImag; }
1174
1175 void moveInto(APValue &v) const {
1176 if (isComplexFloat())
1177 v = APValue(FloatReal, FloatImag);
1178 else
1179 v = APValue(IntReal, IntImag);
1180 }
1181 void setFrom(const APValue &v) {
1182 assert(v.isComplexFloat() || v.isComplexInt())((v.isComplexFloat() || v.isComplexInt()) ? static_cast<void
> (0) : __assert_fail ("v.isComplexFloat() || v.isComplexInt()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1182, __PRETTY_FUNCTION__))
;
1183 if (v.isComplexFloat()) {
1184 makeComplexFloat();
1185 FloatReal = v.getComplexFloatReal();
1186 FloatImag = v.getComplexFloatImag();
1187 } else {
1188 makeComplexInt();
1189 IntReal = v.getComplexIntReal();
1190 IntImag = v.getComplexIntImag();
1191 }
1192 }
1193 };
1194
1195 struct LValue {
1196 APValue::LValueBase Base;
1197 CharUnits Offset;
1198 unsigned InvalidBase : 1;
1199 unsigned CallIndex : 31;
1200 SubobjectDesignator Designator;
1201 bool IsNullPtr;
1202
1203 const APValue::LValueBase getLValueBase() const { return Base; }
1204 CharUnits &getLValueOffset() { return Offset; }
1205 const CharUnits &getLValueOffset() const { return Offset; }
1206 unsigned getLValueCallIndex() const { return CallIndex; }
1207 SubobjectDesignator &getLValueDesignator() { return Designator; }
1208 const SubobjectDesignator &getLValueDesignator() const { return Designator;}
1209 bool isNullPointer() const { return IsNullPtr;}
1210
1211 void moveInto(APValue &V) const {
1212 if (Designator.Invalid)
1213 V = APValue(Base, Offset, APValue::NoLValuePath(), CallIndex,
1214 IsNullPtr);
1215 else {
1216 assert(!InvalidBase && "APValues can't handle invalid LValue bases")((!InvalidBase && "APValues can't handle invalid LValue bases"
) ? static_cast<void> (0) : __assert_fail ("!InvalidBase && \"APValues can't handle invalid LValue bases\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1216, __PRETTY_FUNCTION__))
;
1217 assert(!Designator.FirstEntryIsAnUnsizedArray &&((!Designator.FirstEntryIsAnUnsizedArray && "Unsized array with a valid base?"
) ? static_cast<void> (0) : __assert_fail ("!Designator.FirstEntryIsAnUnsizedArray && \"Unsized array with a valid base?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1218, __PRETTY_FUNCTION__))
1218 "Unsized array with a valid base?")((!Designator.FirstEntryIsAnUnsizedArray && "Unsized array with a valid base?"
) ? static_cast<void> (0) : __assert_fail ("!Designator.FirstEntryIsAnUnsizedArray && \"Unsized array with a valid base?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1218, __PRETTY_FUNCTION__))
;
1219 V = APValue(Base, Offset, Designator.Entries,
1220 Designator.IsOnePastTheEnd, CallIndex, IsNullPtr);
1221 }
1222 }
1223 void setFrom(ASTContext &Ctx, const APValue &V) {
1224 assert(V.isLValue() && "Setting LValue from a non-LValue?")((V.isLValue() && "Setting LValue from a non-LValue?"
) ? static_cast<void> (0) : __assert_fail ("V.isLValue() && \"Setting LValue from a non-LValue?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1224, __PRETTY_FUNCTION__))
;
1225 Base = V.getLValueBase();
1226 Offset = V.getLValueOffset();
1227 InvalidBase = false;
1228 CallIndex = V.getLValueCallIndex();
1229 Designator = SubobjectDesignator(Ctx, V);
1230 IsNullPtr = V.isNullPointer();
1231 }
1232
1233 void set(APValue::LValueBase B, unsigned I = 0, bool BInvalid = false,
1234 bool IsNullPtr_ = false, uint64_t Offset_ = 0) {
1235#ifndef NDEBUG
1236 // We only allow a few types of invalid bases. Enforce that here.
1237 if (BInvalid) {
1238 const auto *E = B.get<const Expr *>();
1239 assert((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&(((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&
"Unexpected type of invalid base") ? static_cast<void>
(0) : __assert_fail ("(isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) && \"Unexpected type of invalid base\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1240, __PRETTY_FUNCTION__))
1240 "Unexpected type of invalid base")(((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&
"Unexpected type of invalid base") ? static_cast<void>
(0) : __assert_fail ("(isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) && \"Unexpected type of invalid base\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1240, __PRETTY_FUNCTION__))
;
1241 }
1242#endif
1243
1244 Base = B;
1245 Offset = CharUnits::fromQuantity(Offset_);
1246 InvalidBase = BInvalid;
1247 CallIndex = I;
1248 Designator = SubobjectDesignator(getType(B));
1249 IsNullPtr = IsNullPtr_;
1250 }
1251
1252 void setInvalid(APValue::LValueBase B, unsigned I = 0) {
1253 set(B, I, true);
1254 }
1255
1256 // Check that this LValue is not based on a null pointer. If it is, produce
1257 // a diagnostic and mark the designator as invalid.
1258 bool checkNullPointer(EvalInfo &Info, const Expr *E,
1259 CheckSubobjectKind CSK) {
1260 if (Designator.Invalid)
1261 return false;
1262 if (IsNullPtr) {
1263 Info.CCEDiag(E, diag::note_constexpr_null_subobject)
1264 << CSK;
1265 Designator.setInvalid();
1266 return false;
1267 }
1268 return true;
1269 }
1270
1271 // Check this LValue refers to an object. If not, set the designator to be
1272 // invalid and emit a diagnostic.
1273 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {
1274 return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
1275 Designator.checkSubobject(Info, E, CSK);
1276 }
1277
1278 void addDecl(EvalInfo &Info, const Expr *E,
1279 const Decl *D, bool Virtual = false) {
1280 if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
1281 Designator.addDeclUnchecked(D, Virtual);
1282 }
1283 void addUnsizedArray(EvalInfo &Info, QualType ElemTy) {
1284 assert(Designator.Entries.empty() && getType(Base)->isPointerType())((Designator.Entries.empty() && getType(Base)->isPointerType
()) ? static_cast<void> (0) : __assert_fail ("Designator.Entries.empty() && getType(Base)->isPointerType()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1284, __PRETTY_FUNCTION__))
;
1285 assert(isBaseAnAllocSizeCall(Base) &&((isBaseAnAllocSizeCall(Base) && "Only alloc_size bases can have unsized arrays"
) ? static_cast<void> (0) : __assert_fail ("isBaseAnAllocSizeCall(Base) && \"Only alloc_size bases can have unsized arrays\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1286, __PRETTY_FUNCTION__))
1286 "Only alloc_size bases can have unsized arrays")((isBaseAnAllocSizeCall(Base) && "Only alloc_size bases can have unsized arrays"
) ? static_cast<void> (0) : __assert_fail ("isBaseAnAllocSizeCall(Base) && \"Only alloc_size bases can have unsized arrays\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1286, __PRETTY_FUNCTION__))
;
1287 Designator.FirstEntryIsAnUnsizedArray = true;
1288 Designator.addUnsizedArrayUnchecked(ElemTy);
1289 }
1290 void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
1291 if (checkSubobject(Info, E, CSK_ArrayToPointer))
1292 Designator.addArrayUnchecked(CAT);
1293 }
1294 void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
1295 if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
1296 Designator.addComplexUnchecked(EltTy, Imag);
1297 }
1298 void clearIsNullPointer() {
1299 IsNullPtr = false;
1300 }
1301 void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
1302 const APSInt &Index, CharUnits ElementSize) {
1303 // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB,
1304 // but we're not required to diagnose it and it's valid in C++.)
1305 if (!Index)
1306 return;
1307
1308 // Compute the new offset in the appropriate width, wrapping at 64 bits.
1309 // FIXME: When compiling for a 32-bit target, we should use 32-bit
1310 // offsets.
1311 uint64_t Offset64 = Offset.getQuantity();
1312 uint64_t ElemSize64 = ElementSize.getQuantity();
1313 uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
1314 Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64);
1315
1316 if (checkNullPointer(Info, E, CSK_ArrayIndex))
1317 Designator.adjustIndex(Info, E, Index);
1318 clearIsNullPointer();
1319 }
1320 void adjustOffset(CharUnits N) {
1321 Offset += N;
1322 if (N.getQuantity())
1323 clearIsNullPointer();
1324 }
1325 };
1326
1327 struct MemberPtr {
1328 MemberPtr() {}
1329 explicit MemberPtr(const ValueDecl *Decl) :
1330 DeclAndIsDerivedMember(Decl, false), Path() {}
1331
1332 /// The member or (direct or indirect) field referred to by this member
1333 /// pointer, or 0 if this is a null member pointer.
1334 const ValueDecl *getDecl() const {
1335 return DeclAndIsDerivedMember.getPointer();
1336 }
1337 /// Is this actually a member of some type derived from the relevant class?
1338 bool isDerivedMember() const {
1339 return DeclAndIsDerivedMember.getInt();
1340 }
1341 /// Get the class which the declaration actually lives in.
1342 const CXXRecordDecl *getContainingRecord() const {
1343 return cast<CXXRecordDecl>(
1344 DeclAndIsDerivedMember.getPointer()->getDeclContext());
1345 }
1346
1347 void moveInto(APValue &V) const {
1348 V = APValue(getDecl(), isDerivedMember(), Path);
1349 }
1350 void setFrom(const APValue &V) {
1351 assert(V.isMemberPointer())((V.isMemberPointer()) ? static_cast<void> (0) : __assert_fail
("V.isMemberPointer()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1351, __PRETTY_FUNCTION__))
;
1352 DeclAndIsDerivedMember.setPointer(V.getMemberPointerDecl());
1353 DeclAndIsDerivedMember.setInt(V.isMemberPointerToDerivedMember());
1354 Path.clear();
1355 ArrayRef<const CXXRecordDecl*> P = V.getMemberPointerPath();
1356 Path.insert(Path.end(), P.begin(), P.end());
1357 }
1358
1359 /// DeclAndIsDerivedMember - The member declaration, and a flag indicating
1360 /// whether the member is a member of some class derived from the class type
1361 /// of the member pointer.
1362 llvm::PointerIntPair<const ValueDecl*, 1, bool> DeclAndIsDerivedMember;
1363 /// Path - The path of base/derived classes from the member declaration's
1364 /// class (exclusive) to the class type of the member pointer (inclusive).
1365 SmallVector<const CXXRecordDecl*, 4> Path;
1366
1367 /// Perform a cast towards the class of the Decl (either up or down the
1368 /// hierarchy).
1369 bool castBack(const CXXRecordDecl *Class) {
1370 assert(!Path.empty())((!Path.empty()) ? static_cast<void> (0) : __assert_fail
("!Path.empty()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1370, __PRETTY_FUNCTION__))
;
1371 const CXXRecordDecl *Expected;
1372 if (Path.size() >= 2)
1373 Expected = Path[Path.size() - 2];
1374 else
1375 Expected = getContainingRecord();
1376 if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) {
1377 // C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*),
1378 // if B does not contain the original member and is not a base or
1379 // derived class of the class containing the original member, the result
1380 // of the cast is undefined.
1381 // C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to
1382 // (D::*). We consider that to be a language defect.
1383 return false;
1384 }
1385 Path.pop_back();
1386 return true;
1387 }
1388 /// Perform a base-to-derived member pointer cast.
1389 bool castToDerived(const CXXRecordDecl *Derived) {
1390 if (!getDecl())
1391 return true;
1392 if (!isDerivedMember()) {
1393 Path.push_back(Derived);
1394 return true;
1395 }
1396 if (!castBack(Derived))
1397 return false;
1398 if (Path.empty())
1399 DeclAndIsDerivedMember.setInt(false);
1400 return true;
1401 }
1402 /// Perform a derived-to-base member pointer cast.
1403 bool castToBase(const CXXRecordDecl *Base) {
1404 if (!getDecl())
1405 return true;
1406 if (Path.empty())
1407 DeclAndIsDerivedMember.setInt(true);
1408 if (isDerivedMember()) {
1409 Path.push_back(Base);
1410 return true;
1411 }
1412 return castBack(Base);
1413 }
1414 };
1415
1416 /// Compare two member pointers, which are assumed to be of the same type.
1417 static bool operator==(const MemberPtr &LHS, const MemberPtr &RHS) {
1418 if (!LHS.getDecl() || !RHS.getDecl())
1419 return !LHS.getDecl() && !RHS.getDecl();
1420 if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl())
1421 return false;
1422 return LHS.Path == RHS.Path;
1423 }
1424}
1425
1426static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E);
1427static bool EvaluateInPlace(APValue &Result, EvalInfo &Info,
1428 const LValue &This, const Expr *E,
1429 bool AllowNonLiteralTypes = false);
1430static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
1431 bool InvalidBaseOK = false);
1432static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info,
1433 bool InvalidBaseOK = false);
1434static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
1435 EvalInfo &Info);
1436static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info);
1437static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
1438static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
1439 EvalInfo &Info);
1440static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
1441static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info);
1442static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
1443 EvalInfo &Info);
1444static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result);
1445
1446//===----------------------------------------------------------------------===//
1447// Misc utilities
1448//===----------------------------------------------------------------------===//
1449
1450/// Negate an APSInt in place, converting it to a signed form if necessary, and
1451/// preserving its value (by extending by up to one bit as needed).
1452static void negateAsSigned(APSInt &Int) {
1453 if (Int.isUnsigned() || Int.isMinSignedValue()) {
1454 Int = Int.extend(Int.getBitWidth() + 1);
1455 Int.setIsSigned(true);
1456 }
1457 Int = -Int;
1458}
1459
1460/// Produce a string describing the given constexpr call.
1461static void describeCall(CallStackFrame *Frame, raw_ostream &Out) {
1462 unsigned ArgIndex = 0;
1463 bool IsMemberCall = isa<CXXMethodDecl>(Frame->Callee) &&
1464 !isa<CXXConstructorDecl>(Frame->Callee) &&
1465 cast<CXXMethodDecl>(Frame->Callee)->isInstance();
1466
1467 if (!IsMemberCall)
1468 Out << *Frame->Callee << '(';
1469
1470 if (Frame->This && IsMemberCall) {
1471 APValue Val;
1472 Frame->This->moveInto(Val);
1473 Val.printPretty(Out, Frame->Info.Ctx,
1474 Frame->This->Designator.MostDerivedType);
1475 // FIXME: Add parens around Val if needed.
1476 Out << "->" << *Frame->Callee << '(';
1477 IsMemberCall = false;
1478 }
1479
1480 for (FunctionDecl::param_const_iterator I = Frame->Callee->param_begin(),
1481 E = Frame->Callee->param_end(); I != E; ++I, ++ArgIndex) {
1482 if (ArgIndex > (unsigned)IsMemberCall)
1483 Out << ", ";
1484
1485 const ParmVarDecl *Param = *I;
1486 const APValue &Arg = Frame->Arguments[ArgIndex];
1487 Arg.printPretty(Out, Frame->Info.Ctx, Param->getType());
1488
1489 if (ArgIndex == 0 && IsMemberCall)
1490 Out << "->" << *Frame->Callee << '(';
1491 }
1492
1493 Out << ')';
1494}
1495
1496/// Evaluate an expression to see if it had side-effects, and discard its
1497/// result.
1498/// \return \c true if the caller should keep evaluating.
1499static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
1500 APValue Scratch;
1501 if (!Evaluate(Scratch, Info, E))
1502 // We don't need the value, but we might have skipped a side effect here.
1503 return Info.noteSideEffect();
1504 return true;
1505}
1506
1507/// Should this call expression be treated as a string literal?
1508static bool IsStringLiteralCall(const CallExpr *E) {
1509 unsigned Builtin = E->getBuiltinCallee();
1510 return (Builtin == Builtin::BI__builtin___CFStringMakeConstantString ||
1511 Builtin == Builtin::BI__builtin___NSStringMakeConstantString);
1512}
1513
1514static bool IsGlobalLValue(APValue::LValueBase B) {
1515 // C++11 [expr.const]p3 An address constant expression is a prvalue core
1516 // constant expression of pointer type that evaluates to...
1517
1518 // ... a null pointer value, or a prvalue core constant expression of type
1519 // std::nullptr_t.
1520 if (!B) return true;
1521
1522 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
1523 // ... the address of an object with static storage duration,
1524 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1525 return VD->hasGlobalStorage();
1526 // ... the address of a function,
1527 return isa<FunctionDecl>(D);
1528 }
1529
1530 const Expr *E = B.get<const Expr*>();
1531 switch (E->getStmtClass()) {
1532 default:
1533 return false;
1534 case Expr::CompoundLiteralExprClass: {
1535 const CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
1536 return CLE->isFileScope() && CLE->isLValue();
1537 }
1538 case Expr::MaterializeTemporaryExprClass:
1539 // A materialized temporary might have been lifetime-extended to static
1540 // storage duration.
1541 return cast<MaterializeTemporaryExpr>(E)->getStorageDuration() == SD_Static;
1542 // A string literal has static storage duration.
1543 case Expr::StringLiteralClass:
1544 case Expr::PredefinedExprClass:
1545 case Expr::ObjCStringLiteralClass:
1546 case Expr::ObjCEncodeExprClass:
1547 case Expr::CXXTypeidExprClass:
1548 case Expr::CXXUuidofExprClass:
1549 return true;
1550 case Expr::CallExprClass:
1551 return IsStringLiteralCall(cast<CallExpr>(E));
1552 // For GCC compatibility, &&label has static storage duration.
1553 case Expr::AddrLabelExprClass:
1554 return true;
1555 // A Block literal expression may be used as the initialization value for
1556 // Block variables at global or local static scope.
1557 case Expr::BlockExprClass:
1558 return !cast<BlockExpr>(E)->getBlockDecl()->hasCaptures();
1559 case Expr::ImplicitValueInitExprClass:
1560 // FIXME:
1561 // We can never form an lvalue with an implicit value initialization as its
1562 // base through expression evaluation, so these only appear in one case: the
1563 // implicit variable declaration we invent when checking whether a constexpr
1564 // constructor can produce a constant expression. We must assume that such
1565 // an expression might be a global lvalue.
1566 return true;
1567 }
1568}
1569
1570static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) {
1571 assert(Base && "no location for a null lvalue")((Base && "no location for a null lvalue") ? static_cast
<void> (0) : __assert_fail ("Base && \"no location for a null lvalue\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1571, __PRETTY_FUNCTION__))
;
1572 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1573 if (VD)
1574 Info.Note(VD->getLocation(), diag::note_declared_at);
1575 else
1576 Info.Note(Base.get<const Expr*>()->getExprLoc(),
1577 diag::note_constexpr_temporary_here);
1578}
1579
1580/// Check that this reference or pointer core constant expression is a valid
1581/// value for an address or reference constant expression. Return true if we
1582/// can fold this expression, whether or not it's a constant expression.
1583static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
1584 QualType Type, const LValue &LVal) {
1585 bool IsReferenceType = Type->isReferenceType();
1586
1587 APValue::LValueBase Base = LVal.getLValueBase();
1588 const SubobjectDesignator &Designator = LVal.getLValueDesignator();
1589
1590 // Check that the object is a global. Note that the fake 'this' object we
1591 // manufacture when checking potential constant expressions is conservatively
1592 // assumed to be global here.
1593 if (!IsGlobalLValue(Base)) {
1594 if (Info.getLangOpts().CPlusPlus11) {
1595 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1596 Info.FFDiag(Loc, diag::note_constexpr_non_global, 1)
1597 << IsReferenceType << !Designator.Entries.empty()
1598 << !!VD << VD;
1599 NoteLValueLocation(Info, Base);
1600 } else {
1601 Info.FFDiag(Loc);
1602 }
1603 // Don't allow references to temporaries to escape.
1604 return false;
1605 }
1606 assert((Info.checkingPotentialConstantExpression() ||(((Info.checkingPotentialConstantExpression() || LVal.getLValueCallIndex
() == 0) && "have call index for global lvalue") ? static_cast
<void> (0) : __assert_fail ("(Info.checkingPotentialConstantExpression() || LVal.getLValueCallIndex() == 0) && \"have call index for global lvalue\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1608, __PRETTY_FUNCTION__))
1607 LVal.getLValueCallIndex() == 0) &&(((Info.checkingPotentialConstantExpression() || LVal.getLValueCallIndex
() == 0) && "have call index for global lvalue") ? static_cast
<void> (0) : __assert_fail ("(Info.checkingPotentialConstantExpression() || LVal.getLValueCallIndex() == 0) && \"have call index for global lvalue\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1608, __PRETTY_FUNCTION__))
1608 "have call index for global lvalue")(((Info.checkingPotentialConstantExpression() || LVal.getLValueCallIndex
() == 0) && "have call index for global lvalue") ? static_cast
<void> (0) : __assert_fail ("(Info.checkingPotentialConstantExpression() || LVal.getLValueCallIndex() == 0) && \"have call index for global lvalue\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1608, __PRETTY_FUNCTION__))
;
1609
1610 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
1611 if (const VarDecl *Var = dyn_cast<const VarDecl>(VD)) {
1612 // Check if this is a thread-local variable.
1613 if (Var->getTLSKind())
1614 return false;
1615
1616 // A dllimport variable never acts like a constant.
1617 if (Var->hasAttr<DLLImportAttr>())
1618 return false;
1619 }
1620 if (const auto *FD = dyn_cast<const FunctionDecl>(VD)) {
1621 // __declspec(dllimport) must be handled very carefully:
1622 // We must never initialize an expression with the thunk in C++.
1623 // Doing otherwise would allow the same id-expression to yield
1624 // different addresses for the same function in different translation
1625 // units. However, this means that we must dynamically initialize the
1626 // expression with the contents of the import address table at runtime.
1627 //
1628 // The C language has no notion of ODR; furthermore, it has no notion of
1629 // dynamic initialization. This means that we are permitted to
1630 // perform initialization with the address of the thunk.
1631 if (Info.getLangOpts().CPlusPlus && FD->hasAttr<DLLImportAttr>())
1632 return false;
1633 }
1634 }
1635
1636 // Allow address constant expressions to be past-the-end pointers. This is
1637 // an extension: the standard requires them to point to an object.
1638 if (!IsReferenceType)
1639 return true;
1640
1641 // A reference constant expression must refer to an object.
1642 if (!Base) {
1643 // FIXME: diagnostic
1644 Info.CCEDiag(Loc);
1645 return true;
1646 }
1647
1648 // Does this refer one past the end of some object?
1649 if (!Designator.Invalid && Designator.isOnePastTheEnd()) {
1650 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
1651 Info.FFDiag(Loc, diag::note_constexpr_past_end, 1)
1652 << !Designator.Entries.empty() << !!VD << VD;
1653 NoteLValueLocation(Info, Base);
1654 }
1655
1656 return true;
1657}
1658
1659/// Check that this core constant expression is of literal type, and if not,
1660/// produce an appropriate diagnostic.
1661static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
1662 const LValue *This = nullptr) {
1663 if (!E->isRValue() || E->getType()->isLiteralType(Info.Ctx))
1664 return true;
1665
1666 // C++1y: A constant initializer for an object o [...] may also invoke
1667 // constexpr constructors for o and its subobjects even if those objects
1668 // are of non-literal class types.
1669 //
1670 // C++11 missed this detail for aggregates, so classes like this:
1671 // struct foo_t { union { int i; volatile int j; } u; };
1672 // are not (obviously) initializable like so:
1673 // __attribute__((__require_constant_initialization__))
1674 // static const foo_t x = {{0}};
1675 // because "i" is a subobject with non-literal initialization (due to the
1676 // volatile member of the union). See:
1677 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1677
1678 // Therefore, we use the C++1y behavior.
1679 if (This && Info.EvaluatingDecl == This->getLValueBase())
1680 return true;
1681
1682 // Prvalue constant expressions must be of literal types.
1683 if (Info.getLangOpts().CPlusPlus11)
1684 Info.FFDiag(E, diag::note_constexpr_nonliteral)
1685 << E->getType();
1686 else
1687 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
1688 return false;
1689}
1690
1691/// Check that this core constant expression value is a valid value for a
1692/// constant expression. If not, report an appropriate diagnostic. Does not
1693/// check that the expression is of literal type.
1694static bool CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc,
1695 QualType Type, const APValue &Value) {
1696 if (Value.isUninit()) {
1697 Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized)
1698 << true << Type;
1699 return false;
1700 }
1701
1702 // We allow _Atomic(T) to be initialized from anything that T can be
1703 // initialized from.
1704 if (const AtomicType *AT = Type->getAs<AtomicType>())
1705 Type = AT->getValueType();
1706
1707 // Core issue 1454: For a literal constant expression of array or class type,
1708 // each subobject of its value shall have been initialized by a constant
1709 // expression.
1710 if (Value.isArray()) {
1711 QualType EltTy = Type->castAsArrayTypeUnsafe()->getElementType();
1712 for (unsigned I = 0, N = Value.getArrayInitializedElts(); I != N; ++I) {
1713 if (!CheckConstantExpression(Info, DiagLoc, EltTy,
1714 Value.getArrayInitializedElt(I)))
1715 return false;
1716 }
1717 if (!Value.hasArrayFiller())
1718 return true;
1719 return CheckConstantExpression(Info, DiagLoc, EltTy,
1720 Value.getArrayFiller());
1721 }
1722 if (Value.isUnion() && Value.getUnionField()) {
1723 return CheckConstantExpression(Info, DiagLoc,
1724 Value.getUnionField()->getType(),
1725 Value.getUnionValue());
1726 }
1727 if (Value.isStruct()) {
1728 RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
1729 if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
1730 unsigned BaseIndex = 0;
1731 for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(),
1732 End = CD->bases_end(); I != End; ++I, ++BaseIndex) {
1733 if (!CheckConstantExpression(Info, DiagLoc, I->getType(),
1734 Value.getStructBase(BaseIndex)))
1735 return false;
1736 }
1737 }
1738 for (const auto *I : RD->fields()) {
1739 if (!CheckConstantExpression(Info, DiagLoc, I->getType(),
1740 Value.getStructField(I->getFieldIndex())))
1741 return false;
1742 }
1743 }
1744
1745 if (Value.isLValue()) {
1746 LValue LVal;
1747 LVal.setFrom(Info.Ctx, Value);
1748 return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal);
1749 }
1750
1751 // Everything else is fine.
1752 return true;
1753}
1754
1755static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) {
1756 return LVal.Base.dyn_cast<const ValueDecl*>();
1757}
1758
1759static bool IsLiteralLValue(const LValue &Value) {
1760 if (Value.CallIndex)
1761 return false;
1762 const Expr *E = Value.Base.dyn_cast<const Expr*>();
1763 return E && !isa<MaterializeTemporaryExpr>(E);
1764}
1765
1766static bool IsWeakLValue(const LValue &Value) {
1767 const ValueDecl *Decl = GetLValueBaseDecl(Value);
1768 return Decl && Decl->isWeak();
1769}
1770
1771static bool isZeroSized(const LValue &Value) {
1772 const ValueDecl *Decl = GetLValueBaseDecl(Value);
1773 if (Decl && isa<VarDecl>(Decl)) {
1774 QualType Ty = Decl->getType();
1775 if (Ty->isArrayType())
1776 return Ty->isIncompleteType() ||
1777 Decl->getASTContext().getTypeSize(Ty) == 0;
1778 }
1779 return false;
1780}
1781
1782static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) {
1783 // A null base expression indicates a null pointer. These are always
1784 // evaluatable, and they are false unless the offset is zero.
1785 if (!Value.getLValueBase()) {
1786 Result = !Value.getLValueOffset().isZero();
1787 return true;
1788 }
1789
1790 // We have a non-null base. These are generally known to be true, but if it's
1791 // a weak declaration it can be null at runtime.
1792 Result = true;
1793 const ValueDecl *Decl = Value.getLValueBase().dyn_cast<const ValueDecl*>();
1794 return !Decl || !Decl->isWeak();
1795}
1796
1797static bool HandleConversionToBool(const APValue &Val, bool &Result) {
1798 switch (Val.getKind()) {
1799 case APValue::Uninitialized:
1800 return false;
1801 case APValue::Int:
1802 Result = Val.getInt().getBoolValue();
1803 return true;
1804 case APValue::Float:
1805 Result = !Val.getFloat().isZero();
1806 return true;
1807 case APValue::ComplexInt:
1808 Result = Val.getComplexIntReal().getBoolValue() ||
1809 Val.getComplexIntImag().getBoolValue();
1810 return true;
1811 case APValue::ComplexFloat:
1812 Result = !Val.getComplexFloatReal().isZero() ||
1813 !Val.getComplexFloatImag().isZero();
1814 return true;
1815 case APValue::LValue:
1816 return EvalPointerValueAsBool(Val, Result);
1817 case APValue::MemberPointer:
1818 Result = Val.getMemberPointerDecl();
1819 return true;
1820 case APValue::Vector:
1821 case APValue::Array:
1822 case APValue::Struct:
1823 case APValue::Union:
1824 case APValue::AddrLabelDiff:
1825 return false;
1826 }
1827
1828 llvm_unreachable("unknown APValue kind")::llvm::llvm_unreachable_internal("unknown APValue kind", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1828)
;
1829}
1830
1831static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
1832 EvalInfo &Info) {
1833 assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition")((E->isRValue() && "missing lvalue-to-rvalue conv in bool condition"
) ? static_cast<void> (0) : __assert_fail ("E->isRValue() && \"missing lvalue-to-rvalue conv in bool condition\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1833, __PRETTY_FUNCTION__))
;
1834 APValue Val;
1835 if (!Evaluate(Val, Info, E))
1836 return false;
1837 return HandleConversionToBool(Val, Result);
1838}
1839
1840template<typename T>
1841static bool HandleOverflow(EvalInfo &Info, const Expr *E,
1842 const T &SrcValue, QualType DestType) {
1843 Info.CCEDiag(E, diag::note_constexpr_overflow)
1844 << SrcValue << DestType;
1845 return Info.noteUndefinedBehavior();
1846}
1847
1848static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
1849 QualType SrcType, const APFloat &Value,
1850 QualType DestType, APSInt &Result) {
1851 unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
1852 // Determine whether we are converting to unsigned or signed.
1853 bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
1854
1855 Result = APSInt(DestWidth, !DestSigned);
1856 bool ignored;
1857 if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
1858 & APFloat::opInvalidOp)
1859 return HandleOverflow(Info, E, Value, DestType);
1860 return true;
1861}
1862
1863static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E,
1864 QualType SrcType, QualType DestType,
1865 APFloat &Result) {
1866 APFloat Value = Result;
1867 bool ignored;
1868 if (Result.convert(Info.Ctx.getFloatTypeSemantics(DestType),
1869 APFloat::rmNearestTiesToEven, &ignored)
1870 & APFloat::opOverflow)
1871 return HandleOverflow(Info, E, Value, DestType);
1872 return true;
1873}
1874
1875static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E,
1876 QualType DestType, QualType SrcType,
1877 const APSInt &Value) {
1878 unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
1879 APSInt Result = Value;
1880 // Figure out if this is a truncate, extend or noop cast.
1881 // If the input is signed, do a sign extend, noop, or truncate.
1882 Result = Result.extOrTrunc(DestWidth);
1883 Result.setIsUnsigned(DestType->isUnsignedIntegerOrEnumerationType());
1884 return Result;
1885}
1886
1887static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E,
1888 QualType SrcType, const APSInt &Value,
1889 QualType DestType, APFloat &Result) {
1890 Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
1891 if (Result.convertFromAPInt(Value, Value.isSigned(),
1892 APFloat::rmNearestTiesToEven)
1893 & APFloat::opOverflow)
1894 return HandleOverflow(Info, E, Value, DestType);
1895 return true;
1896}
1897
1898static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E,
1899 APValue &Value, const FieldDecl *FD) {
1900 assert(FD->isBitField() && "truncateBitfieldValue on non-bitfield")((FD->isBitField() && "truncateBitfieldValue on non-bitfield"
) ? static_cast<void> (0) : __assert_fail ("FD->isBitField() && \"truncateBitfieldValue on non-bitfield\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1900, __PRETTY_FUNCTION__))
;
1901
1902 if (!Value.isInt()) {
1903 // Trying to store a pointer-cast-to-integer into a bitfield.
1904 // FIXME: In this case, we should provide the diagnostic for casting
1905 // a pointer to an integer.
1906 assert(Value.isLValue() && "integral value neither int nor lvalue?")((Value.isLValue() && "integral value neither int nor lvalue?"
) ? static_cast<void> (0) : __assert_fail ("Value.isLValue() && \"integral value neither int nor lvalue?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 1906, __PRETTY_FUNCTION__))
;
1907 Info.FFDiag(E);
1908 return false;
1909 }
1910
1911 APSInt &Int = Value.getInt();
1912 unsigned OldBitWidth = Int.getBitWidth();
1913 unsigned NewBitWidth = FD->getBitWidthValue(Info.Ctx);
1914 if (NewBitWidth < OldBitWidth)
1915 Int = Int.trunc(NewBitWidth).extend(OldBitWidth);
1916 return true;
1917}
1918
1919static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E,
1920 llvm::APInt &Res) {
1921 APValue SVal;
1922 if (!Evaluate(SVal, Info, E))
1923 return false;
1924 if (SVal.isInt()) {
1925 Res = SVal.getInt();
1926 return true;
1927 }
1928 if (SVal.isFloat()) {
1929 Res = SVal.getFloat().bitcastToAPInt();
1930 return true;
1931 }
1932 if (SVal.isVector()) {
1933 QualType VecTy = E->getType();
1934 unsigned VecSize = Info.Ctx.getTypeSize(VecTy);
1935 QualType EltTy = VecTy->castAs<VectorType>()->getElementType();
1936 unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
1937 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
1938 Res = llvm::APInt::getNullValue(VecSize);
1939 for (unsigned i = 0; i < SVal.getVectorLength(); i++) {
1940 APValue &Elt = SVal.getVectorElt(i);
1941 llvm::APInt EltAsInt;
1942 if (Elt.isInt()) {
1943 EltAsInt = Elt.getInt();
1944 } else if (Elt.isFloat()) {
1945 EltAsInt = Elt.getFloat().bitcastToAPInt();
1946 } else {
1947 // Don't try to handle vectors of anything other than int or float
1948 // (not sure if it's possible to hit this case).
1949 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
1950 return false;
1951 }
1952 unsigned BaseEltSize = EltAsInt.getBitWidth();
1953 if (BigEndian)
1954 Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i*EltSize+BaseEltSize);
1955 else
1956 Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i*EltSize);
1957 }
1958 return true;
1959 }
1960 // Give up if the input isn't an int, float, or vector. For example, we
1961 // reject "(v4i16)(intptr_t)&a".
1962 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
1963 return false;
1964}
1965
1966/// Perform the given integer operation, which is known to need at most BitWidth
1967/// bits, and check for overflow in the original type (if that type was not an
1968/// unsigned type).
1969template<typename Operation>
1970static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E,
1971 const APSInt &LHS, const APSInt &RHS,
1972 unsigned BitWidth, Operation Op,
1973 APSInt &Result) {
1974 if (LHS.isUnsigned()) {
1975 Result = Op(LHS, RHS);
1976 return true;
1977 }
1978
1979 APSInt Value(Op(LHS.extend(BitWidth), RHS.extend(BitWidth)), false);
1980 Result = Value.trunc(LHS.getBitWidth());
1981 if (Result.extend(BitWidth) != Value) {
1982 if (Info.checkingForOverflow())
1983 Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
1984 diag::warn_integer_constant_overflow)
1985 << Result.toString(10) << E->getType();
1986 else
1987 return HandleOverflow(Info, E, Value, E->getType());
1988 }
1989 return true;
1990}
1991
1992/// Perform the given binary integer operation.
1993static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS,
1994 BinaryOperatorKind Opcode, APSInt RHS,
1995 APSInt &Result) {
1996 switch (Opcode) {
1997 default:
1998 Info.FFDiag(E);
1999 return false;
2000 case BO_Mul:
2001 return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() * 2,
2002 std::multiplies<APSInt>(), Result);
2003 case BO_Add:
2004 return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2005 std::plus<APSInt>(), Result);
2006 case BO_Sub:
2007 return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2008 std::minus<APSInt>(), Result);
2009 case BO_And: Result = LHS & RHS; return true;
2010 case BO_Xor: Result = LHS ^ RHS; return true;
2011 case BO_Or: Result = LHS | RHS; return true;
2012 case BO_Div:
2013 case BO_Rem:
2014 if (RHS == 0) {
2015 Info.FFDiag(E, diag::note_expr_divide_by_zero);
2016 return false;
2017 }
2018 Result = (Opcode == BO_Rem ? LHS % RHS : LHS / RHS);
2019 // Check for overflow case: INT_MIN / -1 or INT_MIN % -1. APSInt supports
2020 // this operation and gives the two's complement result.
2021 if (RHS.isNegative() && RHS.isAllOnesValue() &&
2022 LHS.isSigned() && LHS.isMinSignedValue())
2023 return HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1),
2024 E->getType());
2025 return true;
2026 case BO_Shl: {
2027 if (Info.getLangOpts().OpenCL)
2028 // OpenCL 6.3j: shift values are effectively % word size of LHS.
2029 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2030 static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2031 RHS.isUnsigned());
2032 else if (RHS.isSigned() && RHS.isNegative()) {
2033 // During constant-folding, a negative shift is an opposite shift. Such
2034 // a shift is not a constant expression.
2035 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2036 RHS = -RHS;
2037 goto shift_right;
2038 }
2039 shift_left:
2040 // C++11 [expr.shift]p1: Shift width must be less than the bit width of
2041 // the shifted type.
2042 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2043 if (SA != RHS) {
2044 Info.CCEDiag(E, diag::note_constexpr_large_shift)
2045 << RHS << E->getType() << LHS.getBitWidth();
2046 } else if (LHS.isSigned()) {
2047 // C++11 [expr.shift]p2: A signed left shift must have a non-negative
2048 // operand, and must not overflow the corresponding unsigned type.
2049 if (LHS.isNegative())
2050 Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
2051 else if (LHS.countLeadingZeros() < SA)
2052 Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
2053 }
2054 Result = LHS << SA;
2055 return true;
2056 }
2057 case BO_Shr: {
2058 if (Info.getLangOpts().OpenCL)
2059 // OpenCL 6.3j: shift values are effectively % word size of LHS.
2060 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2061 static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2062 RHS.isUnsigned());
2063 else if (RHS.isSigned() && RHS.isNegative()) {
2064 // During constant-folding, a negative shift is an opposite shift. Such a
2065 // shift is not a constant expression.
2066 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2067 RHS = -RHS;
2068 goto shift_left;
2069 }
2070 shift_right:
2071 // C++11 [expr.shift]p1: Shift width must be less than the bit width of the
2072 // shifted type.
2073 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2074 if (SA != RHS)
2075 Info.CCEDiag(E, diag::note_constexpr_large_shift)
2076 << RHS << E->getType() << LHS.getBitWidth();
2077 Result = LHS >> SA;
2078 return true;
2079 }
2080
2081 case BO_LT: Result = LHS < RHS; return true;
2082 case BO_GT: Result = LHS > RHS; return true;
2083 case BO_LE: Result = LHS <= RHS; return true;
2084 case BO_GE: Result = LHS >= RHS; return true;
2085 case BO_EQ: Result = LHS == RHS; return true;
2086 case BO_NE: Result = LHS != RHS; return true;
2087 }
2088}
2089
2090/// Perform the given binary floating-point operation, in-place, on LHS.
2091static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E,
2092 APFloat &LHS, BinaryOperatorKind Opcode,
2093 const APFloat &RHS) {
2094 switch (Opcode) {
2095 default:
2096 Info.FFDiag(E);
2097 return false;
2098 case BO_Mul:
2099 LHS.multiply(RHS, APFloat::rmNearestTiesToEven);
2100 break;
2101 case BO_Add:
2102 LHS.add(RHS, APFloat::rmNearestTiesToEven);
2103 break;
2104 case BO_Sub:
2105 LHS.subtract(RHS, APFloat::rmNearestTiesToEven);
2106 break;
2107 case BO_Div:
2108 LHS.divide(RHS, APFloat::rmNearestTiesToEven);
2109 break;
2110 }
2111
2112 if (LHS.isInfinity() || LHS.isNaN()) {
2113 Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();
2114 return Info.noteUndefinedBehavior();
2115 }
2116 return true;
2117}
2118
2119/// Cast an lvalue referring to a base subobject to a derived class, by
2120/// truncating the lvalue's path to the given length.
2121static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
2122 const RecordDecl *TruncatedType,
2123 unsigned TruncatedElements) {
2124 SubobjectDesignator &D = Result.Designator;
2125
2126 // Check we actually point to a derived class object.
2127 if (TruncatedElements == D.Entries.size())
2128 return true;
2129 assert(TruncatedElements >= D.MostDerivedPathLength &&((TruncatedElements >= D.MostDerivedPathLength && "not casting to a derived class"
) ? static_cast<void> (0) : __assert_fail ("TruncatedElements >= D.MostDerivedPathLength && \"not casting to a derived class\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2130, __PRETTY_FUNCTION__))
2130 "not casting to a derived class")((TruncatedElements >= D.MostDerivedPathLength && "not casting to a derived class"
) ? static_cast<void> (0) : __assert_fail ("TruncatedElements >= D.MostDerivedPathLength && \"not casting to a derived class\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2130, __PRETTY_FUNCTION__))
;
2131 if (!Result.checkSubobject(Info, E, CSK_Derived))
2132 return false;
2133
2134 // Truncate the path to the subobject, and remove any derived-to-base offsets.
2135 const RecordDecl *RD = TruncatedType;
2136 for (unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) {
2137 if (RD->isInvalidDecl()) return false;
2138 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
2139 const CXXRecordDecl *Base = getAsBaseClass(D.Entries[I]);
2140 if (isVirtualBaseClass(D.Entries[I]))
2141 Result.Offset -= Layout.getVBaseClassOffset(Base);
2142 else
2143 Result.Offset -= Layout.getBaseClassOffset(Base);
2144 RD = Base;
2145 }
2146 D.Entries.resize(TruncatedElements);
2147 return true;
2148}
2149
2150static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2151 const CXXRecordDecl *Derived,
2152 const CXXRecordDecl *Base,
2153 const ASTRecordLayout *RL = nullptr) {
2154 if (!RL) {
2155 if (Derived->isInvalidDecl()) return false;
2156 RL = &Info.Ctx.getASTRecordLayout(Derived);
2157 }
2158
2159 Obj.getLValueOffset() += RL->getBaseClassOffset(Base);
2160 Obj.addDecl(Info, E, Base, /*Virtual*/ false);
2161 return true;
2162}
2163
2164static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
2165 const CXXRecordDecl *DerivedDecl,
2166 const CXXBaseSpecifier *Base) {
2167 const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl();
2168
2169 if (!Base->isVirtual())
2170 return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl);
2171
2172 SubobjectDesignator &D = Obj.Designator;
2173 if (D.Invalid)
2174 return false;
2175
2176 // Extract most-derived object and corresponding type.
2177 DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl();
2178 if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength))
2179 return false;
2180
2181 // Find the virtual base class.
2182 if (DerivedDecl->isInvalidDecl()) return false;
2183 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
2184 Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl);
2185 Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
2186 return true;
2187}
2188
2189static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E,
2190 QualType Type, LValue &Result) {
2191 for (CastExpr::path_const_iterator PathI = E->path_begin(),
2192 PathE = E->path_end();
2193 PathI != PathE; ++PathI) {
2194 if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(),
2195 *PathI))
2196 return false;
2197 Type = (*PathI)->getType();
2198 }
2199 return true;
2200}
2201
2202/// Update LVal to refer to the given field, which must be a member of the type
2203/// currently described by LVal.
2204static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal,
2205 const FieldDecl *FD,
2206 const ASTRecordLayout *RL = nullptr) {
2207 if (!RL) {
2208 if (FD->getParent()->isInvalidDecl()) return false;
2209 RL = &Info.Ctx.getASTRecordLayout(FD->getParent());
2210 }
2211
2212 unsigned I = FD->getFieldIndex();
2213 LVal.adjustOffset(Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I)));
2214 LVal.addDecl(Info, E, FD);
2215 return true;
2216}
2217
2218/// Update LVal to refer to the given indirect field.
2219static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E,
2220 LValue &LVal,
2221 const IndirectFieldDecl *IFD) {
2222 for (const auto *C : IFD->chain())
2223 if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(C)))
2224 return false;
2225 return true;
2226}
2227
2228/// Get the size of the given type in char units.
2229static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc,
2230 QualType Type, CharUnits &Size) {
2231 // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc
2232 // extension.
2233 if (Type->isVoidType() || Type->isFunctionType()) {
2234 Size = CharUnits::One();
2235 return true;
2236 }
2237
2238 if (Type->isDependentType()) {
2239 Info.FFDiag(Loc);
2240 return false;
2241 }
2242
2243 if (!Type->isConstantSizeType()) {
2244 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
2245 // FIXME: Better diagnostic.
2246 Info.FFDiag(Loc);
2247 return false;
2248 }
2249
2250 Size = Info.Ctx.getTypeSizeInChars(Type);
2251 return true;
2252}
2253
2254/// Update a pointer value to model pointer arithmetic.
2255/// \param Info - Information about the ongoing evaluation.
2256/// \param E - The expression being evaluated, for diagnostic purposes.
2257/// \param LVal - The pointer value to be updated.
2258/// \param EltTy - The pointee type represented by LVal.
2259/// \param Adjustment - The adjustment, in objects of type EltTy, to add.
2260static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2261 LValue &LVal, QualType EltTy,
2262 APSInt Adjustment) {
2263 CharUnits SizeOfPointee;
2264 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfPointee))
2265 return false;
2266
2267 LVal.adjustOffsetAndIndex(Info, E, Adjustment, SizeOfPointee);
2268 return true;
2269}
2270
2271static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
2272 LValue &LVal, QualType EltTy,
2273 int64_t Adjustment) {
2274 return HandleLValueArrayAdjustment(Info, E, LVal, EltTy,
2275 APSInt::get(Adjustment));
2276}
2277
2278/// Update an lvalue to refer to a component of a complex number.
2279/// \param Info - Information about the ongoing evaluation.
2280/// \param LVal - The lvalue to be updated.
2281/// \param EltTy - The complex number's component type.
2282/// \param Imag - False for the real component, true for the imaginary.
2283static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E,
2284 LValue &LVal, QualType EltTy,
2285 bool Imag) {
2286 if (Imag) {
2287 CharUnits SizeOfComponent;
2288 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent))
2289 return false;
2290 LVal.Offset += SizeOfComponent;
2291 }
2292 LVal.addComplex(Info, E, EltTy, Imag);
2293 return true;
2294}
2295
2296static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
2297 QualType Type, const LValue &LVal,
2298 APValue &RVal);
2299
2300/// Try to evaluate the initializer for a variable declaration.
2301///
2302/// \param Info Information about the ongoing evaluation.
2303/// \param E An expression to be used when printing diagnostics.
2304/// \param VD The variable whose initializer should be obtained.
2305/// \param Frame The frame in which the variable was created. Must be null
2306/// if this variable is not local to the evaluation.
2307/// \param Result Filled in with a pointer to the value of the variable.
2308static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
2309 const VarDecl *VD, CallStackFrame *Frame,
2310 APValue *&Result) {
2311
2312 // If this is a parameter to an active constexpr function call, perform
2313 // argument substitution.
2314 if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) {
2315 // Assume arguments of a potential constant expression are unknown
2316 // constant expressions.
2317 if (Info.checkingPotentialConstantExpression())
2318 return false;
2319 if (!Frame || !Frame->Arguments) {
2320 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2321 return false;
2322 }
2323 Result = &Frame->Arguments[PVD->getFunctionScopeIndex()];
2324 return true;
2325 }
2326
2327 // If this is a local variable, dig out its value.
2328 if (Frame) {
2329 Result = Frame->getTemporary(VD);
2330 if (!Result) {
2331 // Assume variables referenced within a lambda's call operator that were
2332 // not declared within the call operator are captures and during checking
2333 // of a potential constant expression, assume they are unknown constant
2334 // expressions.
2335 assert(isLambdaCallOperator(Frame->Callee) &&((isLambdaCallOperator(Frame->Callee) && (VD->getDeclContext
() != Frame->Callee || VD->isInitCapture()) && "missing value for local variable"
) ? static_cast<void> (0) : __assert_fail ("isLambdaCallOperator(Frame->Callee) && (VD->getDeclContext() != Frame->Callee || VD->isInitCapture()) && \"missing value for local variable\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2337, __PRETTY_FUNCTION__))
2336 (VD->getDeclContext() != Frame->Callee || VD->isInitCapture()) &&((isLambdaCallOperator(Frame->Callee) && (VD->getDeclContext
() != Frame->Callee || VD->isInitCapture()) && "missing value for local variable"
) ? static_cast<void> (0) : __assert_fail ("isLambdaCallOperator(Frame->Callee) && (VD->getDeclContext() != Frame->Callee || VD->isInitCapture()) && \"missing value for local variable\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2337, __PRETTY_FUNCTION__))
2337 "missing value for local variable")((isLambdaCallOperator(Frame->Callee) && (VD->getDeclContext
() != Frame->Callee || VD->isInitCapture()) && "missing value for local variable"
) ? static_cast<void> (0) : __assert_fail ("isLambdaCallOperator(Frame->Callee) && (VD->getDeclContext() != Frame->Callee || VD->isInitCapture()) && \"missing value for local variable\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2337, __PRETTY_FUNCTION__))
;
2338 if (Info.checkingPotentialConstantExpression())
2339 return false;
2340 // FIXME: implement capture evaluation during constant expr evaluation.
2341 Info.FFDiag(E->getLocStart(),
2342 diag::note_unimplemented_constexpr_lambda_feature_ast)
2343 << "captures not currently allowed";
2344 return false;
2345 }
2346 return true;
2347 }
2348
2349 // Dig out the initializer, and use the declaration which it's attached to.
2350 const Expr *Init = VD->getAnyInitializer(VD);
2351 if (!Init || Init->isValueDependent()) {
2352 // If we're checking a potential constant expression, the variable could be
2353 // initialized later.
2354 if (!Info.checkingPotentialConstantExpression())
2355 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2356 return false;
2357 }
2358
2359 // If we're currently evaluating the initializer of this declaration, use that
2360 // in-flight value.
2361 if (Info.EvaluatingDecl.dyn_cast<const ValueDecl*>() == VD) {
2362 Result = Info.EvaluatingDeclValue;
2363 return true;
2364 }
2365
2366 // Never evaluate the initializer of a weak variable. We can't be sure that
2367 // this is the definition which will be used.
2368 if (VD->isWeak()) {
2369 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2370 return false;
2371 }
2372
2373 // Check that we can fold the initializer. In C++, we will have already done
2374 // this in the cases where it matters for conformance.
2375 SmallVector<PartialDiagnosticAt, 8> Notes;
2376 if (!VD->evaluateValue(Notes)) {
2377 Info.FFDiag(E, diag::note_constexpr_var_init_non_constant,
2378 Notes.size() + 1) << VD;
2379 Info.Note(VD->getLocation(), diag::note_declared_at);
2380 Info.addNotes(Notes);
2381 return false;
2382 } else if (!VD->checkInitIsICE()) {
2383 Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant,
2384 Notes.size() + 1) << VD;
2385 Info.Note(VD->getLocation(), diag::note_declared_at);
2386 Info.addNotes(Notes);
2387 }
2388
2389 Result = VD->getEvaluatedValue();
2390 return true;
2391}
2392
2393static bool IsConstNonVolatile(QualType T) {
2394 Qualifiers Quals = T.getQualifiers();
2395 return Quals.hasConst() && !Quals.hasVolatile();
2396}
2397
2398/// Get the base index of the given base class within an APValue representing
2399/// the given derived class.
2400static unsigned getBaseIndex(const CXXRecordDecl *Derived,
2401 const CXXRecordDecl *Base) {
2402 Base = Base->getCanonicalDecl();
2403 unsigned Index = 0;
2404 for (CXXRecordDecl::base_class_const_iterator I = Derived->bases_begin(),
2405 E = Derived->bases_end(); I != E; ++I, ++Index) {
2406 if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == Base)
2407 return Index;
2408 }
2409
2410 llvm_unreachable("base class missing from derived class's bases list")::llvm::llvm_unreachable_internal("base class missing from derived class's bases list"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2410)
;
2411}
2412
2413/// Extract the value of a character from a string literal.
2414static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
2415 uint64_t Index) {
2416 // FIXME: Support MakeStringConstant
2417 if (const auto *ObjCEnc = dyn_cast<ObjCEncodeExpr>(Lit)) {
2418 std::string Str;
2419 Info.Ctx.getObjCEncodingForType(ObjCEnc->getEncodedType(), Str);
2420 assert(Index <= Str.size() && "Index too large")((Index <= Str.size() && "Index too large") ? static_cast
<void> (0) : __assert_fail ("Index <= Str.size() && \"Index too large\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2420, __PRETTY_FUNCTION__))
;
2421 return APSInt::getUnsigned(Str.c_str()[Index]);
2422 }
2423
2424 if (auto PE = dyn_cast<PredefinedExpr>(Lit))
2425 Lit = PE->getFunctionName();
2426 const StringLiteral *S = cast<StringLiteral>(Lit);
2427 const ConstantArrayType *CAT =
2428 Info.Ctx.getAsConstantArrayType(S->getType());
2429 assert(CAT && "string literal isn't an array")((CAT && "string literal isn't an array") ? static_cast
<void> (0) : __assert_fail ("CAT && \"string literal isn't an array\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2429, __PRETTY_FUNCTION__))
;
2430 QualType CharType = CAT->getElementType();
2431 assert(CharType->isIntegerType() && "unexpected character type")((CharType->isIntegerType() && "unexpected character type"
) ? static_cast<void> (0) : __assert_fail ("CharType->isIntegerType() && \"unexpected character type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2431, __PRETTY_FUNCTION__))
;
2432
2433 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2434 CharType->isUnsignedIntegerType());
2435 if (Index < S->getLength())
2436 Value = S->getCodeUnit(Index);
2437 return Value;
2438}
2439
2440// Expand a string literal into an array of characters.
2441static void expandStringLiteral(EvalInfo &Info, const Expr *Lit,
2442 APValue &Result) {
2443 const StringLiteral *S = cast<StringLiteral>(Lit);
2444 const ConstantArrayType *CAT =
2445 Info.Ctx.getAsConstantArrayType(S->getType());
2446 assert(CAT && "string literal isn't an array")((CAT && "string literal isn't an array") ? static_cast
<void> (0) : __assert_fail ("CAT && \"string literal isn't an array\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2446, __PRETTY_FUNCTION__))
;
2447 QualType CharType = CAT->getElementType();
2448 assert(CharType->isIntegerType() && "unexpected character type")((CharType->isIntegerType() && "unexpected character type"
) ? static_cast<void> (0) : __assert_fail ("CharType->isIntegerType() && \"unexpected character type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2448, __PRETTY_FUNCTION__))
;
2449
2450 unsigned Elts = CAT->getSize().getZExtValue();
2451 Result = APValue(APValue::UninitArray(),
2452 std::min(S->getLength(), Elts), Elts);
2453 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2454 CharType->isUnsignedIntegerType());
2455 if (Result.hasArrayFiller())
2456 Result.getArrayFiller() = APValue(Value);
2457 for (unsigned I = 0, N = Result.getArrayInitializedElts(); I != N; ++I) {
2458 Value = S->getCodeUnit(I);
2459 Result.getArrayInitializedElt(I) = APValue(Value);
2460 }
2461}
2462
2463// Expand an array so that it has more than Index filled elements.
2464static void expandArray(APValue &Array, unsigned Index) {
2465 unsigned Size = Array.getArraySize();
2466 assert(Index < Size)((Index < Size) ? static_cast<void> (0) : __assert_fail
("Index < Size", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2466, __PRETTY_FUNCTION__))
;
2467
2468 // Always at least double the number of elements for which we store a value.
2469 unsigned OldElts = Array.getArrayInitializedElts();
2470 unsigned NewElts = std::max(Index+1, OldElts * 2);
2471 NewElts = std::min(Size, std::max(NewElts, 8u));
2472
2473 // Copy the data across.
2474 APValue NewValue(APValue::UninitArray(), NewElts, Size);
2475 for (unsigned I = 0; I != OldElts; ++I)
2476 NewValue.getArrayInitializedElt(I).swap(Array.getArrayInitializedElt(I));
2477 for (unsigned I = OldElts; I != NewElts; ++I)
2478 NewValue.getArrayInitializedElt(I) = Array.getArrayFiller();
2479 if (NewValue.hasArrayFiller())
2480 NewValue.getArrayFiller() = Array.getArrayFiller();
2481 Array.swap(NewValue);
2482}
2483
2484/// Determine whether a type would actually be read by an lvalue-to-rvalue
2485/// conversion. If it's of class type, we may assume that the copy operation
2486/// is trivial. Note that this is never true for a union type with fields
2487/// (because the copy always "reads" the active member) and always true for
2488/// a non-class type.
2489static bool isReadByLvalueToRvalueConversion(QualType T) {
2490 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
2491 if (!RD || (RD->isUnion() && !RD->field_empty()))
2492 return true;
2493 if (RD->isEmpty())
2494 return false;
2495
2496 for (auto *Field : RD->fields())
2497 if (isReadByLvalueToRvalueConversion(Field->getType()))
2498 return true;
2499
2500 for (auto &BaseSpec : RD->bases())
2501 if (isReadByLvalueToRvalueConversion(BaseSpec.getType()))
2502 return true;
2503
2504 return false;
2505}
2506
2507/// Diagnose an attempt to read from any unreadable field within the specified
2508/// type, which might be a class type.
2509static bool diagnoseUnreadableFields(EvalInfo &Info, const Expr *E,
2510 QualType T) {
2511 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
2512 if (!RD)
2513 return false;
2514
2515 if (!RD->hasMutableFields())
2516 return false;
2517
2518 for (auto *Field : RD->fields()) {
2519 // If we're actually going to read this field in some way, then it can't
2520 // be mutable. If we're in a union, then assigning to a mutable field
2521 // (even an empty one) can change the active member, so that's not OK.
2522 // FIXME: Add core issue number for the union case.
2523 if (Field->isMutable() &&
2524 (RD->isUnion() || isReadByLvalueToRvalueConversion(Field->getType()))) {
2525 Info.FFDiag(E, diag::note_constexpr_ltor_mutable, 1) << Field;
2526 Info.Note(Field->getLocation(), diag::note_declared_at);
2527 return true;
2528 }
2529
2530 if (diagnoseUnreadableFields(Info, E, Field->getType()))
2531 return true;
2532 }
2533
2534 for (auto &BaseSpec : RD->bases())
2535 if (diagnoseUnreadableFields(Info, E, BaseSpec.getType()))
2536 return true;
2537
2538 // All mutable fields were empty, and thus not actually read.
2539 return false;
2540}
2541
2542/// Kinds of access we can perform on an object, for diagnostics.
2543enum AccessKinds {
2544 AK_Read,
2545 AK_Assign,
2546 AK_Increment,
2547 AK_Decrement
2548};
2549
2550namespace {
2551/// A handle to a complete object (an object that is not a subobject of
2552/// another object).
2553struct CompleteObject {
2554 /// The value of the complete object.
2555 APValue *Value;
2556 /// The type of the complete object.
2557 QualType Type;
2558
2559 CompleteObject() : Value(nullptr) {}
2560 CompleteObject(APValue *Value, QualType Type)
2561 : Value(Value), Type(Type) {
2562 assert(Value && "missing value for complete object")((Value && "missing value for complete object") ? static_cast
<void> (0) : __assert_fail ("Value && \"missing value for complete object\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2562, __PRETTY_FUNCTION__))
;
2563 }
2564
2565 explicit operator bool() const { return Value; }
2566};
2567} // end anonymous namespace
2568
2569/// Find the designated sub-object of an rvalue.
2570template<typename SubobjectHandler>
2571typename SubobjectHandler::result_type
2572findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj,
2573 const SubobjectDesignator &Sub, SubobjectHandler &handler) {
2574 if (Sub.Invalid)
2575 // A diagnostic will have already been produced.
2576 return handler.failed();
2577 if (Sub.isOnePastTheEnd()) {
2578 if (Info.getLangOpts().CPlusPlus11)
2579 Info.FFDiag(E, diag::note_constexpr_access_past_end)
2580 << handler.AccessKind;
2581 else
2582 Info.FFDiag(E);
2583 return handler.failed();
2584 }
2585
2586 APValue *O = Obj.Value;
2587 QualType ObjType = Obj.Type;
2588 const FieldDecl *LastField = nullptr;
2589
2590 // Walk the designator's path to find the subobject.
2591 for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {
2592 if (O->isUninit()) {
2593 if (!Info.checkingPotentialConstantExpression())
2594 Info.FFDiag(E, diag::note_constexpr_access_uninit) << handler.AccessKind;
2595 return handler.failed();
2596 }
2597
2598 if (I == N) {
2599 // If we are reading an object of class type, there may still be more
2600 // things we need to check: if there are any mutable subobjects, we
2601 // cannot perform this read. (This only happens when performing a trivial
2602 // copy or assignment.)
2603 if (ObjType->isRecordType() && handler.AccessKind == AK_Read &&
2604 diagnoseUnreadableFields(Info, E, ObjType))
2605 return handler.failed();
2606
2607 if (!handler.found(*O, ObjType))
2608 return false;
2609
2610 // If we modified a bit-field, truncate it to the right width.
2611 if (handler.AccessKind != AK_Read &&
2612 LastField && LastField->isBitField() &&
2613 !truncateBitfieldValue(Info, E, *O, LastField))
2614 return false;
2615
2616 return true;
2617 }
2618
2619 LastField = nullptr;
2620 if (ObjType->isArrayType()) {
2621 // Next subobject is an array element.
2622 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType);
2623 assert(CAT && "vla in literal type?")((CAT && "vla in literal type?") ? static_cast<void
> (0) : __assert_fail ("CAT && \"vla in literal type?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2623, __PRETTY_FUNCTION__))
;
2624 uint64_t Index = Sub.Entries[I].ArrayIndex;
2625 if (CAT->getSize().ule(Index)) {
2626 // Note, it should not be possible to form a pointer with a valid
2627 // designator which points more than one past the end of the array.
2628 if (Info.getLangOpts().CPlusPlus11)
2629 Info.FFDiag(E, diag::note_constexpr_access_past_end)
2630 << handler.AccessKind;
2631 else
2632 Info.FFDiag(E);
2633 return handler.failed();
2634 }
2635
2636 ObjType = CAT->getElementType();
2637
2638 // An array object is represented as either an Array APValue or as an
2639 // LValue which refers to a string literal.
2640 if (O->isLValue()) {
2641 assert(I == N - 1 && "extracting subobject of character?")((I == N - 1 && "extracting subobject of character?")
? static_cast<void> (0) : __assert_fail ("I == N - 1 && \"extracting subobject of character?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2641, __PRETTY_FUNCTION__))
;
2642 assert(!O->hasLValuePath() || O->getLValuePath().empty())((!O->hasLValuePath() || O->getLValuePath().empty()) ? static_cast
<void> (0) : __assert_fail ("!O->hasLValuePath() || O->getLValuePath().empty()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2642, __PRETTY_FUNCTION__))
;
2643 if (handler.AccessKind != AK_Read)
2644 expandStringLiteral(Info, O->getLValueBase().get<const Expr *>(),
2645 *O);
2646 else
2647 return handler.foundString(*O, ObjType, Index);
2648 }
2649
2650 if (O->getArrayInitializedElts() > Index)
2651 O = &O->getArrayInitializedElt(Index);
2652 else if (handler.AccessKind != AK_Read) {
2653 expandArray(*O, Index);
2654 O = &O->getArrayInitializedElt(Index);
2655 } else
2656 O = &O->getArrayFiller();
2657 } else if (ObjType->isAnyComplexType()) {
2658 // Next subobject is a complex number.
2659 uint64_t Index = Sub.Entries[I].ArrayIndex;
2660 if (Index > 1) {
2661 if (Info.getLangOpts().CPlusPlus11)
2662 Info.FFDiag(E, diag::note_constexpr_access_past_end)
2663 << handler.AccessKind;
2664 else
2665 Info.FFDiag(E);
2666 return handler.failed();
2667 }
2668
2669 bool WasConstQualified = ObjType.isConstQualified();
2670 ObjType = ObjType->castAs<ComplexType>()->getElementType();
2671 if (WasConstQualified)
2672 ObjType.addConst();
2673
2674 assert(I == N - 1 && "extracting subobject of scalar?")((I == N - 1 && "extracting subobject of scalar?") ? static_cast
<void> (0) : __assert_fail ("I == N - 1 && \"extracting subobject of scalar?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2674, __PRETTY_FUNCTION__))
;
2675 if (O->isComplexInt()) {
2676 return handler.found(Index ? O->getComplexIntImag()
2677 : O->getComplexIntReal(), ObjType);
2678 } else {
2679 assert(O->isComplexFloat())((O->isComplexFloat()) ? static_cast<void> (0) : __assert_fail
("O->isComplexFloat()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2679, __PRETTY_FUNCTION__))
;
2680 return handler.found(Index ? O->getComplexFloatImag()
2681 : O->getComplexFloatReal(), ObjType);
2682 }
2683 } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
2684 if (Field->isMutable() && handler.AccessKind == AK_Read) {
2685 Info.FFDiag(E, diag::note_constexpr_ltor_mutable, 1)
2686 << Field;
2687 Info.Note(Field->getLocation(), diag::note_declared_at);
2688 return handler.failed();
2689 }
2690
2691 // Next subobject is a class, struct or union field.
2692 RecordDecl *RD = ObjType->castAs<RecordType>()->getDecl();
2693 if (RD->isUnion()) {
2694 const FieldDecl *UnionField = O->getUnionField();
2695 if (!UnionField ||
2696 UnionField->getCanonicalDecl() != Field->getCanonicalDecl()) {
2697 Info.FFDiag(E, diag::note_constexpr_access_inactive_union_member)
2698 << handler.AccessKind << Field << !UnionField << UnionField;
2699 return handler.failed();
2700 }
2701 O = &O->getUnionValue();
2702 } else
2703 O = &O->getStructField(Field->getFieldIndex());
2704
2705 bool WasConstQualified = ObjType.isConstQualified();
2706 ObjType = Field->getType();
2707 if (WasConstQualified && !Field->isMutable())
2708 ObjType.addConst();
2709
2710 if (ObjType.isVolatileQualified()) {
2711 if (Info.getLangOpts().CPlusPlus) {
2712 // FIXME: Include a description of the path to the volatile subobject.
2713 Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
2714 << handler.AccessKind << 2 << Field;
2715 Info.Note(Field->getLocation(), diag::note_declared_at);
2716 } else {
2717 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2718 }
2719 return handler.failed();
2720 }
2721
2722 LastField = Field;
2723 } else {
2724 // Next subobject is a base class.
2725 const CXXRecordDecl *Derived = ObjType->getAsCXXRecordDecl();
2726 const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]);
2727 O = &O->getStructBase(getBaseIndex(Derived, Base));
2728
2729 bool WasConstQualified = ObjType.isConstQualified();
2730 ObjType = Info.Ctx.getRecordType(Base);
2731 if (WasConstQualified)
2732 ObjType.addConst();
2733 }
2734 }
2735}
2736
2737namespace {
2738struct ExtractSubobjectHandler {
2739 EvalInfo &Info;
2740 APValue &Result;
2741
2742 static const AccessKinds AccessKind = AK_Read;
2743
2744 typedef bool result_type;
2745 bool failed() { return false; }
2746 bool found(APValue &Subobj, QualType SubobjType) {
2747 Result = Subobj;
2748 return true;
2749 }
2750 bool found(APSInt &Value, QualType SubobjType) {
2751 Result = APValue(Value);
2752 return true;
2753 }
2754 bool found(APFloat &Value, QualType SubobjType) {
2755 Result = APValue(Value);
2756 return true;
2757 }
2758 bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
2759 Result = APValue(extractStringLiteralCharacter(
2760 Info, Subobj.getLValueBase().get<const Expr *>(), Character));
2761 return true;
2762 }
2763};
2764} // end anonymous namespace
2765
2766const AccessKinds ExtractSubobjectHandler::AccessKind;
2767
2768/// Extract the designated sub-object of an rvalue.
2769static bool extractSubobject(EvalInfo &Info, const Expr *E,
2770 const CompleteObject &Obj,
2771 const SubobjectDesignator &Sub,
2772 APValue &Result) {
2773 ExtractSubobjectHandler Handler = { Info, Result };
2774 return findSubobject(Info, E, Obj, Sub, Handler);
2775}
2776
2777namespace {
2778struct ModifySubobjectHandler {
2779 EvalInfo &Info;
2780 APValue &NewVal;
2781 const Expr *E;
2782
2783 typedef bool result_type;
2784 static const AccessKinds AccessKind = AK_Assign;
2785
2786 bool checkConst(QualType QT) {
2787 // Assigning to a const object has undefined behavior.
2788 if (QT.isConstQualified()) {
2789 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
2790 return false;
2791 }
2792 return true;
2793 }
2794
2795 bool failed() { return false; }
2796 bool found(APValue &Subobj, QualType SubobjType) {
2797 if (!checkConst(SubobjType))
2798 return false;
2799 // We've been given ownership of NewVal, so just swap it in.
2800 Subobj.swap(NewVal);
2801 return true;
2802 }
2803 bool found(APSInt &Value, QualType SubobjType) {
2804 if (!checkConst(SubobjType))
2805 return false;
2806 if (!NewVal.isInt()) {
2807 // Maybe trying to write a cast pointer value into a complex?
2808 Info.FFDiag(E);
2809 return false;
2810 }
2811 Value = NewVal.getInt();
2812 return true;
2813 }
2814 bool found(APFloat &Value, QualType SubobjType) {
2815 if (!checkConst(SubobjType))
2816 return false;
2817 Value = NewVal.getFloat();
2818 return true;
2819 }
2820 bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
2821 llvm_unreachable("shouldn't encounter string elements with ExpandArrays")::llvm::llvm_unreachable_internal("shouldn't encounter string elements with ExpandArrays"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 2821)
;
2822 }
2823};
2824} // end anonymous namespace
2825
2826const AccessKinds ModifySubobjectHandler::AccessKind;
2827
2828/// Update the designated sub-object of an rvalue to the given value.
2829static bool modifySubobject(EvalInfo &Info, const Expr *E,
2830 const CompleteObject &Obj,
2831 const SubobjectDesignator &Sub,
2832 APValue &NewVal) {
2833 ModifySubobjectHandler Handler = { Info, NewVal, E };
2834 return findSubobject(Info, E, Obj, Sub, Handler);
2835}
2836
2837/// Find the position where two subobject designators diverge, or equivalently
2838/// the length of the common initial subsequence.
2839static unsigned FindDesignatorMismatch(QualType ObjType,
2840 const SubobjectDesignator &A,
2841 const SubobjectDesignator &B,
2842 bool &WasArrayIndex) {
2843 unsigned I = 0, N = std::min(A.Entries.size(), B.Entries.size());
2844 for (/**/; I != N; ++I) {
2845 if (!ObjType.isNull() &&
2846 (ObjType->isArrayType() || ObjType->isAnyComplexType())) {
2847 // Next subobject is an array element.
2848 if (A.Entries[I].ArrayIndex != B.Entries[I].ArrayIndex) {
2849 WasArrayIndex = true;
2850 return I;
2851 }
2852 if (ObjType->isAnyComplexType())
2853 ObjType = ObjType->castAs<ComplexType>()->getElementType();
2854 else
2855 ObjType = ObjType->castAsArrayTypeUnsafe()->getElementType();
2856 } else {
2857 if (A.Entries[I].BaseOrMember != B.Entries[I].BaseOrMember) {
2858 WasArrayIndex = false;
2859 return I;
2860 }
2861 if (const FieldDecl *FD = getAsField(A.Entries[I]))
2862 // Next subobject is a field.
2863 ObjType = FD->getType();
2864 else
2865 // Next subobject is a base class.
2866 ObjType = QualType();
2867 }
2868 }
2869 WasArrayIndex = false;
2870 return I;
2871}
2872
2873/// Determine whether the given subobject designators refer to elements of the
2874/// same array object.
2875static bool AreElementsOfSameArray(QualType ObjType,
2876 const SubobjectDesignator &A,
2877 const SubobjectDesignator &B) {
2878 if (A.Entries.size() != B.Entries.size())
2879 return false;
2880
2881 bool IsArray = A.MostDerivedIsArrayElement;
2882 if (IsArray && A.MostDerivedPathLength != A.Entries.size())
2883 // A is a subobject of the array element.
2884 return false;
2885
2886 // If A (and B) designates an array element, the last entry will be the array
2887 // index. That doesn't have to match. Otherwise, we're in the 'implicit array
2888 // of length 1' case, and the entire path must match.
2889 bool WasArrayIndex;
2890 unsigned CommonLength = FindDesignatorMismatch(ObjType, A, B, WasArrayIndex);
2891 return CommonLength >= A.Entries.size() - IsArray;
2892}
2893
2894/// Find the complete object to which an LValue refers.
2895static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
2896 AccessKinds AK, const LValue &LVal,
2897 QualType LValType) {
2898 if (!LVal.Base) {
2899 Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
2900 return CompleteObject();
2901 }
2902
2903 CallStackFrame *Frame = nullptr;
2904 if (LVal.CallIndex) {
2905 Frame = Info.getCallFrame(LVal.CallIndex);
2906 if (!Frame) {
2907 Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1)
2908 << AK << LVal.Base.is<const ValueDecl*>();
2909 NoteLValueLocation(Info, LVal.Base);
2910 return CompleteObject();
2911 }
2912 }
2913
2914 // C++11 DR1311: An lvalue-to-rvalue conversion on a volatile-qualified type
2915 // is not a constant expression (even if the object is non-volatile). We also
2916 // apply this rule to C++98, in order to conform to the expected 'volatile'
2917 // semantics.
2918 if (LValType.isVolatileQualified()) {
2919 if (Info.getLangOpts().CPlusPlus)
2920 Info.FFDiag(E, diag::note_constexpr_access_volatile_type)
2921 << AK << LValType;
2922 else
2923 Info.FFDiag(E);
2924 return CompleteObject();
2925 }
2926
2927 // Compute value storage location and type of base object.
2928 APValue *BaseVal = nullptr;
2929 QualType BaseType = getType(LVal.Base);
2930
2931 if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl*>()) {
2932 // In C++98, const, non-volatile integers initialized with ICEs are ICEs.
2933 // In C++11, constexpr, non-volatile variables initialized with constant
2934 // expressions are constant expressions too. Inside constexpr functions,
2935 // parameters are constant expressions even if they're non-const.
2936 // In C++1y, objects local to a constant expression (those with a Frame) are
2937 // both readable and writable inside constant expressions.
2938 // In C, such things can also be folded, although they are not ICEs.
2939 const VarDecl *VD = dyn_cast<VarDecl>(D);
2940 if (VD) {
2941 if (const VarDecl *VDef = VD->getDefinition(Info.Ctx))
2942 VD = VDef;
2943 }
2944 if (!VD || VD->isInvalidDecl()) {
2945 Info.FFDiag(E);
2946 return CompleteObject();
2947 }
2948
2949 // Accesses of volatile-qualified objects are not allowed.
2950 if (BaseType.isVolatileQualified()) {
2951 if (Info.getLangOpts().CPlusPlus) {
2952 Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
2953 << AK << 1 << VD;
2954 Info.Note(VD->getLocation(), diag::note_declared_at);
2955 } else {
2956 Info.FFDiag(E);
2957 }
2958 return CompleteObject();
2959 }
2960
2961 // Unless we're looking at a local variable or argument in a constexpr call,
2962 // the variable we're reading must be const.
2963 if (!Frame) {
2964 if (Info.getLangOpts().CPlusPlus14 &&
2965 VD == Info.EvaluatingDecl.dyn_cast<const ValueDecl *>()) {
2966 // OK, we can read and modify an object if we're in the process of
2967 // evaluating its initializer, because its lifetime began in this
2968 // evaluation.
2969 } else if (AK != AK_Read) {
2970 // All the remaining cases only permit reading.
2971 Info.FFDiag(E, diag::note_constexpr_modify_global);
2972 return CompleteObject();
2973 } else if (VD->isConstexpr()) {
2974 // OK, we can read this variable.
2975 } else if (BaseType->isIntegralOrEnumerationType()) {
2976 // In OpenCL if a variable is in constant address space it is a const value.
2977 if (!(BaseType.isConstQualified() ||
2978 (Info.getLangOpts().OpenCL &&
2979 BaseType.getAddressSpace() == LangAS::opencl_constant))) {
2980 if (Info.getLangOpts().CPlusPlus) {
2981 Info.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;
2982 Info.Note(VD->getLocation(), diag::note_declared_at);
2983 } else {
2984 Info.FFDiag(E);
2985 }
2986 return CompleteObject();
2987 }
2988 } else if (BaseType->isFloatingType() && BaseType.isConstQualified()) {
2989 // We support folding of const floating-point types, in order to make
2990 // static const data members of such types (supported as an extension)
2991 // more useful.
2992 if (Info.getLangOpts().CPlusPlus11) {
2993 Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
2994 Info.Note(VD->getLocation(), diag::note_declared_at);
2995 } else {
2996 Info.CCEDiag(E);
2997 }
2998 } else if (BaseType.isConstQualified() && VD->hasDefinition(Info.Ctx)) {
2999 Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr) << VD;
3000 // Keep evaluating to see what we can do.
3001 } else {
3002 // FIXME: Allow folding of values of any literal type in all languages.
3003 if (Info.checkingPotentialConstantExpression() &&
3004 VD->getType().isConstQualified() && !VD->hasDefinition(Info.Ctx)) {
3005 // The definition of this variable could be constexpr. We can't
3006 // access it right now, but may be able to in future.
3007 } else if (Info.getLangOpts().CPlusPlus11) {
3008 Info.FFDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
3009 Info.Note(VD->getLocation(), diag::note_declared_at);
3010 } else {
3011 Info.FFDiag(E);
3012 }
3013 return CompleteObject();
3014 }
3015 }
3016
3017 if (!evaluateVarDeclInit(Info, E, VD, Frame, BaseVal))
3018 return CompleteObject();
3019 } else {
3020 const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3021
3022 if (!Frame) {
3023 if (const MaterializeTemporaryExpr *MTE =
3024 dyn_cast<MaterializeTemporaryExpr>(Base)) {
3025 assert(MTE->getStorageDuration() == SD_Static &&((MTE->getStorageDuration() == SD_Static && "should have a frame for a non-global materialized temporary"
) ? static_cast<void> (0) : __assert_fail ("MTE->getStorageDuration() == SD_Static && \"should have a frame for a non-global materialized temporary\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3026, __PRETTY_FUNCTION__))
3026 "should have a frame for a non-global materialized temporary")((MTE->getStorageDuration() == SD_Static && "should have a frame for a non-global materialized temporary"
) ? static_cast<void> (0) : __assert_fail ("MTE->getStorageDuration() == SD_Static && \"should have a frame for a non-global materialized temporary\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3026, __PRETTY_FUNCTION__))
;
3027
3028 // Per C++1y [expr.const]p2:
3029 // an lvalue-to-rvalue conversion [is not allowed unless it applies to]
3030 // - a [...] glvalue of integral or enumeration type that refers to
3031 // a non-volatile const object [...]
3032 // [...]
3033 // - a [...] glvalue of literal type that refers to a non-volatile
3034 // object whose lifetime began within the evaluation of e.
3035 //
3036 // C++11 misses the 'began within the evaluation of e' check and
3037 // instead allows all temporaries, including things like:
3038 // int &&r = 1;
3039 // int x = ++r;
3040 // constexpr int k = r;
3041 // Therefore we use the C++1y rules in C++11 too.
3042 const ValueDecl *VD = Info.EvaluatingDecl.dyn_cast<const ValueDecl*>();
3043 const ValueDecl *ED = MTE->getExtendingDecl();
3044 if (!(BaseType.isConstQualified() &&
3045 BaseType->isIntegralOrEnumerationType()) &&
3046 !(VD && VD->getCanonicalDecl() == ED->getCanonicalDecl())) {
3047 Info.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
3048 Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here);
3049 return CompleteObject();
3050 }
3051
3052 BaseVal = Info.Ctx.getMaterializedTemporaryValue(MTE, false);
3053 assert(BaseVal && "got reference to unevaluated temporary")((BaseVal && "got reference to unevaluated temporary"
) ? static_cast<void> (0) : __assert_fail ("BaseVal && \"got reference to unevaluated temporary\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3053, __PRETTY_FUNCTION__))
;
3054 } else {
3055 Info.FFDiag(E);
3056 return CompleteObject();
3057 }
3058 } else {
3059 BaseVal = Frame->getTemporary(Base);
3060 assert(BaseVal && "missing value for temporary")((BaseVal && "missing value for temporary") ? static_cast
<void> (0) : __assert_fail ("BaseVal && \"missing value for temporary\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3060, __PRETTY_FUNCTION__))
;
3061 }
3062
3063 // Volatile temporary objects cannot be accessed in constant expressions.
3064 if (BaseType.isVolatileQualified()) {
3065 if (Info.getLangOpts().CPlusPlus) {
3066 Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
3067 << AK << 0;
3068 Info.Note(Base->getExprLoc(), diag::note_constexpr_temporary_here);
3069 } else {
3070 Info.FFDiag(E);
3071 }
3072 return CompleteObject();
3073 }
3074 }
3075
3076 // During the construction of an object, it is not yet 'const'.
3077 // FIXME: We don't set up EvaluatingDecl for local variables or temporaries,
3078 // and this doesn't do quite the right thing for const subobjects of the
3079 // object under construction.
3080 if (LVal.getLValueBase() == Info.EvaluatingDecl) {
3081 BaseType = Info.Ctx.getCanonicalType(BaseType);
3082 BaseType.removeLocalConst();
3083 }
3084
3085 // In C++1y, we can't safely access any mutable state when we might be
3086 // evaluating after an unmodeled side effect.
3087 //
3088 // FIXME: Not all local state is mutable. Allow local constant subobjects
3089 // to be read here (but take care with 'mutable' fields).
3090 if ((Frame && Info.getLangOpts().CPlusPlus14 &&
3091 Info.EvalStatus.HasSideEffects) ||
3092 (AK != AK_Read && Info.IsSpeculativelyEvaluating))
3093 return CompleteObject();
3094
3095 return CompleteObject(BaseVal, BaseType);
3096}
3097
3098/// \brief Perform an lvalue-to-rvalue conversion on the given glvalue. This
3099/// can also be used for 'lvalue-to-lvalue' conversions for looking up the
3100/// glvalue referred to by an entity of reference type.
3101///
3102/// \param Info - Information about the ongoing evaluation.
3103/// \param Conv - The expression for which we are performing the conversion.
3104/// Used for diagnostics.
3105/// \param Type - The type of the glvalue (before stripping cv-qualifiers in the
3106/// case of a non-class type).
3107/// \param LVal - The glvalue on which we are attempting to perform this action.
3108/// \param RVal - The produced value will be placed here.
3109static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
3110 QualType Type,
3111 const LValue &LVal, APValue &RVal) {
3112 if (LVal.Designator.Invalid)
3113 return false;
3114
3115 // Check for special cases where there is no existing APValue to look at.
3116 const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
3117 if (Base && !LVal.CallIndex && !Type.isVolatileQualified()) {
3118 if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
3119 // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the
3120 // initializer until now for such expressions. Such an expression can't be
3121 // an ICE in C, so this only matters for fold.
3122 if (Type.isVolatileQualified()) {
3123 Info.FFDiag(Conv);
3124 return false;
3125 }
3126 APValue Lit;
3127 if (!Evaluate(Lit, Info, CLE->getInitializer()))
3128 return false;
3129 CompleteObject LitObj(&Lit, Base->getType());
3130 return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal);
3131 } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) {
3132 // We represent a string literal array as an lvalue pointing at the
3133 // corresponding expression, rather than building an array of chars.
3134 // FIXME: Support ObjCEncodeExpr, MakeStringConstant
3135 APValue Str(Base, CharUnits::Zero(), APValue::NoLValuePath(), 0);
3136 CompleteObject StrObj(&Str, Base->getType());
3137 return extractSubobject(Info, Conv, StrObj, LVal.Designator, RVal);
3138 }
3139 }
3140
3141 CompleteObject Obj = findCompleteObject(Info, Conv, AK_Read, LVal, Type);
3142 return Obj && extractSubobject(Info, Conv, Obj, LVal.Designator, RVal);
3143}
3144
3145/// Perform an assignment of Val to LVal. Takes ownership of Val.
3146static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal,
3147 QualType LValType, APValue &Val) {
3148 if (LVal.Designator.Invalid)
3149 return false;
3150
3151 if (!Info.getLangOpts().CPlusPlus14) {
3152 Info.FFDiag(E);
3153 return false;
3154 }
3155
3156 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
3157 return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val);
3158}
3159
3160static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T) {
3161 return T->isSignedIntegerType() &&
3162 Ctx.getIntWidth(T) >= Ctx.getIntWidth(Ctx.IntTy);
3163}
3164
3165namespace {
3166struct CompoundAssignSubobjectHandler {
3167 EvalInfo &Info;
3168 const Expr *E;
3169 QualType PromotedLHSType;
3170 BinaryOperatorKind Opcode;
3171 const APValue &RHS;
3172
3173 static const AccessKinds AccessKind = AK_Assign;
3174
3175 typedef bool result_type;
3176
3177 bool checkConst(QualType QT) {
3178 // Assigning to a const object has undefined behavior.
3179 if (QT.isConstQualified()) {
3180 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3181 return false;
3182 }
3183 return true;
3184 }
3185
3186 bool failed() { return false; }
3187 bool found(APValue &Subobj, QualType SubobjType) {
3188 switch (Subobj.getKind()) {
3189 case APValue::Int:
3190 return found(Subobj.getInt(), SubobjType);
3191 case APValue::Float:
3192 return found(Subobj.getFloat(), SubobjType);
3193 case APValue::ComplexInt:
3194 case APValue::ComplexFloat:
3195 // FIXME: Implement complex compound assignment.
3196 Info.FFDiag(E);
3197 return false;
3198 case APValue::LValue:
3199 return foundPointer(Subobj, SubobjType);
3200 default:
3201 // FIXME: can this happen?
3202 Info.FFDiag(E);
3203 return false;
3204 }
3205 }
3206 bool found(APSInt &Value, QualType SubobjType) {
3207 if (!checkConst(SubobjType))
3208 return false;
3209
3210 if (!SubobjType->isIntegerType() || !RHS.isInt()) {
3211 // We don't support compound assignment on integer-cast-to-pointer
3212 // values.
3213 Info.FFDiag(E);
3214 return false;
3215 }
3216
3217 APSInt LHS = HandleIntToIntCast(Info, E, PromotedLHSType,
3218 SubobjType, Value);
3219 if (!handleIntIntBinOp(Info, E, LHS, Opcode, RHS.getInt(), LHS))
3220 return false;
3221 Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS);
3222 return true;
3223 }
3224 bool found(APFloat &Value, QualType SubobjType) {
3225 return checkConst(SubobjType) &&
3226 HandleFloatToFloatCast(Info, E, SubobjType, PromotedLHSType,
3227 Value) &&
3228 handleFloatFloatBinOp(Info, E, Value, Opcode, RHS.getFloat()) &&
3229 HandleFloatToFloatCast(Info, E, PromotedLHSType, SubobjType, Value);
3230 }
3231 bool foundPointer(APValue &Subobj, QualType SubobjType) {
3232 if (!checkConst(SubobjType))
3233 return false;
3234
3235 QualType PointeeType;
3236 if (const PointerType *PT = SubobjType->getAs<PointerType>())
3237 PointeeType = PT->getPointeeType();
3238
3239 if (PointeeType.isNull() || !RHS.isInt() ||
3240 (Opcode != BO_Add && Opcode != BO_Sub)) {
3241 Info.FFDiag(E);
3242 return false;
3243 }
3244
3245 APSInt Offset = RHS.getInt();
3246 if (Opcode == BO_Sub)
3247 negateAsSigned(Offset);
3248
3249 LValue LVal;
3250 LVal.setFrom(Info.Ctx, Subobj);
3251 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, Offset))
3252 return false;
3253 LVal.moveInto(Subobj);
3254 return true;
3255 }
3256 bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
3257 llvm_unreachable("shouldn't encounter string elements here")::llvm::llvm_unreachable_internal("shouldn't encounter string elements here"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3257)
;
3258 }
3259};
3260} // end anonymous namespace
3261
3262const AccessKinds CompoundAssignSubobjectHandler::AccessKind;
3263
3264/// Perform a compound assignment of LVal <op>= RVal.
3265static bool handleCompoundAssignment(
3266 EvalInfo &Info, const Expr *E,
3267 const LValue &LVal, QualType LValType, QualType PromotedLValType,
3268 BinaryOperatorKind Opcode, const APValue &RVal) {
3269 if (LVal.Designator.Invalid)
3270 return false;
3271
3272 if (!Info.getLangOpts().CPlusPlus14) {
3273 Info.FFDiag(E);
3274 return false;
3275 }
3276
3277 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
3278 CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode,
3279 RVal };
3280 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
3281}
3282
3283namespace {
3284struct IncDecSubobjectHandler {
3285 EvalInfo &Info;
3286 const Expr *E;
3287 AccessKinds AccessKind;
3288 APValue *Old;
3289
3290 typedef bool result_type;
3291
3292 bool checkConst(QualType QT) {
3293 // Assigning to a const object has undefined behavior.
3294 if (QT.isConstQualified()) {
3295 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3296 return false;
3297 }
3298 return true;
3299 }
3300
3301 bool failed() { return false; }
3302 bool found(APValue &Subobj, QualType SubobjType) {
3303 // Stash the old value. Also clear Old, so we don't clobber it later
3304 // if we're post-incrementing a complex.
3305 if (Old) {
3306 *Old = Subobj;
3307 Old = nullptr;
3308 }
3309
3310 switch (Subobj.getKind()) {
3311 case APValue::Int:
3312 return found(Subobj.getInt(), SubobjType);
3313 case APValue::Float:
3314 return found(Subobj.getFloat(), SubobjType);
3315 case APValue::ComplexInt:
3316 return found(Subobj.getComplexIntReal(),
3317 SubobjType->castAs<ComplexType>()->getElementType()
3318 .withCVRQualifiers(SubobjType.getCVRQualifiers()));
3319 case APValue::ComplexFloat:
3320 return found(Subobj.getComplexFloatReal(),
3321 SubobjType->castAs<ComplexType>()->getElementType()
3322 .withCVRQualifiers(SubobjType.getCVRQualifiers()));
3323 case APValue::LValue:
3324 return foundPointer(Subobj, SubobjType);
3325 default:
3326 // FIXME: can this happen?
3327 Info.FFDiag(E);
3328 return false;
3329 }
3330 }
3331 bool found(APSInt &Value, QualType SubobjType) {
3332 if (!checkConst(SubobjType))
3333 return false;
3334
3335 if (!SubobjType->isIntegerType()) {
3336 // We don't support increment / decrement on integer-cast-to-pointer
3337 // values.
3338 Info.FFDiag(E);
3339 return false;
3340 }
3341
3342 if (Old) *Old = APValue(Value);
3343
3344 // bool arithmetic promotes to int, and the conversion back to bool
3345 // doesn't reduce mod 2^n, so special-case it.
3346 if (SubobjType->isBooleanType()) {
3347 if (AccessKind == AK_Increment)
3348 Value = 1;
3349 else
3350 Value = !Value;
3351 return true;
3352 }
3353
3354 bool WasNegative = Value.isNegative();
3355 if (AccessKind == AK_Increment) {
3356 ++Value;
3357
3358 if (!WasNegative && Value.isNegative() &&
3359 isOverflowingIntegerType(Info.Ctx, SubobjType)) {
3360 APSInt ActualValue(Value, /*IsUnsigned*/true);
3361 return HandleOverflow(Info, E, ActualValue, SubobjType);
3362 }
3363 } else {
3364 --Value;
3365
3366 if (WasNegative && !Value.isNegative() &&
3367 isOverflowingIntegerType(Info.Ctx, SubobjType)) {
3368 unsigned BitWidth = Value.getBitWidth();
3369 APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false);
3370 ActualValue.setBit(BitWidth);
3371 return HandleOverflow(Info, E, ActualValue, SubobjType);
3372 }
3373 }
3374 return true;
3375 }
3376 bool found(APFloat &Value, QualType SubobjType) {
3377 if (!checkConst(SubobjType))
3378 return false;
3379
3380 if (Old) *Old = APValue(Value);
3381
3382 APFloat One(Value.getSemantics(), 1);
3383 if (AccessKind == AK_Increment)
3384 Value.add(One, APFloat::rmNearestTiesToEven);
3385 else
3386 Value.subtract(One, APFloat::rmNearestTiesToEven);
3387 return true;
3388 }
3389 bool foundPointer(APValue &Subobj, QualType SubobjType) {
3390 if (!checkConst(SubobjType))
3391 return false;
3392
3393 QualType PointeeType;
3394 if (const PointerType *PT = SubobjType->getAs<PointerType>())
3395 PointeeType = PT->getPointeeType();
3396 else {
3397 Info.FFDiag(E);
3398 return false;
3399 }
3400
3401 LValue LVal;
3402 LVal.setFrom(Info.Ctx, Subobj);
3403 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType,
3404 AccessKind == AK_Increment ? 1 : -1))
3405 return false;
3406 LVal.moveInto(Subobj);
3407 return true;
3408 }
3409 bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) {
3410 llvm_unreachable("shouldn't encounter string elements here")::llvm::llvm_unreachable_internal("shouldn't encounter string elements here"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3410)
;
3411 }
3412};
3413} // end anonymous namespace
3414
3415/// Perform an increment or decrement on LVal.
3416static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal,
3417 QualType LValType, bool IsIncrement, APValue *Old) {
3418 if (LVal.Designator.Invalid)
3419 return false;
3420
3421 if (!Info.getLangOpts().CPlusPlus14) {
3422 Info.FFDiag(E);
3423 return false;
3424 }
3425
3426 AccessKinds AK = IsIncrement ? AK_Increment : AK_Decrement;
3427 CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType);
3428 IncDecSubobjectHandler Handler = { Info, E, AK, Old };
3429 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
3430}
3431
3432/// Build an lvalue for the object argument of a member function call.
3433static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
3434 LValue &This) {
3435 if (Object->getType()->isPointerType())
3436 return EvaluatePointer(Object, This, Info);
3437
3438 if (Object->isGLValue())
3439 return EvaluateLValue(Object, This, Info);
3440
3441 if (Object->getType()->isLiteralType(Info.Ctx))
3442 return EvaluateTemporary(Object, This, Info);
3443
3444 Info.FFDiag(Object, diag::note_constexpr_nonliteral) << Object->getType();
3445 return false;
3446}
3447
3448/// HandleMemberPointerAccess - Evaluate a member access operation and build an
3449/// lvalue referring to the result.
3450///
3451/// \param Info - Information about the ongoing evaluation.
3452/// \param LV - An lvalue referring to the base of the member pointer.
3453/// \param RHS - The member pointer expression.
3454/// \param IncludeMember - Specifies whether the member itself is included in
3455/// the resulting LValue subobject designator. This is not possible when
3456/// creating a bound member function.
3457/// \return The field or method declaration to which the member pointer refers,
3458/// or 0 if evaluation fails.
3459static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
3460 QualType LVType,
3461 LValue &LV,
3462 const Expr *RHS,
3463 bool IncludeMember = true) {
3464 MemberPtr MemPtr;
3465 if (!EvaluateMemberPointer(RHS, MemPtr, Info))
3466 return nullptr;
3467
3468 // C++11 [expr.mptr.oper]p6: If the second operand is the null pointer to
3469 // member value, the behavior is undefined.
3470 if (!MemPtr.getDecl()) {
3471 // FIXME: Specific diagnostic.
3472 Info.FFDiag(RHS);
3473 return nullptr;
3474 }
3475
3476 if (MemPtr.isDerivedMember()) {
3477 // This is a member of some derived class. Truncate LV appropriately.
3478 // The end of the derived-to-base path for the base object must match the
3479 // derived-to-base path for the member pointer.
3480 if (LV.Designator.MostDerivedPathLength + MemPtr.Path.size() >
3481 LV.Designator.Entries.size()) {
3482 Info.FFDiag(RHS);
3483 return nullptr;
3484 }
3485 unsigned PathLengthToMember =
3486 LV.Designator.Entries.size() - MemPtr.Path.size();
3487 for (unsigned I = 0, N = MemPtr.Path.size(); I != N; ++I) {
3488 const CXXRecordDecl *LVDecl = getAsBaseClass(
3489 LV.Designator.Entries[PathLengthToMember + I]);
3490 const CXXRecordDecl *MPDecl = MemPtr.Path[I];
3491 if (LVDecl->getCanonicalDecl() != MPDecl->getCanonicalDecl()) {
3492 Info.FFDiag(RHS);
3493 return nullptr;
3494 }
3495 }
3496
3497 // Truncate the lvalue to the appropriate derived class.
3498 if (!CastToDerivedClass(Info, RHS, LV, MemPtr.getContainingRecord(),
3499 PathLengthToMember))
3500 return nullptr;
3501 } else if (!MemPtr.Path.empty()) {
3502 // Extend the LValue path with the member pointer's path.
3503 LV.Designator.Entries.reserve(LV.Designator.Entries.size() +
3504 MemPtr.Path.size() + IncludeMember);
3505
3506 // Walk down to the appropriate base class.
3507 if (const PointerType *PT = LVType->getAs<PointerType>())
3508 LVType = PT->getPointeeType();
3509 const CXXRecordDecl *RD = LVType->getAsCXXRecordDecl();
3510 assert(RD && "member pointer access on non-class-type expression")((RD && "member pointer access on non-class-type expression"
) ? static_cast<void> (0) : __assert_fail ("RD && \"member pointer access on non-class-type expression\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3510, __PRETTY_FUNCTION__))
;
3511 // The first class in the path is that of the lvalue.
3512 for (unsigned I = 1, N = MemPtr.Path.size(); I != N; ++I) {
3513 const CXXRecordDecl *Base = MemPtr.Path[N - I - 1];
3514 if (!HandleLValueDirectBase(Info, RHS, LV, RD, Base))
3515 return nullptr;
3516 RD = Base;
3517 }
3518 // Finally cast to the class containing the member.
3519 if (!HandleLValueDirectBase(Info, RHS, LV, RD,
3520 MemPtr.getContainingRecord()))
3521 return nullptr;
3522 }
3523
3524 // Add the member. Note that we cannot build bound member functions here.
3525 if (IncludeMember) {
3526 if (const FieldDecl *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) {
3527 if (!HandleLValueMember(Info, RHS, LV, FD))
3528 return nullptr;
3529 } else if (const IndirectFieldDecl *IFD =
3530 dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) {
3531 if (!HandleLValueIndirectMember(Info, RHS, LV, IFD))
3532 return nullptr;
3533 } else {
3534 llvm_unreachable("can't construct reference to bound member function")::llvm::llvm_unreachable_internal("can't construct reference to bound member function"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3534)
;
3535 }
3536 }
3537
3538 return MemPtr.getDecl();
3539}
3540
3541static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
3542 const BinaryOperator *BO,
3543 LValue &LV,
3544 bool IncludeMember = true) {
3545 assert(BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI)((BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI
) ? static_cast<void> (0) : __assert_fail ("BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3545, __PRETTY_FUNCTION__))
;
3546
3547 if (!EvaluateObjectArgument(Info, BO->getLHS(), LV)) {
3548 if (Info.noteFailure()) {
3549 MemberPtr MemPtr;
3550 EvaluateMemberPointer(BO->getRHS(), MemPtr, Info);
3551 }
3552 return nullptr;
3553 }
3554
3555 return HandleMemberPointerAccess(Info, BO->getLHS()->getType(), LV,
3556 BO->getRHS(), IncludeMember);
3557}
3558
3559/// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on
3560/// the provided lvalue, which currently refers to the base object.
3561static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E,
3562 LValue &Result) {
3563 SubobjectDesignator &D = Result.Designator;
3564 if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
3565 return false;
3566
3567 QualType TargetQT = E->getType();
3568 if (const PointerType *PT = TargetQT->getAs<PointerType>())
3569 TargetQT = PT->getPointeeType();
3570
3571 // Check this cast lands within the final derived-to-base subobject path.
3572 if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) {
3573 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3574 << D.MostDerivedType << TargetQT;
3575 return false;
3576 }
3577
3578 // Check the type of the final cast. We don't need to check the path,
3579 // since a cast can only be formed if the path is unique.
3580 unsigned NewEntriesSize = D.Entries.size() - E->path_size();
3581 const CXXRecordDecl *TargetType = TargetQT->getAsCXXRecordDecl();
3582 const CXXRecordDecl *FinalType;
3583 if (NewEntriesSize == D.MostDerivedPathLength)
3584 FinalType = D.MostDerivedType->getAsCXXRecordDecl();
3585 else
3586 FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
3587 if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) {
3588 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3589 << D.MostDerivedType << TargetQT;
3590 return false;
3591 }
3592
3593 // Truncate the lvalue to the appropriate derived class.
3594 return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize);
3595}
3596
3597namespace {
3598enum EvalStmtResult {
3599 /// Evaluation failed.
3600 ESR_Failed,
3601 /// Hit a 'return' statement.
3602 ESR_Returned,
3603 /// Evaluation succeeded.
3604 ESR_Succeeded,
3605 /// Hit a 'continue' statement.
3606 ESR_Continue,
3607 /// Hit a 'break' statement.
3608 ESR_Break,
3609 /// Still scanning for 'case' or 'default' statement.
3610 ESR_CaseNotFound
3611};
3612}
3613
3614static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD) {
3615 // We don't need to evaluate the initializer for a static local.
3616 if (!VD->hasLocalStorage())
3617 return true;
3618
3619 LValue Result;
3620 Result.set(VD, Info.CurrentCall->Index);
3621 APValue &Val = Info.CurrentCall->createTemporary(VD, true);
3622
3623 const Expr *InitE = VD->getInit();
3624 if (!InitE) {
3625 Info.FFDiag(VD->getLocStart(), diag::note_constexpr_uninitialized)
3626 << false << VD->getType();
3627 Val = APValue();
3628 return false;
3629 }
3630
3631 if (InitE->isValueDependent())
3632 return false;
3633
3634 if (!EvaluateInPlace(Val, Info, Result, InitE)) {
3635 // Wipe out any partially-computed value, to allow tracking that this
3636 // evaluation failed.
3637 Val = APValue();
3638 return false;
3639 }
3640
3641 return true;
3642}
3643
3644static bool EvaluateDecl(EvalInfo &Info, const Decl *D) {
3645 bool OK = true;
3646
3647 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
3648 OK &= EvaluateVarDecl(Info, VD);
3649
3650 if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(D))
3651 for (auto *BD : DD->bindings())
3652 if (auto *VD = BD->getHoldingVar())
3653 OK &= EvaluateDecl(Info, VD);
3654
3655 return OK;
3656}
3657
3658
3659/// Evaluate a condition (either a variable declaration or an expression).
3660static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
3661 const Expr *Cond, bool &Result) {
3662 FullExpressionRAII Scope(Info);
3663 if (CondDecl && !EvaluateDecl(Info, CondDecl))
3664 return false;
3665 return EvaluateAsBooleanCondition(Cond, Result, Info);
3666}
3667
3668namespace {
3669/// \brief A location where the result (returned value) of evaluating a
3670/// statement should be stored.
3671struct StmtResult {
3672 /// The APValue that should be filled in with the returned value.
3673 APValue &Value;
3674 /// The location containing the result, if any (used to support RVO).
3675 const LValue *Slot;
3676};
3677}
3678
3679static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
3680 const Stmt *S,
3681 const SwitchCase *SC = nullptr);
3682
3683/// Evaluate the body of a loop, and translate the result as appropriate.
3684static EvalStmtResult EvaluateLoopBody(StmtResult &Result, EvalInfo &Info,
3685 const Stmt *Body,
3686 const SwitchCase *Case = nullptr) {
3687 BlockScopeRAII Scope(Info);
3688 switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, Body, Case)) {
3689 case ESR_Break:
3690 return ESR_Succeeded;
3691 case ESR_Succeeded:
3692 case ESR_Continue:
3693 return ESR_Continue;
3694 case ESR_Failed:
3695 case ESR_Returned:
3696 case ESR_CaseNotFound:
3697 return ESR;
3698 }
3699 llvm_unreachable("Invalid EvalStmtResult!")::llvm::llvm_unreachable_internal("Invalid EvalStmtResult!", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3699)
;
3700}
3701
3702/// Evaluate a switch statement.
3703static EvalStmtResult EvaluateSwitch(StmtResult &Result, EvalInfo &Info,
3704 const SwitchStmt *SS) {
3705 BlockScopeRAII Scope(Info);
3706
3707 // Evaluate the switch condition.
3708 APSInt Value;
3709 {
3710 FullExpressionRAII Scope(Info);
3711 if (const Stmt *Init = SS->getInit()) {
3712 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
3713 if (ESR != ESR_Succeeded)
3714 return ESR;
3715 }
3716 if (SS->getConditionVariable() &&
3717 !EvaluateDecl(Info, SS->getConditionVariable()))
3718 return ESR_Failed;
3719 if (!EvaluateInteger(SS->getCond(), Value, Info))
3720 return ESR_Failed;
3721 }
3722
3723 // Find the switch case corresponding to the value of the condition.
3724 // FIXME: Cache this lookup.
3725 const SwitchCase *Found = nullptr;
3726 for (const SwitchCase *SC = SS->getSwitchCaseList(); SC;
3727 SC = SC->getNextSwitchCase()) {
3728 if (isa<DefaultStmt>(SC)) {
3729 Found = SC;
3730 continue;
3731 }
3732
3733 const CaseStmt *CS = cast<CaseStmt>(SC);
3734 APSInt LHS = CS->getLHS()->EvaluateKnownConstInt(Info.Ctx);
3735 APSInt RHS = CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx)
3736 : LHS;
3737 if (LHS <= Value && Value <= RHS) {
3738 Found = SC;
3739 break;
3740 }
3741 }
3742
3743 if (!Found)
3744 return ESR_Succeeded;
3745
3746 // Search the switch body for the switch case and evaluate it from there.
3747 switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, SS->getBody(), Found)) {
3748 case ESR_Break:
3749 return ESR_Succeeded;
3750 case ESR_Succeeded:
3751 case ESR_Continue:
3752 case ESR_Failed:
3753 case ESR_Returned:
3754 return ESR;
3755 case ESR_CaseNotFound:
3756 // This can only happen if the switch case is nested within a statement
3757 // expression. We have no intention of supporting that.
3758 Info.FFDiag(Found->getLocStart(), diag::note_constexpr_stmt_expr_unsupported);
3759 return ESR_Failed;
3760 }
3761 llvm_unreachable("Invalid EvalStmtResult!")::llvm::llvm_unreachable_internal("Invalid EvalStmtResult!", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 3761)
;
3762}
3763
3764// Evaluate a statement.
3765static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
3766 const Stmt *S, const SwitchCase *Case) {
3767 if (!Info.nextStep(S))
3768 return ESR_Failed;
3769
3770 // If we're hunting down a 'case' or 'default' label, recurse through
3771 // substatements until we hit the label.
3772 if (Case) {
3773 // FIXME: We don't start the lifetime of objects whose initialization we
3774 // jump over. However, such objects must be of class type with a trivial
3775 // default constructor that initialize all subobjects, so must be empty,
3776 // so this almost never matters.
3777 switch (S->getStmtClass()) {
3778 case Stmt::CompoundStmtClass:
3779 // FIXME: Precompute which substatement of a compound statement we
3780 // would jump to, and go straight there rather than performing a
3781 // linear scan each time.
3782 case Stmt::LabelStmtClass:
3783 case Stmt::AttributedStmtClass:
3784 case Stmt::DoStmtClass:
3785 break;
3786
3787 case Stmt::CaseStmtClass:
3788 case Stmt::DefaultStmtClass:
3789 if (Case == S)
3790 Case = nullptr;
3791 break;
3792
3793 case Stmt::IfStmtClass: {
3794 // FIXME: Precompute which side of an 'if' we would jump to, and go
3795 // straight there rather than scanning both sides.
3796 const IfStmt *IS = cast<IfStmt>(S);
3797
3798 // Wrap the evaluation in a block scope, in case it's a DeclStmt
3799 // preceded by our switch label.
3800 BlockScopeRAII Scope(Info);
3801
3802 EvalStmtResult ESR = EvaluateStmt(Result, Info, IS->getThen(), Case);
3803 if (ESR != ESR_CaseNotFound || !IS->getElse())
3804 return ESR;
3805 return EvaluateStmt(Result, Info, IS->getElse(), Case);
3806 }
3807
3808 case Stmt::WhileStmtClass: {
3809 EvalStmtResult ESR =
3810 EvaluateLoopBody(Result, Info, cast<WhileStmt>(S)->getBody(), Case);
3811 if (ESR != ESR_Continue)
3812 return ESR;
3813 break;
3814 }
3815
3816 case Stmt::ForStmtClass: {
3817 const ForStmt *FS = cast<ForStmt>(S);
3818 EvalStmtResult ESR =
3819 EvaluateLoopBody(Result, Info, FS->getBody(), Case);
3820 if (ESR != ESR_Continue)
3821 return ESR;
3822 if (FS->getInc()) {
3823 FullExpressionRAII IncScope(Info);
3824 if (!EvaluateIgnoredValue(Info, FS->getInc()))
3825 return ESR_Failed;
3826 }
3827 break;
3828 }
3829
3830 case Stmt::DeclStmtClass:
3831 // FIXME: If the variable has initialization that can't be jumped over,
3832 // bail out of any immediately-surrounding compound-statement too.
3833 default:
3834 return ESR_CaseNotFound;
3835 }
3836 }
3837
3838 switch (S->getStmtClass()) {
3839 default:
3840 if (const Expr *E = dyn_cast<Expr>(S)) {
3841 // Don't bother evaluating beyond an expression-statement which couldn't
3842 // be evaluated.
3843 FullExpressionRAII Scope(Info);
3844 if (!EvaluateIgnoredValue(Info, E))
3845 return ESR_Failed;
3846 return ESR_Succeeded;
3847 }
3848
3849 Info.FFDiag(S->getLocStart());
3850 return ESR_Failed;
3851
3852 case Stmt::NullStmtClass:
3853 return ESR_Succeeded;
3854
3855 case Stmt::DeclStmtClass: {
3856 const DeclStmt *DS = cast<DeclStmt>(S);
3857 for (const auto *DclIt : DS->decls()) {
3858 // Each declaration initialization is its own full-expression.
3859 // FIXME: This isn't quite right; if we're performing aggregate
3860 // initialization, each braced subexpression is its own full-expression.
3861 FullExpressionRAII Scope(Info);
3862 if (!EvaluateDecl(Info, DclIt) && !Info.noteFailure())
3863 return ESR_Failed;
3864 }
3865 return ESR_Succeeded;
3866 }
3867
3868 case Stmt::ReturnStmtClass: {
3869 const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
3870 FullExpressionRAII Scope(Info);
3871 if (RetExpr &&
3872 !(Result.Slot
3873 ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
3874 : Evaluate(Result.Value, Info, RetExpr)))
3875 return ESR_Failed;
3876 return ESR_Returned;
3877 }
3878
3879 case Stmt::CompoundStmtClass: {
3880 BlockScopeRAII Scope(Info);
3881
3882 const CompoundStmt *CS = cast<CompoundStmt>(S);
3883 for (const auto *BI : CS->body()) {
3884 EvalStmtResult ESR = EvaluateStmt(Result, Info, BI, Case);
3885 if (ESR == ESR_Succeeded)
3886 Case = nullptr;
3887 else if (ESR != ESR_CaseNotFound)
3888 return ESR;
3889 }
3890 return Case ? ESR_CaseNotFound : ESR_Succeeded;
3891 }
3892
3893 case Stmt::IfStmtClass: {
3894 const IfStmt *IS = cast<IfStmt>(S);
3895
3896 // Evaluate the condition, as either a var decl or as an expression.
3897 BlockScopeRAII Scope(Info);
3898 if (const Stmt *Init = IS->getInit()) {
3899 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
3900 if (ESR != ESR_Succeeded)
3901 return ESR;
3902 }
3903 bool Cond;
3904 if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
3905 return ESR_Failed;
3906
3907 if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
3908 EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt);
3909 if (ESR != ESR_Succeeded)
3910 return ESR;
3911 }
3912 return ESR_Succeeded;
3913 }
3914
3915 case Stmt::WhileStmtClass: {
3916 const WhileStmt *WS = cast<WhileStmt>(S);
3917 while (true) {
3918 BlockScopeRAII Scope(Info);
3919 bool Continue;
3920 if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(),
3921 Continue))
3922 return ESR_Failed;
3923 if (!Continue)
3924 break;
3925
3926 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, WS->getBody());
3927 if (ESR != ESR_Continue)
3928 return ESR;
3929 }
3930 return ESR_Succeeded;
3931 }
3932
3933 case Stmt::DoStmtClass: {
3934 const DoStmt *DS = cast<DoStmt>(S);
3935 bool Continue;
3936 do {
3937 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case);
3938 if (ESR != ESR_Continue)
3939 return ESR;
3940 Case = nullptr;
3941
3942 FullExpressionRAII CondScope(Info);
3943 if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info))
3944 return ESR_Failed;
3945 } while (Continue);
3946 return ESR_Succeeded;
3947 }
3948
3949 case Stmt::ForStmtClass: {
3950 const ForStmt *FS = cast<ForStmt>(S);
3951 BlockScopeRAII Scope(Info);
3952 if (FS->getInit()) {
3953 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
3954 if (ESR != ESR_Succeeded)
3955 return ESR;
3956 }
3957 while (true) {
3958 BlockScopeRAII Scope(Info);
3959 bool Continue = true;
3960 if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(),
3961 FS->getCond(), Continue))
3962 return ESR_Failed;
3963 if (!Continue)
3964 break;
3965
3966 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody());
3967 if (ESR != ESR_Continue)
3968 return ESR;
3969
3970 if (FS->getInc()) {
3971 FullExpressionRAII IncScope(Info);
3972 if (!EvaluateIgnoredValue(Info, FS->getInc()))
3973 return ESR_Failed;
3974 }
3975 }
3976 return ESR_Succeeded;
3977 }
3978
3979 case Stmt::CXXForRangeStmtClass: {
3980 const CXXForRangeStmt *FS = cast<CXXForRangeStmt>(S);
3981 BlockScopeRAII Scope(Info);
3982
3983 // Initialize the __range variable.
3984 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getRangeStmt());
3985 if (ESR != ESR_Succeeded)
3986 return ESR;
3987
3988 // Create the __begin and __end iterators.
3989 ESR = EvaluateStmt(Result, Info, FS->getBeginStmt());
3990 if (ESR != ESR_Succeeded)
3991 return ESR;
3992 ESR = EvaluateStmt(Result, Info, FS->getEndStmt());
3993 if (ESR != ESR_Succeeded)
3994 return ESR;
3995
3996 while (true) {
3997 // Condition: __begin != __end.
3998 {
3999 bool Continue = true;
4000 FullExpressionRAII CondExpr(Info);
4001 if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info))
4002 return ESR_Failed;
4003 if (!Continue)
4004 break;
4005 }
4006
4007 // User's variable declaration, initialized by *__begin.
4008 BlockScopeRAII InnerScope(Info);
4009 ESR = EvaluateStmt(Result, Info, FS->getLoopVarStmt());
4010 if (ESR != ESR_Succeeded)
4011 return ESR;
4012
4013 // Loop body.
4014 ESR = EvaluateLoopBody(Result, Info, FS->getBody());
4015 if (ESR != ESR_Continue)
4016 return ESR;
4017
4018 // Increment: ++__begin
4019 if (!EvaluateIgnoredValue(Info, FS->getInc()))
4020 return ESR_Failed;
4021 }
4022
4023 return ESR_Succeeded;
4024 }
4025
4026 case Stmt::SwitchStmtClass:
4027 return EvaluateSwitch(Result, Info, cast<SwitchStmt>(S));
4028
4029 case Stmt::ContinueStmtClass:
4030 return ESR_Continue;
4031
4032 case Stmt::BreakStmtClass:
4033 return ESR_Break;
4034
4035 case Stmt::LabelStmtClass:
4036 return EvaluateStmt(Result, Info, cast<LabelStmt>(S)->getSubStmt(), Case);
4037
4038 case Stmt::AttributedStmtClass:
4039 // As a general principle, C++11 attributes can be ignored without
4040 // any semantic impact.
4041 return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(),
4042 Case);
4043
4044 case Stmt::CaseStmtClass:
4045 case Stmt::DefaultStmtClass:
4046 return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case);
4047 }
4048}
4049
4050/// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial
4051/// default constructor. If so, we'll fold it whether or not it's marked as
4052/// constexpr. If it is marked as constexpr, we will never implicitly define it,
4053/// so we need special handling.
4054static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,
4055 const CXXConstructorDecl *CD,
4056 bool IsValueInitialization) {
4057 if (!CD->isTrivial() || !CD->isDefaultConstructor())
4058 return false;
4059
4060 // Value-initialization does not call a trivial default constructor, so such a
4061 // call is a core constant expression whether or not the constructor is
4062 // constexpr.
4063 if (!CD->isConstexpr() && !IsValueInitialization) {
4064 if (Info.getLangOpts().CPlusPlus11) {
4065 // FIXME: If DiagDecl is an implicitly-declared special member function,
4066 // we should be much more explicit about why it's not constexpr.
4067 Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
4068 << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD;
4069 Info.Note(CD->getLocation(), diag::note_declared_at);
4070 } else {
4071 Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
4072 }
4073 }
4074 return true;
4075}
4076
4077/// CheckConstexprFunction - Check that a function can be called in a constant
4078/// expression.
4079static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc,
4080 const FunctionDecl *Declaration,
4081 const FunctionDecl *Definition,
4082 const Stmt *Body) {
4083 // Potential constant expressions can contain calls to declared, but not yet
4084 // defined, constexpr functions.
4085 if (Info.checkingPotentialConstantExpression() && !Definition &&
4086 Declaration->isConstexpr())
4087 return false;
4088
4089 // Bail out with no diagnostic if the function declaration itself is invalid.
4090 // We will have produced a relevant diagnostic while parsing it.
4091 if (Declaration->isInvalidDecl())
4092 return false;
4093
4094 // Can we evaluate this function call?
4095 if (Definition && Definition->isConstexpr() &&
4096 !Definition->isInvalidDecl() && Body)
4097 return true;
4098
4099 if (Info.getLangOpts().CPlusPlus11) {
4100 const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;
4101
4102 // If this function is not constexpr because it is an inherited
4103 // non-constexpr constructor, diagnose that directly.
4104 auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
4105 if (CD && CD->isInheritingConstructor()) {
4106 auto *Inherited = CD->getInheritedConstructor().getConstructor();
4107 if (!Inherited->isConstexpr())
4108 DiagDecl = CD = Inherited;
4109 }
4110
4111 // FIXME: If DiagDecl is an implicitly-declared special member function
4112 // or an inheriting constructor, we should be much more explicit about why
4113 // it's not constexpr.
4114 if (CD && CD->isInheritingConstructor())
4115 Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1)
4116 << CD->getInheritedConstructor().getConstructor()->getParent();
4117 else
4118 Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1)
4119 << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
4120 Info.Note(DiagDecl->getLocation(), diag::note_declared_at);
4121 } else {
4122 Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
4123 }
4124 return false;
4125}
4126
4127/// Determine if a class has any fields that might need to be copied by a
4128/// trivial copy or move operation.
4129static bool hasFields(const CXXRecordDecl *RD) {
4130 if (!RD || RD->isEmpty())
4131 return false;
4132 for (auto *FD : RD->fields()) {
4133 if (FD->isUnnamedBitfield())
4134 continue;
4135 return true;
4136 }
4137 for (auto &Base : RD->bases())
4138 if (hasFields(Base.getType()->getAsCXXRecordDecl()))
4139 return true;
4140 return false;
4141}
4142
4143namespace {
4144typedef SmallVector<APValue, 8> ArgVector;
4145}
4146
4147/// EvaluateArgs - Evaluate the arguments to a function call.
4148static bool EvaluateArgs(ArrayRef<const Expr*> Args, ArgVector &ArgValues,
4149 EvalInfo &Info) {
4150 bool Success = true;
4151 for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end();
4152 I != E; ++I) {
4153 if (!Evaluate(ArgValues[I - Args.begin()], Info, *I)) {
4154 // If we're checking for a potential constant expression, evaluate all
4155 // initializers even if some of them fail.
4156 if (!Info.noteFailure())
4157 return false;
4158 Success = false;
4159 }
4160 }
4161 return Success;
4162}
4163
4164/// Evaluate a function call.
4165static bool HandleFunctionCall(SourceLocation CallLoc,
4166 const FunctionDecl *Callee, const LValue *This,
4167 ArrayRef<const Expr*> Args, const Stmt *Body,
4168 EvalInfo &Info, APValue &Result,
4169 const LValue *ResultSlot) {
4170 ArgVector ArgValues(Args.size());
4171 if (!EvaluateArgs(Args, ArgValues, Info))
4172 return false;
4173
4174 if (!Info.CheckCallLimit(CallLoc))
4175 return false;
4176
4177 CallStackFrame Frame(Info, CallLoc, Callee, This, ArgValues.data());
4178
4179 // For a trivial copy or move assignment, perform an APValue copy. This is
4180 // essential for unions, where the operations performed by the assignment
4181 // operator cannot be represented as statements.
4182 //
4183 // Skip this for non-union classes with no fields; in that case, the defaulted
4184 // copy/move does not actually read the object.
4185 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee);
4186 if (MD && MD->isDefaulted() &&
4187 (MD->getParent()->isUnion() ||
4188 (MD->isTrivial() && hasFields(MD->getParent())))) {
4189 assert(This &&((This && (MD->isCopyAssignmentOperator() || MD->
isMoveAssignmentOperator())) ? static_cast<void> (0) : __assert_fail
("This && (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4190, __PRETTY_FUNCTION__))
4190 (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()))((This && (MD->isCopyAssignmentOperator() || MD->
isMoveAssignmentOperator())) ? static_cast<void> (0) : __assert_fail
("This && (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4190, __PRETTY_FUNCTION__))
;
4191 LValue RHS;
4192 RHS.setFrom(Info.Ctx, ArgValues[0]);
4193 APValue RHSValue;
4194 if (!handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(),
4195 RHS, RHSValue))
4196 return false;
4197 if (!handleAssignment(Info, Args[0], *This, MD->getThisType(Info.Ctx),
4198 RHSValue))
4199 return false;
4200 This->moveInto(Result);
4201 return true;
4202 } else if (MD && isLambdaCallOperator(MD)) {
4203 // We're in a lambda; determine the lambda capture field maps.
4204 MD->getParent()->getCaptureFields(Frame.LambdaCaptureFields,
4205 Frame.LambdaThisCaptureField);
4206 }
4207
4208 StmtResult Ret = {Result, ResultSlot};
4209 EvalStmtResult ESR = EvaluateStmt(Ret, Info, Body);
4210 if (ESR == ESR_Succeeded) {
4211 if (Callee->getReturnType()->isVoidType())
4212 return true;
4213 Info.FFDiag(Callee->getLocEnd(), diag::note_constexpr_no_return);
4214 }
4215 return ESR == ESR_Returned;
4216}
4217
4218/// Evaluate a constructor call.
4219static bool HandleConstructorCall(const Expr *E, const LValue &This,
4220 APValue *ArgValues,
4221 const CXXConstructorDecl *Definition,
4222 EvalInfo &Info, APValue &Result) {
4223 SourceLocation CallLoc = E->getExprLoc();
4224 if (!Info.CheckCallLimit(CallLoc))
4225 return false;
4226
4227 const CXXRecordDecl *RD = Definition->getParent();
4228 if (RD->getNumVBases()) {
4229 Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
4230 return false;
4231 }
4232
4233 CallStackFrame Frame(Info, CallLoc, Definition, &This, ArgValues);
4234
4235 // FIXME: Creating an APValue just to hold a nonexistent return value is
4236 // wasteful.
4237 APValue RetVal;
4238 StmtResult Ret = {RetVal, nullptr};
4239
4240 // If it's a delegating constructor, delegate.
4241 if (Definition->isDelegatingConstructor()) {
4242 CXXConstructorDecl::init_const_iterator I = Definition->init_begin();
4243 {
4244 FullExpressionRAII InitScope(Info);
4245 if (!EvaluateInPlace(Result, Info, This, (*I)->getInit()))
4246 return false;
4247 }
4248 return EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed;
4249 }
4250
4251 // For a trivial copy or move constructor, perform an APValue copy. This is
4252 // essential for unions (or classes with anonymous union members), where the
4253 // operations performed by the constructor cannot be represented by
4254 // ctor-initializers.
4255 //
4256 // Skip this for empty non-union classes; we should not perform an
4257 // lvalue-to-rvalue conversion on them because their copy constructor does not
4258 // actually read them.
4259 if (Definition->isDefaulted() && Definition->isCopyOrMoveConstructor() &&
4260 (Definition->getParent()->isUnion() ||
4261 (Definition->isTrivial() && hasFields(Definition->getParent())))) {
4262 LValue RHS;
4263 RHS.setFrom(Info.Ctx, ArgValues[0]);
4264 return handleLValueToRValueConversion(
4265 Info, E, Definition->getParamDecl(0)->getType().getNonReferenceType(),
4266 RHS, Result);
4267 }
4268
4269 // Reserve space for the struct members.
4270 if (!RD->isUnion() && Result.isUninit())
4271 Result = APValue(APValue::UninitStruct(), RD->getNumBases(),
4272 std::distance(RD->field_begin(), RD->field_end()));
4273
4274 if (RD->isInvalidDecl()) return false;
4275 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
4276
4277 // A scope for temporaries lifetime-extended by reference members.
4278 BlockScopeRAII LifetimeExtendedScope(Info);
4279
4280 bool Success = true;
4281 unsigned BasesSeen = 0;
4282#ifndef NDEBUG
4283 CXXRecordDecl::base_class_const_iterator BaseIt = RD->bases_begin();
4284#endif
4285 for (const auto *I : Definition->inits()) {
4286 LValue Subobject = This;
4287 APValue *Value = &Result;
4288
4289 // Determine the subobject to initialize.
4290 FieldDecl *FD = nullptr;
4291 if (I->isBaseInitializer()) {
4292 QualType BaseType(I->getBaseClass(), 0);
4293#ifndef NDEBUG
4294 // Non-virtual base classes are initialized in the order in the class
4295 // definition. We have already checked for virtual base classes.
4296 assert(!BaseIt->isVirtual() && "virtual base for literal type")((!BaseIt->isVirtual() && "virtual base for literal type"
) ? static_cast<void> (0) : __assert_fail ("!BaseIt->isVirtual() && \"virtual base for literal type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4296, __PRETTY_FUNCTION__))
;
4297 assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&((Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&
"base class initializers not in expected order") ? static_cast
<void> (0) : __assert_fail ("Info.Ctx.hasSameType(BaseIt->getType(), BaseType) && \"base class initializers not in expected order\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4298, __PRETTY_FUNCTION__))
4298 "base class initializers not in expected order")((Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&
"base class initializers not in expected order") ? static_cast
<void> (0) : __assert_fail ("Info.Ctx.hasSameType(BaseIt->getType(), BaseType) && \"base class initializers not in expected order\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4298, __PRETTY_FUNCTION__))
;
4299 ++BaseIt;
4300#endif
4301 if (!HandleLValueDirectBase(Info, I->getInit(), Subobject, RD,
4302 BaseType->getAsCXXRecordDecl(), &Layout))
4303 return false;
4304 Value = &Result.getStructBase(BasesSeen++);
4305 } else if ((FD = I->getMember())) {
4306 if (!HandleLValueMember(Info, I->getInit(), Subobject, FD, &Layout))
4307 return false;
4308 if (RD->isUnion()) {
4309 Result = APValue(FD);
4310 Value = &Result.getUnionValue();
4311 } else {
4312 Value = &Result.getStructField(FD->getFieldIndex());
4313 }
4314 } else if (IndirectFieldDecl *IFD = I->getIndirectMember()) {
4315 // Walk the indirect field decl's chain to find the object to initialize,
4316 // and make sure we've initialized every step along it.
4317 for (auto *C : IFD->chain()) {
4318 FD = cast<FieldDecl>(C);
4319 CXXRecordDecl *CD = cast<CXXRecordDecl>(FD->getParent());
4320 // Switch the union field if it differs. This happens if we had
4321 // preceding zero-initialization, and we're now initializing a union
4322 // subobject other than the first.
4323 // FIXME: In this case, the values of the other subobjects are
4324 // specified, since zero-initialization sets all padding bits to zero.
4325 if (Value->isUninit() ||
4326 (Value->isUnion() && Value->getUnionField() != FD)) {
4327 if (CD->isUnion())
4328 *Value = APValue(FD);
4329 else
4330 *Value = APValue(APValue::UninitStruct(), CD->getNumBases(),
4331 std::distance(CD->field_begin(), CD->field_end()));
4332 }
4333 if (!HandleLValueMember(Info, I->getInit(), Subobject, FD))
4334 return false;
4335 if (CD->isUnion())
4336 Value = &Value->getUnionValue();
4337 else
4338 Value = &Value->getStructField(FD->getFieldIndex());
4339 }
4340 } else {
4341 llvm_unreachable("unknown base initializer kind")::llvm::llvm_unreachable_internal("unknown base initializer kind"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4341)
;
4342 }
4343
4344 FullExpressionRAII InitScope(Info);
4345 if (!EvaluateInPlace(*Value, Info, Subobject, I->getInit()) ||
4346 (FD && FD->isBitField() && !truncateBitfieldValue(Info, I->getInit(),
4347 *Value, FD))) {
4348 // If we're checking for a potential constant expression, evaluate all
4349 // initializers even if some of them fail.
4350 if (!Info.noteFailure())
4351 return false;
4352 Success = false;
4353 }
4354 }
4355
4356 return Success &&
4357 EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed;
4358}
4359
4360static bool HandleConstructorCall(const Expr *E, const LValue &This,
4361 ArrayRef<const Expr*> Args,
4362 const CXXConstructorDecl *Definition,
4363 EvalInfo &Info, APValue &Result) {
4364 ArgVector ArgValues(Args.size());
4365 if (!EvaluateArgs(Args, ArgValues, Info))
4366 return false;
4367
4368 return HandleConstructorCall(E, This, ArgValues.data(), Definition,
4369 Info, Result);
4370}
4371
4372//===----------------------------------------------------------------------===//
4373// Generic Evaluation
4374//===----------------------------------------------------------------------===//
4375namespace {
4376
4377template <class Derived>
4378class ExprEvaluatorBase
4379 : public ConstStmtVisitor<Derived, bool> {
4380private:
4381 Derived &getDerived() { return static_cast<Derived&>(*this); }
4382 bool DerivedSuccess(const APValue &V, const Expr *E) {
4383 return getDerived().Success(V, E);
4384 }
4385 bool DerivedZeroInitialization(const Expr *E) {
4386 return getDerived().ZeroInitialization(E);
4387 }
4388
4389 // Check whether a conditional operator with a non-constant condition is a
4390 // potential constant expression. If neither arm is a potential constant
4391 // expression, then the conditional operator is not either.
4392 template<typename ConditionalOperator>
4393 void CheckPotentialConstantConditional(const ConditionalOperator *E) {
4394 assert(Info.checkingPotentialConstantExpression())((Info.checkingPotentialConstantExpression()) ? static_cast<
void> (0) : __assert_fail ("Info.checkingPotentialConstantExpression()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4394, __PRETTY_FUNCTION__))
;
4395
4396 // Speculatively evaluate both arms.
4397 SmallVector<PartialDiagnosticAt, 8> Diag;
4398 {
4399 SpeculativeEvaluationRAII Speculate(Info, &Diag);
4400 StmtVisitorTy::Visit(E->getFalseExpr());
4401 if (Diag.empty())
4402 return;
4403 }
4404
4405 {
4406 SpeculativeEvaluationRAII Speculate(Info, &Diag);
4407 Diag.clear();
4408 StmtVisitorTy::Visit(E->getTrueExpr());
4409 if (Diag.empty())
4410 return;
4411 }
4412
4413 Error(E, diag::note_constexpr_conditional_never_const);
4414 }
4415
4416
4417 template<typename ConditionalOperator>
4418 bool HandleConditionalOperator(const ConditionalOperator *E) {
4419 bool BoolResult;
4420 if (!EvaluateAsBooleanCondition(E->getCond(), BoolResult, Info)) {
4421 if (Info.checkingPotentialConstantExpression() && Info.noteFailure()) {
4422 CheckPotentialConstantConditional(E);
4423 return false;
4424 }
4425 if (Info.noteFailure()) {
4426 StmtVisitorTy::Visit(E->getTrueExpr());
4427 StmtVisitorTy::Visit(E->getFalseExpr());
4428 }
4429 return false;
4430 }
4431
4432 Expr *EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr();
4433 return StmtVisitorTy::Visit(EvalExpr);
4434 }
4435
4436protected:
4437 EvalInfo &Info;
4438 typedef ConstStmtVisitor<Derived, bool> StmtVisitorTy;
4439 typedef ExprEvaluatorBase ExprEvaluatorBaseTy;
4440
4441 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
4442 return Info.CCEDiag(E, D);
4443 }
4444
4445 bool ZeroInitialization(const Expr *E) { return Error(E); }
4446
4447public:
4448 ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
4449
4450 EvalInfo &getEvalInfo() { return Info; }
4451
4452 /// Report an evaluation error. This should only be called when an error is
4453 /// first discovered. When propagating an error, just return false.
4454 bool Error(const Expr *E, diag::kind D) {
4455 Info.FFDiag(E, D);
4456 return false;
4457 }
4458 bool Error(const Expr *E) {
4459 return Error(E, diag::note_invalid_subexpr_in_const_expr);
4460 }
4461
4462 bool VisitStmt(const Stmt *) {
4463 llvm_unreachable("Expression evaluator should not be called on stmts")::llvm::llvm_unreachable_internal("Expression evaluator should not be called on stmts"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4463)
;
4464 }
4465 bool VisitExpr(const Expr *E) {
4466 return Error(E);
4467 }
4468
4469 bool VisitParenExpr(const ParenExpr *E)
4470 { return StmtVisitorTy::Visit(E->getSubExpr()); }
4471 bool VisitUnaryExtension(const UnaryOperator *E)
4472 { return StmtVisitorTy::Visit(E->getSubExpr()); }
4473 bool VisitUnaryPlus(const UnaryOperator *E)
4474 { return StmtVisitorTy::Visit(E->getSubExpr()); }
4475 bool VisitChooseExpr(const ChooseExpr *E)
4476 { return StmtVisitorTy::Visit(E->getChosenSubExpr()); }
4477 bool VisitGenericSelectionExpr(const GenericSelectionExpr *E)
4478 { return StmtVisitorTy::Visit(E->getResultExpr()); }
4479 bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E)
4480 { return StmtVisitorTy::Visit(E->getReplacement()); }
4481 bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E)
4482 { return StmtVisitorTy::Visit(E->getExpr()); }
4483 bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
4484 // The initializer may not have been parsed yet, or might be erroneous.
4485 if (!E->getExpr())
4486 return Error(E);
4487 return StmtVisitorTy::Visit(E->getExpr());
4488 }
4489 // We cannot create any objects for which cleanups are required, so there is
4490 // nothing to do here; all cleanups must come from unevaluated subexpressions.
4491 bool VisitExprWithCleanups(const ExprWithCleanups *E)
4492 { return StmtVisitorTy::Visit(E->getSubExpr()); }
4493
4494 bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
4495 CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
4496 return static_cast<Derived*>(this)->VisitCastExpr(E);
4497 }
4498 bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
4499 CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
4500 return static_cast<Derived*>(this)->VisitCastExpr(E);
4501 }
4502
4503 bool VisitBinaryOperator(const BinaryOperator *E) {
4504 switch (E->getOpcode()) {
4505 default:
4506 return Error(E);
4507
4508 case BO_Comma:
4509 VisitIgnoredValue(E->getLHS());
4510 return StmtVisitorTy::Visit(E->getRHS());
4511
4512 case BO_PtrMemD:
4513 case BO_PtrMemI: {
4514 LValue Obj;
4515 if (!HandleMemberPointerAccess(Info, E, Obj))
4516 return false;
4517 APValue Result;
4518 if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result))
4519 return false;
4520 return DerivedSuccess(Result, E);
4521 }
4522 }
4523 }
4524
4525 bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E) {
4526 // Evaluate and cache the common expression. We treat it as a temporary,
4527 // even though it's not quite the same thing.
4528 if (!Evaluate(Info.CurrentCall->createTemporary(E->getOpaqueValue(), false),
4529 Info, E->getCommon()))
4530 return false;
4531
4532 return HandleConditionalOperator(E);
4533 }
4534
4535 bool VisitConditionalOperator(const ConditionalOperator *E) {
4536 bool IsBcpCall = false;
4537 // If the condition (ignoring parens) is a __builtin_constant_p call,
4538 // the result is a constant expression if it can be folded without
4539 // side-effects. This is an important GNU extension. See GCC PR38377
4540 // for discussion.
4541 if (const CallExpr *CallCE =
4542 dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
4543 if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
4544 IsBcpCall = true;
4545
4546 // Always assume __builtin_constant_p(...) ? ... : ... is a potential
4547 // constant expression; we can't check whether it's potentially foldable.
4548 if (Info.checkingPotentialConstantExpression() && IsBcpCall)
4549 return false;
4550
4551 FoldConstant Fold(Info, IsBcpCall);
4552 if (!HandleConditionalOperator(E)) {
4553 Fold.keepDiagnostics();
4554 return false;
4555 }
4556
4557 return true;
4558 }
4559
4560 bool VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
4561 if (APValue *Value = Info.CurrentCall->getTemporary(E))
4562 return DerivedSuccess(*Value, E);
4563
4564 const Expr *Source = E->getSourceExpr();
4565 if (!Source)
4566 return Error(E);
4567 if (Source == E) { // sanity checking.
4568 assert(0 && "OpaqueValueExpr recursively refers to itself")((0 && "OpaqueValueExpr recursively refers to itself"
) ? static_cast<void> (0) : __assert_fail ("0 && \"OpaqueValueExpr recursively refers to itself\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4568, __PRETTY_FUNCTION__))
;
4569 return Error(E);
4570 }
4571 return StmtVisitorTy::Visit(Source);
4572 }
4573
4574 bool VisitCallExpr(const CallExpr *E) {
4575 APValue Result;
4576 if (!handleCallExpr(E, Result, nullptr))
4577 return false;
4578 return DerivedSuccess(Result, E);
4579 }
4580
4581 bool handleCallExpr(const CallExpr *E, APValue &Result,
4582 const LValue *ResultSlot) {
4583 const Expr *Callee = E->getCallee()->IgnoreParens();
4584 QualType CalleeType = Callee->getType();
4585
4586 const FunctionDecl *FD = nullptr;
4587 LValue *This = nullptr, ThisVal;
4588 auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
4589 bool HasQualifier = false;
4590
4591 struct EvaluateIgnoredRAII {
4592 public:
4593 EvaluateIgnoredRAII(EvalInfo &Info, llvm::ArrayRef<const Expr*> ToEval)
4594 : Info(Info), ToEval(ToEval) {}
4595 ~EvaluateIgnoredRAII() {
4596 if (Info.noteFailure()) {
4597 for (auto E : ToEval)
4598 EvaluateIgnoredValue(Info, E);
4599 }
4600 }
4601 void cancel() { ToEval = {}; }
4602 void drop_front() { ToEval = ToEval.drop_front(); }
4603 private:
4604 EvalInfo &Info;
4605 llvm::ArrayRef<const Expr*> ToEval;
4606 } EvalArguments(Info, Args);
4607
4608 // Extract function decl and 'this' pointer from the callee.
4609 if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) {
4610 const ValueDecl *Member = nullptr;
4611 if (const MemberExpr *ME = dyn_cast<MemberExpr>(Callee)) {
4612 // Explicit bound member calls, such as x.f() or p->g();
4613 if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal))
4614 return false;
4615 Member = ME->getMemberDecl();
4616 This = &ThisVal;
4617 HasQualifier = ME->hasQualifier();
4618 } else if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) {
4619 // Indirect bound member calls ('.*' or '->*').
4620 Member = HandleMemberPointerAccess(Info, BE, ThisVal, false);
4621 if (!Member) return false;
4622 This = &ThisVal;
4623 } else
4624 return Error(Callee);
4625
4626 FD = dyn_cast<FunctionDecl>(Member);
4627 if (!FD)
4628 return Error(Callee);
4629 } else if (CalleeType->isFunctionPointerType()) {
4630 LValue Call;
4631 if (!EvaluatePointer(Callee, Call, Info))
4632 return false;
4633
4634 if (!Call.getLValueOffset().isZero())
4635 return Error(Callee);
4636 FD = dyn_cast_or_null<FunctionDecl>(
4637 Call.getLValueBase().dyn_cast<const ValueDecl*>());
4638 if (!FD)
4639 return Error(Callee);
4640 // Don't call function pointers which have been cast to some other type.
4641 // Per DR (no number yet), the caller and callee can differ in noexcept.
4642 if (!Info.Ctx.hasSameFunctionTypeIgnoringExceptionSpec(
4643 CalleeType->getPointeeType(), FD->getType())) {
4644 return Error(E);
4645 }
4646
4647 // Overloaded operator calls to member functions are represented as normal
4648 // calls with '*this' as the first argument.
4649 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
4650 if (MD && !MD->isStatic()) {
4651 // FIXME: When selecting an implicit conversion for an overloaded
4652 // operator delete, we sometimes try to evaluate calls to conversion
4653 // operators without a 'this' parameter!
4654 if (Args.empty())
4655 return Error(E);
4656
4657 const Expr *FirstArg = Args[0];
4658 Args = Args.drop_front();
4659 EvalArguments.drop_front();
4660 if (!EvaluateObjectArgument(Info, FirstArg, ThisVal))
4661 return false;
4662 This = &ThisVal;
4663 } else if (MD && MD->isLambdaStaticInvoker()) {
4664 // Map the static invoker for the lambda back to the call operator.
4665 // Conveniently, we don't have to slice out the 'this' argument (as is
4666 // being done for the non-static case), since a static member function
4667 // doesn't have an implicit argument passed in.
4668 const CXXRecordDecl *ClosureClass = MD->getParent();
4669 assert(((ClosureClass->captures_begin() == ClosureClass->captures_end
() && "Number of captures must be zero for conversion to function-ptr"
) ? static_cast<void> (0) : __assert_fail ("ClosureClass->captures_begin() == ClosureClass->captures_end() && \"Number of captures must be zero for conversion to function-ptr\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4671, __PRETTY_FUNCTION__))
4670 ClosureClass->captures_begin() == ClosureClass->captures_end() &&((ClosureClass->captures_begin() == ClosureClass->captures_end
() && "Number of captures must be zero for conversion to function-ptr"
) ? static_cast<void> (0) : __assert_fail ("ClosureClass->captures_begin() == ClosureClass->captures_end() && \"Number of captures must be zero for conversion to function-ptr\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4671, __PRETTY_FUNCTION__))
4671 "Number of captures must be zero for conversion to function-ptr")((ClosureClass->captures_begin() == ClosureClass->captures_end
() && "Number of captures must be zero for conversion to function-ptr"
) ? static_cast<void> (0) : __assert_fail ("ClosureClass->captures_begin() == ClosureClass->captures_end() && \"Number of captures must be zero for conversion to function-ptr\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4671, __PRETTY_FUNCTION__))
;
4672
4673 const CXXMethodDecl *LambdaCallOp =
4674 ClosureClass->getLambdaCallOperator();
4675
4676 // Set 'FD', the function that will be called below, to the call
4677 // operator. If the closure object represents a generic lambda, find
4678 // the corresponding specialization of the call operator.
4679
4680 if (ClosureClass->isGenericLambda()) {
4681 assert(MD->isFunctionTemplateSpecialization() &&((MD->isFunctionTemplateSpecialization() && "A generic lambda's static-invoker function must be a "
"template specialization") ? static_cast<void> (0) : __assert_fail
("MD->isFunctionTemplateSpecialization() && \"A generic lambda's static-invoker function must be a \" \"template specialization\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4683, __PRETTY_FUNCTION__))
4682 "A generic lambda's static-invoker function must be a "((MD->isFunctionTemplateSpecialization() && "A generic lambda's static-invoker function must be a "
"template specialization") ? static_cast<void> (0) : __assert_fail
("MD->isFunctionTemplateSpecialization() && \"A generic lambda's static-invoker function must be a \" \"template specialization\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4683, __PRETTY_FUNCTION__))
4683 "template specialization")((MD->isFunctionTemplateSpecialization() && "A generic lambda's static-invoker function must be a "
"template specialization") ? static_cast<void> (0) : __assert_fail
("MD->isFunctionTemplateSpecialization() && \"A generic lambda's static-invoker function must be a \" \"template specialization\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4683, __PRETTY_FUNCTION__))
;
4684 const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs();
4685 FunctionTemplateDecl *CallOpTemplate =
4686 LambdaCallOp->getDescribedFunctionTemplate();
4687 void *InsertPos = nullptr;
4688 FunctionDecl *CorrespondingCallOpSpecialization =
4689 CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos);
4690 assert(CorrespondingCallOpSpecialization &&((CorrespondingCallOpSpecialization && "We must always have a function call operator specialization "
"that corresponds to our static invoker specialization") ? static_cast
<void> (0) : __assert_fail ("CorrespondingCallOpSpecialization && \"We must always have a function call operator specialization \" \"that corresponds to our static invoker specialization\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4692, __PRETTY_FUNCTION__))
4691 "We must always have a function call operator specialization "((CorrespondingCallOpSpecialization && "We must always have a function call operator specialization "
"that corresponds to our static invoker specialization") ? static_cast
<void> (0) : __assert_fail ("CorrespondingCallOpSpecialization && \"We must always have a function call operator specialization \" \"that corresponds to our static invoker specialization\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4692, __PRETTY_FUNCTION__))
4692 "that corresponds to our static invoker specialization")((CorrespondingCallOpSpecialization && "We must always have a function call operator specialization "
"that corresponds to our static invoker specialization") ? static_cast
<void> (0) : __assert_fail ("CorrespondingCallOpSpecialization && \"We must always have a function call operator specialization \" \"that corresponds to our static invoker specialization\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4692, __PRETTY_FUNCTION__))
;
4693 FD = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization);
4694 } else
4695 FD = LambdaCallOp;
4696 }
4697
4698
4699 } else
4700 return Error(E);
4701
4702 if (This && !This->checkSubobject(Info, E, CSK_This))
4703 return false;
4704
4705 // DR1358 allows virtual constexpr functions in some cases. Don't allow
4706 // calls to such functions in constant expressions.
4707 if (This && !HasQualifier &&
4708 isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isVirtual())
4709 return Error(E, diag::note_constexpr_virtual_call);
4710
4711 const FunctionDecl *Definition = nullptr;
4712 Stmt *Body = FD->getBody(Definition);
4713
4714 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
4715 return false;
4716
4717 EvalArguments.cancel();
4718
4719 if (!HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Body, Info,
4720 Result, ResultSlot))
4721 return false;
4722
4723 return true;
4724 }
4725
4726 bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
4727 return StmtVisitorTy::Visit(E->getInitializer());
4728 }
4729 bool VisitInitListExpr(const InitListExpr *E) {
4730 if (E->getNumInits() == 0)
4731 return DerivedZeroInitialization(E);
4732 if (E->getNumInits() == 1)
4733 return StmtVisitorTy::Visit(E->getInit(0));
4734 return Error(E);
4735 }
4736 bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
4737 return DerivedZeroInitialization(E);
4738 }
4739 bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
4740 return DerivedZeroInitialization(E);
4741 }
4742 bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
4743 return DerivedZeroInitialization(E);
4744 }
4745
4746 /// A member expression where the object is a prvalue is itself a prvalue.
4747 bool VisitMemberExpr(const MemberExpr *E) {
4748 assert(!E->isArrow() && "missing call to bound member function?")((!E->isArrow() && "missing call to bound member function?"
) ? static_cast<void> (0) : __assert_fail ("!E->isArrow() && \"missing call to bound member function?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4748, __PRETTY_FUNCTION__))
;
4749
4750 APValue Val;
4751 if (!Evaluate(Val, Info, E->getBase()))
4752 return false;
4753
4754 QualType BaseTy = E->getBase()->getType();
4755
4756 const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
4757 if (!FD) return Error(E);
4758 assert(!FD->getType()->isReferenceType() && "prvalue reference?")((!FD->getType()->isReferenceType() && "prvalue reference?"
) ? static_cast<void> (0) : __assert_fail ("!FD->getType()->isReferenceType() && \"prvalue reference?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4758, __PRETTY_FUNCTION__))
;
4759 assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() ==((BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl
() == FD->getParent()->getCanonicalDecl() && "record / field mismatch"
) ? static_cast<void> (0) : __assert_fail ("BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() == FD->getParent()->getCanonicalDecl() && \"record / field mismatch\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4760, __PRETTY_FUNCTION__))
4760 FD->getParent()->getCanonicalDecl() && "record / field mismatch")((BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl
() == FD->getParent()->getCanonicalDecl() && "record / field mismatch"
) ? static_cast<void> (0) : __assert_fail ("BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() == FD->getParent()->getCanonicalDecl() && \"record / field mismatch\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4760, __PRETTY_FUNCTION__))
;
4761
4762 CompleteObject Obj(&Val, BaseTy);
4763 SubobjectDesignator Designator(BaseTy);
4764 Designator.addDeclUnchecked(FD);
4765
4766 APValue Result;
4767 return extractSubobject(Info, E, Obj, Designator, Result) &&
4768 DerivedSuccess(Result, E);
4769 }
4770
4771 bool VisitCastExpr(const CastExpr *E) {
4772 switch (E->getCastKind()) {
4773 default:
4774 break;
4775
4776 case CK_AtomicToNonAtomic: {
4777 APValue AtomicVal;
4778 // This does not need to be done in place even for class/array types:
4779 // atomic-to-non-atomic conversion implies copying the object
4780 // representation.
4781 if (!Evaluate(AtomicVal, Info, E->getSubExpr()))
4782 return false;
4783 return DerivedSuccess(AtomicVal, E);
4784 }
4785
4786 case CK_NoOp:
4787 case CK_UserDefinedConversion:
4788 return StmtVisitorTy::Visit(E->getSubExpr());
4789
4790 case CK_LValueToRValue: {
4791 LValue LVal;
4792 if (!EvaluateLValue(E->getSubExpr(), LVal, Info))
4793 return false;
4794 APValue RVal;
4795 // Note, we use the subexpression's type in order to retain cv-qualifiers.
4796 if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
4797 LVal, RVal))
4798 return false;
4799 return DerivedSuccess(RVal, E);
4800 }
4801 }
4802
4803 return Error(E);
4804 }
4805
4806 bool VisitUnaryPostInc(const UnaryOperator *UO) {
4807 return VisitUnaryPostIncDec(UO);
4808 }
4809 bool VisitUnaryPostDec(const UnaryOperator *UO) {
4810 return VisitUnaryPostIncDec(UO);
4811 }
4812 bool VisitUnaryPostIncDec(const UnaryOperator *UO) {
4813 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
4814 return Error(UO);
4815
4816 LValue LVal;
4817 if (!EvaluateLValue(UO->getSubExpr(), LVal, Info))
4818 return false;
4819 APValue RVal;
4820 if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(),
4821 UO->isIncrementOp(), &RVal))
4822 return false;
4823 return DerivedSuccess(RVal, UO);
4824 }
4825
4826 bool VisitStmtExpr(const StmtExpr *E) {
4827 // We will have checked the full-expressions inside the statement expression
4828 // when they were completed, and don't need to check them again now.
4829 if (Info.checkingForOverflow())
4830 return Error(E);
4831
4832 BlockScopeRAII Scope(Info);
4833 const CompoundStmt *CS = E->getSubStmt();
4834 if (CS->body_empty())
4835 return true;
4836
4837 for (CompoundStmt::const_body_iterator BI = CS->body_begin(),
4838 BE = CS->body_end();
4839 /**/; ++BI) {
4840 if (BI + 1 == BE) {
4841 const Expr *FinalExpr = dyn_cast<Expr>(*BI);
4842 if (!FinalExpr) {
4843 Info.FFDiag((*BI)->getLocStart(),
4844 diag::note_constexpr_stmt_expr_unsupported);
4845 return false;
4846 }
4847 return this->Visit(FinalExpr);
4848 }
4849
4850 APValue ReturnValue;
4851 StmtResult Result = { ReturnValue, nullptr };
4852 EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI);
4853 if (ESR != ESR_Succeeded) {
4854 // FIXME: If the statement-expression terminated due to 'return',
4855 // 'break', or 'continue', it would be nice to propagate that to
4856 // the outer statement evaluation rather than bailing out.
4857 if (ESR != ESR_Failed)
4858 Info.FFDiag((*BI)->getLocStart(),
4859 diag::note_constexpr_stmt_expr_unsupported);
4860 return false;
4861 }
4862 }
4863
4864 llvm_unreachable("Return from function from the loop above.")::llvm::llvm_unreachable_internal("Return from function from the loop above."
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4864)
;
4865 }
4866
4867 /// Visit a value which is evaluated, but whose value is ignored.
4868 void VisitIgnoredValue(const Expr *E) {
4869 EvaluateIgnoredValue(Info, E);
4870 }
4871
4872 /// Potentially visit a MemberExpr's base expression.
4873 void VisitIgnoredBaseExpression(const Expr *E) {
4874 // While MSVC doesn't evaluate the base expression, it does diagnose the
4875 // presence of side-effecting behavior.
4876 if (Info.getLangOpts().MSVCCompat && !E->HasSideEffects(Info.Ctx))
4877 return;
4878 VisitIgnoredValue(E);
4879 }
4880};
4881
4882}
4883
4884//===----------------------------------------------------------------------===//
4885// Common base class for lvalue and temporary evaluation.
4886//===----------------------------------------------------------------------===//
4887namespace {
4888template<class Derived>
4889class LValueExprEvaluatorBase
4890 : public ExprEvaluatorBase<Derived> {
4891protected:
4892 LValue &Result;
4893 bool InvalidBaseOK;
4894 typedef LValueExprEvaluatorBase LValueExprEvaluatorBaseTy;
4895 typedef ExprEvaluatorBase<Derived> ExprEvaluatorBaseTy;
4896
4897 bool Success(APValue::LValueBase B) {
4898 Result.set(B);
4899 return true;
4900 }
4901
4902 bool evaluatePointer(const Expr *E, LValue &Result) {
4903 return EvaluatePointer(E, Result, this->Info, InvalidBaseOK);
4904 }
4905
4906public:
4907 LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result, bool InvalidBaseOK)
4908 : ExprEvaluatorBaseTy(Info), Result(Result),
4909 InvalidBaseOK(InvalidBaseOK) {}
4910
4911 bool Success(const APValue &V, const Expr *E) {
4912 Result.setFrom(this->Info.Ctx, V);
4913 return true;
4914 }
4915
4916 bool VisitMemberExpr(const MemberExpr *E) {
4917 // Handle non-static data members.
4918 QualType BaseTy;
4919 bool EvalOK;
4920 if (E->isArrow()) {
4921 EvalOK = evaluatePointer(E->getBase(), Result);
4922 BaseTy = E->getBase()->getType()->castAs<PointerType>()->getPointeeType();
4923 } else if (E->getBase()->isRValue()) {
4924 assert(E->getBase()->getType()->isRecordType())((E->getBase()->getType()->isRecordType()) ? static_cast
<void> (0) : __assert_fail ("E->getBase()->getType()->isRecordType()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4924, __PRETTY_FUNCTION__))
;
4925 EvalOK = EvaluateTemporary(E->getBase(), Result, this->Info);
4926 BaseTy = E->getBase()->getType();
4927 } else {
4928 EvalOK = this->Visit(E->getBase());
4929 BaseTy = E->getBase()->getType();
4930 }
4931 if (!EvalOK) {
4932 if (!InvalidBaseOK)
4933 return false;
4934 Result.setInvalid(E);
4935 return true;
4936 }
4937
4938 const ValueDecl *MD = E->getMemberDecl();
4939 if (const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
4940 assert(BaseTy->getAs<RecordType>()->getDecl()->getCanonicalDecl() ==((BaseTy->getAs<RecordType>()->getDecl()->getCanonicalDecl
() == FD->getParent()->getCanonicalDecl() && "record / field mismatch"
) ? static_cast<void> (0) : __assert_fail ("BaseTy->getAs<RecordType>()->getDecl()->getCanonicalDecl() == FD->getParent()->getCanonicalDecl() && \"record / field mismatch\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4941, __PRETTY_FUNCTION__))
4941 FD->getParent()->getCanonicalDecl() && "record / field mismatch")((BaseTy->getAs<RecordType>()->getDecl()->getCanonicalDecl
() == FD->getParent()->getCanonicalDecl() && "record / field mismatch"
) ? static_cast<void> (0) : __assert_fail ("BaseTy->getAs<RecordType>()->getDecl()->getCanonicalDecl() == FD->getParent()->getCanonicalDecl() && \"record / field mismatch\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 4941, __PRETTY_FUNCTION__))
;
4942 (void)BaseTy;
4943 if (!HandleLValueMember(this->Info, E, Result, FD))
4944 return false;
4945 } else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(MD)) {
4946 if (!HandleLValueIndirectMember(this->Info, E, Result, IFD))
4947 return false;
4948 } else
4949 return this->Error(E);
4950
4951 if (MD->getType()->isReferenceType()) {
4952 APValue RefValue;
4953 if (!handleLValueToRValueConversion(this->Info, E, MD->getType(), Result,
4954 RefValue))
4955 return false;
4956 return Success(RefValue, E);
4957 }
4958 return true;
4959 }
4960
4961 bool VisitBinaryOperator(const BinaryOperator *E) {
4962 switch (E->getOpcode()) {
4963 default:
4964 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
4965
4966 case BO_PtrMemD:
4967 case BO_PtrMemI:
4968 return HandleMemberPointerAccess(this->Info, E, Result);
4969 }
4970 }
4971
4972 bool VisitCastExpr(const CastExpr *E) {
4973 switch (E->getCastKind()) {
4974 default:
4975 return ExprEvaluatorBaseTy::VisitCastExpr(E);
4976
4977 case CK_DerivedToBase:
4978 case CK_UncheckedDerivedToBase:
4979 if (!this->Visit(E->getSubExpr()))
4980 return false;
4981
4982 // Now figure out the necessary offset to add to the base LV to get from
4983 // the derived class to the base class.
4984 return HandleLValueBasePath(this->Info, E, E->getSubExpr()->getType(),
4985 Result);
4986 }
4987 }
4988};
4989}
4990
4991//===----------------------------------------------------------------------===//
4992// LValue Evaluation
4993//
4994// This is used for evaluating lvalues (in C and C++), xvalues (in C++11),
4995// function designators (in C), decl references to void objects (in C), and
4996// temporaries (if building with -Wno-address-of-temporary).
4997//
4998// LValue evaluation produces values comprising a base expression of one of the
4999// following types:
5000// - Declarations
5001// * VarDecl
5002// * FunctionDecl
5003// - Literals
5004// * CompoundLiteralExpr in C (and in global scope in C++)
5005// * StringLiteral
5006// * CXXTypeidExpr
5007// * PredefinedExpr
5008// * ObjCStringLiteralExpr
5009// * ObjCEncodeExpr
5010// * AddrLabelExpr
5011// * BlockExpr
5012// * CallExpr for a MakeStringConstant builtin
5013// - Locals and temporaries
5014// * MaterializeTemporaryExpr
5015// * Any Expr, with a CallIndex indicating the function in which the temporary
5016// was evaluated, for cases where the MaterializeTemporaryExpr is missing
5017// from the AST (FIXME).
5018// * A MaterializeTemporaryExpr that has static storage duration, with no
5019// CallIndex, for a lifetime-extended temporary.
5020// plus an offset in bytes.
5021//===----------------------------------------------------------------------===//
5022namespace {
5023class LValueExprEvaluator
5024 : public LValueExprEvaluatorBase<LValueExprEvaluator> {
5025public:
5026 LValueExprEvaluator(EvalInfo &Info, LValue &Result, bool InvalidBaseOK) :
5027 LValueExprEvaluatorBaseTy(Info, Result, InvalidBaseOK) {}
5028
5029 bool VisitVarDecl(const Expr *E, const VarDecl *VD);
5030 bool VisitUnaryPreIncDec(const UnaryOperator *UO);
5031
5032 bool VisitDeclRefExpr(const DeclRefExpr *E);
5033 bool VisitPredefinedExpr(const PredefinedExpr *E) { return Success(E); }
5034 bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
5035 bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
5036 bool VisitMemberExpr(const MemberExpr *E);
5037 bool VisitStringLiteral(const StringLiteral *E) { return Success(E); }
5038 bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { return Success(E); }
5039 bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
5040 bool VisitCXXUuidofExpr(const CXXUuidofExpr *E);
5041 bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
5042 bool VisitUnaryDeref(const UnaryOperator *E);
5043 bool VisitUnaryReal(const UnaryOperator *E);
5044 bool VisitUnaryImag(const UnaryOperator *E);
5045 bool VisitUnaryPreInc(const UnaryOperator *UO) {
5046 return VisitUnaryPreIncDec(UO);
5047 }
5048 bool VisitUnaryPreDec(const UnaryOperator *UO) {
5049 return VisitUnaryPreIncDec(UO);
5050 }
5051 bool VisitBinAssign(const BinaryOperator *BO);
5052 bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO);
5053
5054 bool VisitCastExpr(const CastExpr *E) {
5055 switch (E->getCastKind()) {
5056 default:
5057 return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
5058
5059 case CK_LValueBitCast:
5060 this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5061 if (!Visit(E->getSubExpr()))
5062 return false;
5063 Result.Designator.setInvalid();
5064 return true;
5065
5066 case CK_BaseToDerived:
5067 if (!Visit(E->getSubExpr()))
5068 return false;
5069 return HandleBaseToDerivedCast(Info, E, Result);
5070 }
5071 }
5072};
5073} // end anonymous namespace
5074
5075/// Evaluate an expression as an lvalue. This can be legitimately called on
5076/// expressions which are not glvalues, in three cases:
5077/// * function designators in C, and
5078/// * "extern void" objects
5079/// * @selector() expressions in Objective-C
5080static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
5081 bool InvalidBaseOK) {
5082 assert(E->isGLValue() || E->getType()->isFunctionType() ||((E->isGLValue() || E->getType()->isFunctionType() ||
E->getType()->isVoidType() || isa<ObjCSelectorExpr>
(E)) ? static_cast<void> (0) : __assert_fail ("E->isGLValue() || E->getType()->isFunctionType() || E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E)"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5083, __PRETTY_FUNCTION__))
5083 E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E))((E->isGLValue() || E->getType()->isFunctionType() ||
E->getType()->isVoidType() || isa<ObjCSelectorExpr>
(E)) ? static_cast<void> (0) : __assert_fail ("E->isGLValue() || E->getType()->isFunctionType() || E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E)"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5083, __PRETTY_FUNCTION__))
;
5084 return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
5085}
5086
5087bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) {
5088 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(E->getDecl()))
1
Taking false branch
5089 return Success(FD);
5090 if (const VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
2
Assuming 'VD' is non-null
3
Taking true branch
5091 return VisitVarDecl(E, VD);
4
Calling 'LValueExprEvaluator::VisitVarDecl'
5092 if (const BindingDecl *BD = dyn_cast<BindingDecl>(E->getDecl()))
5093 return Visit(BD->getBinding());
5094 return Error(E);
5095}
5096
5097
5098bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
5099
5100 // If we are within a lambda's call operator, check whether the 'VD' referred
5101 // to within 'E' actually represents a lambda-capture that maps to a
5102 // data-member/field within the closure object, and if so, evaluate to the
5103 // field or what the field refers to.
5104 if (Info.CurrentCall && isLambdaCallOperator(Info.CurrentCall->Callee)) {
5
Assuming pointer value is null
5105 if (auto *FD = Info.CurrentCall->LambdaCaptureFields.lookup(VD)) {
5106 if (Info.checkingPotentialConstantExpression())
5107 return false;
5108 // Start with 'Result' referring to the complete closure object...
5109 Result = *Info.CurrentCall->This;
5110 // ... then update it to refer to the field of the closure object
5111 // that represents the capture.
5112 if (!HandleLValueMember(Info, E, Result, FD))
5113 return false;
5114 // And if the field is of reference type, update 'Result' to refer to what
5115 // the field refers to.
5116 if (FD->getType()->isReferenceType()) {
5117 APValue RVal;
5118 if (!handleLValueToRValueConversion(Info, E, FD->getType(), Result,
5119 RVal))
5120 return false;
5121 Result.setFrom(Info.Ctx, RVal);
5122 }
5123 return true;
5124 }
5125 }
5126 CallStackFrame *Frame = nullptr;
5127 if (VD->hasLocalStorage() && Info.CurrentCall->Index > 1) {
6
Access to field 'Index' results in a dereference of a null pointer (loaded from field 'CurrentCall')
5128 // Only if a local variable was declared in the function currently being
5129 // evaluated, do we expect to be able to find its value in the current
5130 // frame. (Otherwise it was likely declared in an enclosing context and
5131 // could either have a valid evaluatable value (for e.g. a constexpr
5132 // variable) or be ill-formed (and trigger an appropriate evaluation
5133 // diagnostic)).
5134 if (Info.CurrentCall->Callee &&
5135 Info.CurrentCall->Callee->Equals(VD->getDeclContext())) {
5136 Frame = Info.CurrentCall;
5137 }
5138 }
5139
5140 if (!VD->getType()->isReferenceType()) {
5141 if (Frame) {
5142 Result.set(VD, Frame->Index);
5143 return true;
5144 }
5145 return Success(VD);
5146 }
5147
5148 APValue *V;
5149 if (!evaluateVarDeclInit(Info, E, VD, Frame, V))
5150 return false;
5151 if (V->isUninit()) {
5152 if (!Info.checkingPotentialConstantExpression())
5153 Info.FFDiag(E, diag::note_constexpr_use_uninit_reference);
5154 return false;
5155 }
5156 return Success(*V, E);
5157}
5158
5159bool LValueExprEvaluator::VisitMaterializeTemporaryExpr(
5160 const MaterializeTemporaryExpr *E) {
5161 // Walk through the expression to find the materialized temporary itself.
5162 SmallVector<const Expr *, 2> CommaLHSs;
5163 SmallVector<SubobjectAdjustment, 2> Adjustments;
5164 const Expr *Inner = E->GetTemporaryExpr()->
5165 skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
5166
5167 // If we passed any comma operators, evaluate their LHSs.
5168 for (unsigned I = 0, N = CommaLHSs.size(); I != N; ++I)
5169 if (!EvaluateIgnoredValue(Info, CommaLHSs[I]))
5170 return false;
5171
5172 // A materialized temporary with static storage duration can appear within the
5173 // result of a constant expression evaluation, so we need to preserve its
5174 // value for use outside this evaluation.
5175 APValue *Value;
5176 if (E->getStorageDuration() == SD_Static) {
5177 Value = Info.Ctx.getMaterializedTemporaryValue(E, true);
5178 *Value = APValue();
5179 Result.set(E);
5180 } else {
5181 Value = &Info.CurrentCall->
5182 createTemporary(E, E->getStorageDuration() == SD_Automatic);
5183 Result.set(E, Info.CurrentCall->Index);
5184 }
5185
5186 QualType Type = Inner->getType();
5187
5188 // Materialize the temporary itself.
5189 if (!EvaluateInPlace(*Value, Info, Result, Inner) ||
5190 (E->getStorageDuration() == SD_Static &&
5191 !CheckConstantExpression(Info, E->getExprLoc(), Type, *Value))) {
5192 *Value = APValue();
5193 return false;
5194 }
5195
5196 // Adjust our lvalue to refer to the desired subobject.
5197 for (unsigned I = Adjustments.size(); I != 0; /**/) {
5198 --I;
5199 switch (Adjustments[I].Kind) {
5200 case SubobjectAdjustment::DerivedToBaseAdjustment:
5201 if (!HandleLValueBasePath(Info, Adjustments[I].DerivedToBase.BasePath,
5202 Type, Result))
5203 return false;
5204 Type = Adjustments[I].DerivedToBase.BasePath->getType();
5205 break;
5206
5207 case SubobjectAdjustment::FieldAdjustment:
5208 if (!HandleLValueMember(Info, E, Result, Adjustments[I].Field))
5209 return false;
5210 Type = Adjustments[I].Field->getType();
5211 break;
5212
5213 case SubobjectAdjustment::MemberPointerAdjustment:
5214 if (!HandleMemberPointerAccess(this->Info, Type, Result,
5215 Adjustments[I].Ptr.RHS))
5216 return false;
5217 Type = Adjustments[I].Ptr.MPT->getPointeeType();
5218 break;
5219 }
5220 }
5221
5222 return true;
5223}
5224
5225bool
5226LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
5227 assert((!Info.getLangOpts().CPlusPlus || E->isFileScope()) &&(((!Info.getLangOpts().CPlusPlus || E->isFileScope()) &&
"lvalue compound literal in c++?") ? static_cast<void>
(0) : __assert_fail ("(!Info.getLangOpts().CPlusPlus || E->isFileScope()) && \"lvalue compound literal in c++?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5228, __PRETTY_FUNCTION__))
5228 "lvalue compound literal in c++?")(((!Info.getLangOpts().CPlusPlus || E->isFileScope()) &&
"lvalue compound literal in c++?") ? static_cast<void>
(0) : __assert_fail ("(!Info.getLangOpts().CPlusPlus || E->isFileScope()) && \"lvalue compound literal in c++?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5228, __PRETTY_FUNCTION__))
;
5229 // Defer visiting the literal until the lvalue-to-rvalue conversion. We can
5230 // only see this when folding in C, so there's no standard to follow here.
5231 return Success(E);
5232}
5233
5234bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
5235 if (!E->isPotentiallyEvaluated())
5236 return Success(E);
5237
5238 Info.FFDiag(E, diag::note_constexpr_typeid_polymorphic)
5239 << E->getExprOperand()->getType()
5240 << E->getExprOperand()->getSourceRange();
5241 return false;
5242}
5243
5244bool LValueExprEvaluator::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
5245 return Success(E);
5246}
5247
5248bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
5249 // Handle static data members.
5250 if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) {
5251 VisitIgnoredBaseExpression(E->getBase());
5252 return VisitVarDecl(E, VD);
5253 }
5254
5255 // Handle static member functions.
5256 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) {
5257 if (MD->isStatic()) {
5258 VisitIgnoredBaseExpression(E->getBase());
5259 return Success(MD);
5260 }
5261 }
5262
5263 // Handle non-static data members.
5264 return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
5265}
5266
5267bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
5268 // FIXME: Deal with vectors as array subscript bases.
5269 if (E->getBase()->getType()->isVectorType())
5270 return Error(E);
5271
5272 bool Success = true;
5273 if (!evaluatePointer(E->getBase(), Result)) {
5274 if (!Info.noteFailure())
5275 return false;
5276 Success = false;
5277 }
5278
5279 APSInt Index;
5280 if (!EvaluateInteger(E->getIdx(), Index, Info))
5281 return false;
5282
5283 return Success &&
5284 HandleLValueArrayAdjustment(Info, E, Result, E->getType(), Index);
5285}
5286
5287bool LValueExprEvaluator::VisitUnaryDeref(const UnaryOperator *E) {
5288 return evaluatePointer(E->getSubExpr(), Result);
5289}
5290
5291bool LValueExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
5292 if (!Visit(E->getSubExpr()))
5293 return false;
5294 // __real is a no-op on scalar lvalues.
5295 if (E->getSubExpr()->getType()->isAnyComplexType())
5296 HandleLValueComplexElement(Info, E, Result, E->getType(), false);
5297 return true;
5298}
5299
5300bool LValueExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
5301 assert(E->getSubExpr()->getType()->isAnyComplexType() &&((E->getSubExpr()->getType()->isAnyComplexType() &&
"lvalue __imag__ on scalar?") ? static_cast<void> (0) :
__assert_fail ("E->getSubExpr()->getType()->isAnyComplexType() && \"lvalue __imag__ on scalar?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5302, __PRETTY_FUNCTION__))
5302 "lvalue __imag__ on scalar?")((E->getSubExpr()->getType()->isAnyComplexType() &&
"lvalue __imag__ on scalar?") ? static_cast<void> (0) :
__assert_fail ("E->getSubExpr()->getType()->isAnyComplexType() && \"lvalue __imag__ on scalar?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5302, __PRETTY_FUNCTION__))
;
5303 if (!Visit(E->getSubExpr()))
5304 return false;
5305 HandleLValueComplexElement(Info, E, Result, E->getType(), true);
5306 return true;
5307}
5308
5309bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) {
5310 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5311 return Error(UO);
5312
5313 if (!this->Visit(UO->getSubExpr()))
5314 return false;
5315
5316 return handleIncDec(
5317 this->Info, UO, Result, UO->getSubExpr()->getType(),
5318 UO->isIncrementOp(), nullptr);
5319}
5320
5321bool LValueExprEvaluator::VisitCompoundAssignOperator(
5322 const CompoundAssignOperator *CAO) {
5323 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5324 return Error(CAO);
5325
5326 APValue RHS;
5327
5328 // The overall lvalue result is the result of evaluating the LHS.
5329 if (!this->Visit(CAO->getLHS())) {
5330 if (Info.noteFailure())
5331 Evaluate(RHS, this->Info, CAO->getRHS());
5332 return false;
5333 }
5334
5335 if (!Evaluate(RHS, this->Info, CAO->getRHS()))
5336 return false;
5337
5338 return handleCompoundAssignment(
5339 this->Info, CAO,
5340 Result, CAO->getLHS()->getType(), CAO->getComputationLHSType(),
5341 CAO->getOpForCompoundAssignment(CAO->getOpcode()), RHS);
5342}
5343
5344bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) {
5345 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5346 return Error(E);
5347
5348 APValue NewVal;
5349
5350 if (!this->Visit(E->getLHS())) {
5351 if (Info.noteFailure())
5352 Evaluate(NewVal, this->Info, E->getRHS());
5353 return false;
5354 }
5355
5356 if (!Evaluate(NewVal, this->Info, E->getRHS()))
5357 return false;
5358
5359 return handleAssignment(this->Info, E, Result, E->getLHS()->getType(),
5360 NewVal);
5361}
5362
5363//===----------------------------------------------------------------------===//
5364// Pointer Evaluation
5365//===----------------------------------------------------------------------===//
5366
5367/// \brief Attempts to compute the number of bytes available at the pointer
5368/// returned by a function with the alloc_size attribute. Returns true if we
5369/// were successful. Places an unsigned number into `Result`.
5370///
5371/// This expects the given CallExpr to be a call to a function with an
5372/// alloc_size attribute.
5373static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx,
5374 const CallExpr *Call,
5375 llvm::APInt &Result) {
5376 const AllocSizeAttr *AllocSize = getAllocSizeAttr(Call);
5377
5378 // alloc_size args are 1-indexed, 0 means not present.
5379 assert(AllocSize && AllocSize->getElemSizeParam() != 0)((AllocSize && AllocSize->getElemSizeParam() != 0)
? static_cast<void> (0) : __assert_fail ("AllocSize && AllocSize->getElemSizeParam() != 0"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5379, __PRETTY_FUNCTION__))
;
5380 unsigned SizeArgNo = AllocSize->getElemSizeParam() - 1;
5381 unsigned BitsInSizeT = Ctx.getTypeSize(Ctx.getSizeType());
5382 if (Call->getNumArgs() <= SizeArgNo)
5383 return false;
5384
5385 auto EvaluateAsSizeT = [&](const Expr *E, APSInt &Into) {
5386 if (!E->EvaluateAsInt(Into, Ctx, Expr::SE_AllowSideEffects))
5387 return false;
5388 if (Into.isNegative() || !Into.isIntN(BitsInSizeT))
5389 return false;
5390 Into = Into.zextOrSelf(BitsInSizeT);
5391 return true;
5392 };
5393
5394 APSInt SizeOfElem;
5395 if (!EvaluateAsSizeT(Call->getArg(SizeArgNo), SizeOfElem))
5396 return false;
5397
5398 if (!AllocSize->getNumElemsParam()) {
5399 Result = std::move(SizeOfElem);
5400 return true;
5401 }
5402
5403 APSInt NumberOfElems;
5404 // Argument numbers start at 1
5405 unsigned NumArgNo = AllocSize->getNumElemsParam() - 1;
5406 if (!EvaluateAsSizeT(Call->getArg(NumArgNo), NumberOfElems))
5407 return false;
5408
5409 bool Overflow;
5410 llvm::APInt BytesAvailable = SizeOfElem.umul_ov(NumberOfElems, Overflow);
5411 if (Overflow)
5412 return false;
5413
5414 Result = std::move(BytesAvailable);
5415 return true;
5416}
5417
5418/// \brief Convenience function. LVal's base must be a call to an alloc_size
5419/// function.
5420static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx,
5421 const LValue &LVal,
5422 llvm::APInt &Result) {
5423 assert(isBaseAnAllocSizeCall(LVal.getLValueBase()) &&((isBaseAnAllocSizeCall(LVal.getLValueBase()) && "Can't get the size of a non alloc_size function"
) ? static_cast<void> (0) : __assert_fail ("isBaseAnAllocSizeCall(LVal.getLValueBase()) && \"Can't get the size of a non alloc_size function\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5424, __PRETTY_FUNCTION__))
5424 "Can't get the size of a non alloc_size function")((isBaseAnAllocSizeCall(LVal.getLValueBase()) && "Can't get the size of a non alloc_size function"
) ? static_cast<void> (0) : __assert_fail ("isBaseAnAllocSizeCall(LVal.getLValueBase()) && \"Can't get the size of a non alloc_size function\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5424, __PRETTY_FUNCTION__))
;
5425 const auto *Base = LVal.getLValueBase().get<const Expr *>();
5426 const CallExpr *CE = tryUnwrapAllocSizeCall(Base);
5427 return getBytesReturnedByAllocSizeCall(Ctx, CE, Result);
5428}
5429
5430/// \brief Attempts to evaluate the given LValueBase as the result of a call to
5431/// a function with the alloc_size attribute. If it was possible to do so, this
5432/// function will return true, make Result's Base point to said function call,
5433/// and mark Result's Base as invalid.
5434static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base,
5435 LValue &Result) {
5436 if (Base.isNull())
5437 return false;
5438
5439 // Because we do no form of static analysis, we only support const variables.
5440 //
5441 // Additionally, we can't support parameters, nor can we support static
5442 // variables (in the latter case, use-before-assign isn't UB; in the former,
5443 // we have no clue what they'll be assigned to).
5444 const auto *VD =
5445 dyn_cast_or_null<VarDecl>(Base.dyn_cast<const ValueDecl *>());
5446 if (!VD || !VD->isLocalVarDecl() || !VD->getType().isConstQualified())
5447 return false;
5448
5449 const Expr *Init = VD->getAnyInitializer();
5450 if (!Init)
5451 return false;
5452
5453 const Expr *E = Init->IgnoreParens();
5454 if (!tryUnwrapAllocSizeCall(E))
5455 return false;
5456
5457 // Store E instead of E unwrapped so that the type of the LValue's base is
5458 // what the user wanted.
5459 Result.setInvalid(E);
5460
5461 QualType Pointee = E->getType()->castAs<PointerType>()->getPointeeType();
5462 Result.addUnsizedArray(Info, Pointee);
5463 return true;
5464}
5465
5466namespace {
5467class PointerExprEvaluator
5468 : public ExprEvaluatorBase<PointerExprEvaluator> {
5469 LValue &Result;
5470 bool InvalidBaseOK;
5471
5472 bool Success(const Expr *E) {
5473 Result.set(E);
5474 return true;
5475 }
5476
5477 bool evaluateLValue(const Expr *E, LValue &Result) {
5478 return EvaluateLValue(E, Result, Info, InvalidBaseOK);
5479 }
5480
5481 bool evaluatePointer(const Expr *E, LValue &Result) {
5482 return EvaluatePointer(E, Result, Info, InvalidBaseOK);
5483 }
5484
5485 bool visitNonBuiltinCallExpr(const CallExpr *E);
5486public:
5487
5488 PointerExprEvaluator(EvalInfo &info, LValue &Result, bool InvalidBaseOK)
5489 : ExprEvaluatorBaseTy(info), Result(Result),
5490 InvalidBaseOK(InvalidBaseOK) {}
5491
5492 bool Success(const APValue &V, const Expr *E) {
5493 Result.setFrom(Info.Ctx, V);
5494 return true;
5495 }
5496 bool ZeroInitialization(const Expr *E) {
5497 auto Offset = Info.Ctx.getTargetNullPointerValue(E->getType());
5498 Result.set((Expr*)nullptr, 0, false, true, Offset);
5499 return true;
5500 }
5501
5502 bool VisitBinaryOperator(const BinaryOperator *E);
5503 bool VisitCastExpr(const CastExpr* E);
5504 bool VisitUnaryAddrOf(const UnaryOperator *E);
5505 bool VisitObjCStringLiteral(const ObjCStringLiteral *E)
5506 { return Success(E); }
5507 bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
5508 if (Info.noteFailure())
5509 EvaluateIgnoredValue(Info, E->getSubExpr());
5510 return Error(E);
5511 }
5512 bool VisitAddrLabelExpr(const AddrLabelExpr *E)
5513 { return Success(E); }
5514 bool VisitCallExpr(const CallExpr *E);
5515 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
5516 bool VisitBlockExpr(const BlockExpr *E) {
5517 if (!E->getBlockDecl()->hasCaptures())
5518 return Success(E);
5519 return Error(E);
5520 }
5521 bool VisitCXXThisExpr(const CXXThisExpr *E) {
5522 // Can't look at 'this' when checking a potential constant expression.
5523 if (Info.checkingPotentialConstantExpression())
5524 return false;
5525 if (!Info.CurrentCall->This) {
5526 if (Info.getLangOpts().CPlusPlus11)
5527 Info.FFDiag(E, diag::note_constexpr_this) << E->isImplicit();
5528 else
5529 Info.FFDiag(E);
5530 return false;
5531 }
5532 Result = *Info.CurrentCall->This;
5533 // If we are inside a lambda's call operator, the 'this' expression refers
5534 // to the enclosing '*this' object (either by value or reference) which is
5535 // either copied into the closure object's field that represents the '*this'
5536 // or refers to '*this'.
5537 if (isLambdaCallOperator(Info.CurrentCall->Callee)) {
5538 // Update 'Result' to refer to the data member/field of the closure object
5539 // that represents the '*this' capture.
5540 if (!HandleLValueMember(Info, E, Result,
5541 Info.CurrentCall->LambdaThisCaptureField))
5542 return false;
5543 // If we captured '*this' by reference, replace the field with its referent.
5544 if (Info.CurrentCall->LambdaThisCaptureField->getType()
5545 ->isPointerType()) {
5546 APValue RVal;
5547 if (!handleLValueToRValueConversion(Info, E, E->getType(), Result,
5548 RVal))
5549 return false;
5550
5551 Result.setFrom(Info.Ctx, RVal);
5552 }
5553 }
5554 return true;
5555 }
5556
5557 // FIXME: Missing: @protocol, @selector
5558};
5559} // end anonymous namespace
5560
5561static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
5562 bool InvalidBaseOK) {
5563 assert(E->isRValue() && E->getType()->hasPointerRepresentation())((E->isRValue() && E->getType()->hasPointerRepresentation
()) ? static_cast<void> (0) : __assert_fail ("E->isRValue() && E->getType()->hasPointerRepresentation()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5563, __PRETTY_FUNCTION__))
;
5564 return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
5565}
5566
5567bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
5568 if (E->getOpcode() != BO_Add &&
5569 E->getOpcode() != BO_Sub)
5570 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
5571
5572 const Expr *PExp = E->getLHS();
5573 const Expr *IExp = E->getRHS();
5574 if (IExp->getType()->isPointerType())
5575 std::swap(PExp, IExp);
5576
5577 bool EvalPtrOK = evaluatePointer(PExp, Result);
5578 if (!EvalPtrOK && !Info.noteFailure())
5579 return false;
5580
5581 llvm::APSInt Offset;
5582 if (!EvaluateInteger(IExp, Offset, Info) || !EvalPtrOK)
5583 return false;
5584
5585 if (E->getOpcode() == BO_Sub)
5586 negateAsSigned(Offset);
5587
5588 QualType Pointee = PExp->getType()->castAs<PointerType>()->getPointeeType();
5589 return HandleLValueArrayAdjustment(Info, E, Result, Pointee, Offset);
5590}
5591
5592bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
5593 return evaluateLValue(E->getSubExpr(), Result);
5594}
5595
5596bool PointerExprEvaluator::VisitCastExpr(const CastExpr* E) {
5597 const Expr* SubExpr = E->getSubExpr();
5598
5599 switch (E->getCastKind()) {
5600 default:
5601 break;
5602
5603 case CK_BitCast:
5604 case CK_CPointerToObjCPointerCast:
5605 case CK_BlockPointerToObjCPointerCast:
5606 case CK_AnyPointerToBlockPointerCast:
5607 case CK_AddressSpaceConversion:
5608 if (!Visit(SubExpr))
5609 return false;
5610 // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are
5611 // permitted in constant expressions in C++11. Bitcasts from cv void* are
5612 // also static_casts, but we disallow them as a resolution to DR1312.
5613 if (!E->getType()->isVoidPointerType()) {
5614 Result.Designator.setInvalid();
5615 if (SubExpr->getType()->isVoidPointerType())
5616 CCEDiag(E, diag::note_constexpr_invalid_cast)
5617 << 3 << SubExpr->getType();
5618 else
5619 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5620 }
5621 if (E->getCastKind() == CK_AddressSpaceConversion && Result.IsNullPtr)
5622 ZeroInitialization(E);
5623 return true;
5624
5625 case CK_DerivedToBase:
5626 case CK_UncheckedDerivedToBase:
5627 if (!evaluatePointer(E->getSubExpr(), Result))
5628 return false;
5629 if (!Result.Base && Result.Offset.isZero())
5630 return true;
5631
5632 // Now figure out the necessary offset to add to the base LV to get from
5633 // the derived class to the base class.
5634 return HandleLValueBasePath(Info, E, E->getSubExpr()->getType()->
5635 castAs<PointerType>()->getPointeeType(),
5636 Result);
5637
5638 case CK_BaseToDerived:
5639 if (!Visit(E->getSubExpr()))
5640 return false;
5641 if (!Result.Base && Result.Offset.isZero())
5642 return true;
5643 return HandleBaseToDerivedCast(Info, E, Result);
5644
5645 case CK_NullToPointer:
5646 VisitIgnoredValue(E->getSubExpr());
5647 return ZeroInitialization(E);
5648
5649 case CK_IntegralToPointer: {
5650 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5651
5652 APValue Value;
5653 if (!EvaluateIntegerOrLValue(SubExpr, Value, Info))
5654 break;
5655
5656 if (Value.isInt()) {
5657 unsigned Size = Info.Ctx.getTypeSize(E->getType());
5658 uint64_t N = Value.getInt().extOrTrunc(Size).getZExtValue();
5659 Result.Base = (Expr*)nullptr;
5660 Result.InvalidBase = false;
5661 Result.Offset = CharUnits::fromQuantity(N);
5662 Result.CallIndex = 0;
5663 Result.Designator.setInvalid();
5664 Result.IsNullPtr = false;
5665 return true;
5666 } else {
5667 // Cast is of an lvalue, no need to change value.
5668 Result.setFrom(Info.Ctx, Value);
5669 return true;
5670 }
5671 }
5672 case CK_ArrayToPointerDecay:
5673 if (SubExpr->isGLValue()) {
5674 if (!evaluateLValue(SubExpr, Result))
5675 return false;
5676 } else {
5677 Result.set(SubExpr, Info.CurrentCall->Index);
5678 if (!EvaluateInPlace(Info.CurrentCall->createTemporary(SubExpr, false),
5679 Info, Result, SubExpr))
5680 return false;
5681 }
5682 // The result is a pointer to the first element of the array.
5683 if (const ConstantArrayType *CAT
5684 = Info.Ctx.getAsConstantArrayType(SubExpr->getType()))
5685 Result.addArray(Info, E, CAT);
5686 else
5687 Result.Designator.setInvalid();
5688 return true;
5689
5690 case CK_FunctionToPointerDecay:
5691 return evaluateLValue(SubExpr, Result);
5692
5693 case CK_LValueToRValue: {
5694 LValue LVal;
5695 if (!evaluateLValue(E->getSubExpr(), LVal))
5696 return false;
5697
5698 APValue RVal;
5699 // Note, we use the subexpression's type in order to retain cv-qualifiers.
5700 if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
5701 LVal, RVal))
5702 return InvalidBaseOK &&
5703 evaluateLValueAsAllocSize(Info, LVal.Base, Result);
5704 return Success(RVal, E);
5705 }
5706 }
5707
5708 return ExprEvaluatorBaseTy::VisitCastExpr(E);
5709}
5710
5711static CharUnits GetAlignOfType(EvalInfo &Info, QualType T) {
5712 // C++ [expr.alignof]p3:
5713 // When alignof is applied to a reference type, the result is the
5714 // alignment of the referenced type.
5715 if (const ReferenceType *Ref = T->getAs<ReferenceType>())
5716 T = Ref->getPointeeType();
5717
5718 // __alignof is defined to return the preferred alignment.
5719 if (T.getQualifiers().hasUnaligned())
5720 return CharUnits::One();
5721 return Info.Ctx.toCharUnitsFromBits(
5722 Info.Ctx.getPreferredTypeAlign(T.getTypePtr()));
5723}
5724
5725static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E) {
5726 E = E->IgnoreParens();
5727
5728 // The kinds of expressions that we have special-case logic here for
5729 // should be kept up to date with the special checks for those
5730 // expressions in Sema.
5731
5732 // alignof decl is always accepted, even if it doesn't make sense: we default
5733 // to 1 in those cases.
5734 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
5735 return Info.Ctx.getDeclAlign(DRE->getDecl(),
5736 /*RefAsPointee*/true);
5737
5738 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
5739 return Info.Ctx.getDeclAlign(ME->getMemberDecl(),
5740 /*RefAsPointee*/true);
5741
5742 return GetAlignOfType(Info, E->getType());
5743}
5744
5745// To be clear: this happily visits unsupported builtins. Better name welcomed.
5746bool PointerExprEvaluator::visitNonBuiltinCallExpr(const CallExpr *E) {
5747 if (ExprEvaluatorBaseTy::VisitCallExpr(E))
5748 return true;
5749
5750 if (!(InvalidBaseOK && getAllocSizeAttr(E)))
5751 return false;
5752
5753 Result.setInvalid(E);
5754 QualType PointeeTy = E->getType()->castAs<PointerType>()->getPointeeType();
5755 Result.addUnsizedArray(Info, PointeeTy);
5756 return true;
5757}
5758
5759bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) {
5760 if (IsStringLiteralCall(E))
5761 return Success(E);
5762
5763 if (unsigned BuiltinOp = E->getBuiltinCallee())
5764 return VisitBuiltinCallExpr(E, BuiltinOp);
5765
5766 return visitNonBuiltinCallExpr(E);
5767}
5768
5769bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
5770 unsigned BuiltinOp) {
5771 switch (BuiltinOp) {
5772 case Builtin::BI__builtin_addressof:
5773 return evaluateLValue(E->getArg(0), Result);
5774 case Builtin::BI__builtin_assume_aligned: {
5775 // We need to be very careful here because: if the pointer does not have the
5776 // asserted alignment, then the behavior is undefined, and undefined
5777 // behavior is non-constant.
5778 if (!evaluatePointer(E->getArg(0), Result))
5779 return false;
5780
5781 LValue OffsetResult(Result);
5782 APSInt Alignment;
5783 if (!EvaluateInteger(E->getArg(1), Alignment, Info))
5784 return false;
5785 CharUnits Align = CharUnits::fromQuantity(Alignment.getZExtValue());
5786
5787 if (E->getNumArgs() > 2) {
5788 APSInt Offset;
5789 if (!EvaluateInteger(E->getArg(2), Offset, Info))
5790 return false;
5791
5792 int64_t AdditionalOffset = -Offset.getZExtValue();
5793 OffsetResult.Offset += CharUnits::fromQuantity(AdditionalOffset);
5794 }
5795
5796 // If there is a base object, then it must have the correct alignment.
5797 if (OffsetResult.Base) {
5798 CharUnits BaseAlignment;
5799 if (const ValueDecl *VD =
5800 OffsetResult.Base.dyn_cast<const ValueDecl*>()) {
5801 BaseAlignment = Info.Ctx.getDeclAlign(VD);
5802 } else {
5803 BaseAlignment =
5804 GetAlignOfExpr(Info, OffsetResult.Base.get<const Expr*>());
5805 }
5806
5807 if (BaseAlignment < Align) {
5808 Result.Designator.setInvalid();
5809 // FIXME: Add support to Diagnostic for long / long long.
5810 CCEDiag(E->getArg(0),
5811 diag::note_constexpr_baa_insufficient_alignment) << 0
5812 << (unsigned)BaseAlignment.getQuantity()
5813 << (unsigned)Align.getQuantity();
5814 return false;
5815 }
5816 }
5817
5818 // The offset must also have the correct alignment.
5819 if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) {
5820 Result.Designator.setInvalid();
5821
5822 (OffsetResult.Base
5823 ? CCEDiag(E->getArg(0),
5824 diag::note_constexpr_baa_insufficient_alignment) << 1
5825 : CCEDiag(E->getArg(0),
5826 diag::note_constexpr_baa_value_insufficient_alignment))
5827 << (int)OffsetResult.Offset.getQuantity()
5828 << (unsigned)Align.getQuantity();
5829 return false;
5830 }
5831
5832 return true;
5833 }
5834
5835 case Builtin::BIstrchr:
5836 case Builtin::BIwcschr:
5837 case Builtin::BImemchr:
5838 case Builtin::BIwmemchr:
5839 if (Info.getLangOpts().CPlusPlus11)
5840 Info.CCEDiag(E, diag::note_constexpr_invalid_function)
5841 << /*isConstexpr*/0 << /*isConstructor*/0
5842 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
5843 else
5844 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
5845 // Fall through.
5846 case Builtin::BI__builtin_strchr:
5847 case Builtin::BI__builtin_wcschr:
5848 case Builtin::BI__builtin_memchr:
5849 case Builtin::BI__builtin_char_memchr:
5850 case Builtin::BI__builtin_wmemchr: {
5851 if (!Visit(E->getArg(0)))
5852 return false;
5853 APSInt Desired;
5854 if (!EvaluateInteger(E->getArg(1), Desired, Info))
5855 return false;
5856 uint64_t MaxLength = uint64_t(-1);
5857 if (BuiltinOp != Builtin::BIstrchr &&
5858 BuiltinOp != Builtin::BIwcschr &&
5859 BuiltinOp != Builtin::BI__builtin_strchr &&
5860 BuiltinOp != Builtin::BI__builtin_wcschr) {
5861 APSInt N;
5862 if (!EvaluateInteger(E->getArg(2), N, Info))
5863 return false;
5864 MaxLength = N.getExtValue();
5865 }
5866
5867 QualType CharTy = E->getArg(0)->getType()->getPointeeType();
5868
5869 // Figure out what value we're actually looking for (after converting to
5870 // the corresponding unsigned type if necessary).
5871 uint64_t DesiredVal;
5872 bool StopAtNull = false;
5873 switch (BuiltinOp) {
5874 case Builtin::BIstrchr:
5875 case Builtin::BI__builtin_strchr:
5876 // strchr compares directly to the passed integer, and therefore
5877 // always fails if given an int that is not a char.
5878 if (!APSInt::isSameValue(HandleIntToIntCast(Info, E, CharTy,
5879 E->getArg(1)->getType(),
5880 Desired),
5881 Desired))
5882 return ZeroInitialization(E);
5883 StopAtNull = true;
5884 // Fall through.
5885 case Builtin::BImemchr:
5886 case Builtin::BI__builtin_memchr:
5887 case Builtin::BI__builtin_char_memchr:
5888 // memchr compares by converting both sides to unsigned char. That's also
5889 // correct for strchr if we get this far (to cope with plain char being
5890 // unsigned in the strchr case).
5891 DesiredVal = Desired.trunc(Info.Ctx.getCharWidth()).getZExtValue();
5892 break;
5893
5894 case Builtin::BIwcschr:
5895 case Builtin::BI__builtin_wcschr:
5896 StopAtNull = true;
5897 // Fall through.
5898 case Builtin::BIwmemchr:
5899 case Builtin::BI__builtin_wmemchr:
5900 // wcschr and wmemchr are given a wchar_t to look for. Just use it.
5901 DesiredVal = Desired.getZExtValue();
5902 break;
5903 }
5904
5905 for (; MaxLength; --MaxLength) {
5906 APValue Char;
5907 if (!handleLValueToRValueConversion(Info, E, CharTy, Result, Char) ||
5908 !Char.isInt())
5909 return false;
5910 if (Char.getInt().getZExtValue() == DesiredVal)
5911 return true;
5912 if (StopAtNull && !Char.getInt())
5913 break;
5914 if (!HandleLValueArrayAdjustment(Info, E, Result, CharTy, 1))
5915 return false;
5916 }
5917 // Not found: return nullptr.
5918 return ZeroInitialization(E);
5919 }
5920
5921 default:
5922 return visitNonBuiltinCallExpr(E);
5923 }
5924}
5925
5926//===----------------------------------------------------------------------===//
5927// Member Pointer Evaluation
5928//===----------------------------------------------------------------------===//
5929
5930namespace {
5931class MemberPointerExprEvaluator
5932 : public ExprEvaluatorBase<MemberPointerExprEvaluator> {
5933 MemberPtr &Result;
5934
5935 bool Success(const ValueDecl *D) {
5936 Result = MemberPtr(D);
5937 return true;
5938 }
5939public:
5940
5941 MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result)
5942 : ExprEvaluatorBaseTy(Info), Result(Result) {}
5943
5944 bool Success(const APValue &V, const Expr *E) {
5945 Result.setFrom(V);
5946 return true;
5947 }
5948 bool ZeroInitialization(const Expr *E) {
5949 return Success((const ValueDecl*)nullptr);
5950 }
5951
5952 bool VisitCastExpr(const CastExpr *E);
5953 bool VisitUnaryAddrOf(const UnaryOperator *E);
5954};
5955} // end anonymous namespace
5956
5957static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
5958 EvalInfo &Info) {
5959 assert(E->isRValue() && E->getType()->isMemberPointerType())((E->isRValue() && E->getType()->isMemberPointerType
()) ? static_cast<void> (0) : __assert_fail ("E->isRValue() && E->getType()->isMemberPointerType()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5959, __PRETTY_FUNCTION__))
;
5960 return MemberPointerExprEvaluator(Info, Result).Visit(E);
5961}
5962
5963bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
5964 switch (E->getCastKind()) {
5965 default:
5966 return ExprEvaluatorBaseTy::VisitCastExpr(E);
5967
5968 case CK_NullToMemberPointer:
5969 VisitIgnoredValue(E->getSubExpr());
5970 return ZeroInitialization(E);
5971
5972 case CK_BaseToDerivedMemberPointer: {
5973 if (!Visit(E->getSubExpr()))
5974 return false;
5975 if (E->path_empty())
5976 return true;
5977 // Base-to-derived member pointer casts store the path in derived-to-base
5978 // order, so iterate backwards. The CXXBaseSpecifier also provides us with
5979 // the wrong end of the derived->base arc, so stagger the path by one class.
5980 typedef std::reverse_iterator<CastExpr::path_const_iterator> ReverseIter;
5981 for (ReverseIter PathI(E->path_end() - 1), PathE(E->path_begin());
5982 PathI != PathE; ++PathI) {
5983 assert(!(*PathI)->isVirtual() && "memptr cast through vbase")((!(*PathI)->isVirtual() && "memptr cast through vbase"
) ? static_cast<void> (0) : __assert_fail ("!(*PathI)->isVirtual() && \"memptr cast through vbase\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5983, __PRETTY_FUNCTION__))
;
5984 const CXXRecordDecl *Derived = (*PathI)->getType()->getAsCXXRecordDecl();
5985 if (!Result.castToDerived(Derived))
5986 return Error(E);
5987 }
5988 const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass();
5989 if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl()))
5990 return Error(E);
5991 return true;
5992 }
5993
5994 case CK_DerivedToBaseMemberPointer:
5995 if (!Visit(E->getSubExpr()))
5996 return false;
5997 for (CastExpr::path_const_iterator PathI = E->path_begin(),
5998 PathE = E->path_end(); PathI != PathE; ++PathI) {
5999 assert(!(*PathI)->isVirtual() && "memptr cast through vbase")((!(*PathI)->isVirtual() && "memptr cast through vbase"
) ? static_cast<void> (0) : __assert_fail ("!(*PathI)->isVirtual() && \"memptr cast through vbase\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 5999, __PRETTY_FUNCTION__))
;
6000 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
6001 if (!Result.castToBase(Base))
6002 return Error(E);
6003 }
6004 return true;
6005 }
6006}
6007
6008bool MemberPointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
6009 // C++11 [expr.unary.op]p3 has very strict rules on how the address of a
6010 // member can be formed.
6011 return Success(cast<DeclRefExpr>(E->getSubExpr())->getDecl());
6012}
6013
6014//===----------------------------------------------------------------------===//
6015// Record Evaluation
6016//===----------------------------------------------------------------------===//
6017
6018namespace {
6019 class RecordExprEvaluator
6020 : public ExprEvaluatorBase<RecordExprEvaluator> {
6021 const LValue &This;
6022 APValue &Result;
6023 public:
6024
6025 RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result)
6026 : ExprEvaluatorBaseTy(info), This(This), Result(Result) {}
6027
6028 bool Success(const APValue &V, const Expr *E) {
6029 Result = V;
6030 return true;
6031 }
6032 bool ZeroInitialization(const Expr *E) {
6033 return ZeroInitialization(E, E->getType());
6034 }
6035 bool ZeroInitialization(const Expr *E, QualType T);
6036
6037 bool VisitCallExpr(const CallExpr *E) {
6038 return handleCallExpr(E, Result, &This);
6039 }
6040 bool VisitCastExpr(const CastExpr *E);
6041 bool VisitInitListExpr(const InitListExpr *E);
6042 bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
6043 return VisitCXXConstructExpr(E, E->getType());
6044 }
6045 bool VisitLambdaExpr(const LambdaExpr *E);
6046 bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
6047 bool VisitCXXConstructExpr(const CXXConstructExpr *E, QualType T);
6048 bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E);
6049 };
6050}
6051
6052/// Perform zero-initialization on an object of non-union class type.
6053/// C++11 [dcl.init]p5:
6054/// To zero-initialize an object or reference of type T means:
6055/// [...]
6056/// -- if T is a (possibly cv-qualified) non-union class type,
6057/// each non-static data member and each base-class subobject is
6058/// zero-initialized
6059static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E,
6060 const RecordDecl *RD,
6061 const LValue &This, APValue &Result) {
6062 assert(!RD->isUnion() && "Expected non-union class type")((!RD->isUnion() && "Expected non-union class type"
) ? static_cast<void> (0) : __assert_fail ("!RD->isUnion() && \"Expected non-union class type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6062, __PRETTY_FUNCTION__))
;
6063 const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
6064 Result = APValue(APValue::UninitStruct(), CD ? CD->getNumBases() : 0,
6065 std::distance(RD->field_begin(), RD->field_end()));
6066
6067 if (RD->isInvalidDecl()) return false;
6068 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6069
6070 if (CD) {
6071 unsigned Index = 0;
6072 for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(),
6073 End = CD->bases_end(); I != End; ++I, ++Index) {
6074 const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl();
6075 LValue Subobject = This;
6076 if (!HandleLValueDirectBase(Info, E, Subobject, CD, Base, &Layout))
6077 return false;
6078 if (!HandleClassZeroInitialization(Info, E, Base, Subobject,
6079 Result.getStructBase(Index)))
6080 return false;
6081 }
6082 }
6083
6084 for (const auto *I : RD->fields()) {
6085 // -- if T is a reference type, no initialization is performed.
6086 if (I->getType()->isReferenceType())
6087 continue;
6088
6089 LValue Subobject = This;
6090 if (!HandleLValueMember(Info, E, Subobject, I, &Layout))
6091 return false;
6092
6093 ImplicitValueInitExpr VIE(I->getType());
6094 if (!EvaluateInPlace(
6095 Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE))
6096 return false;
6097 }
6098
6099 return true;
6100}
6101
6102bool RecordExprEvaluator::ZeroInitialization(const Expr *E, QualType T) {
6103 const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
6104 if (RD->isInvalidDecl()) return false;
6105 if (RD->isUnion()) {
6106 // C++11 [dcl.init]p5: If T is a (possibly cv-qualified) union type, the
6107 // object's first non-static named data member is zero-initialized
6108 RecordDecl::field_iterator I = RD->field_begin();
6109 if (I == RD->field_end()) {
6110 Result = APValue((const FieldDecl*)nullptr);
6111 return true;
6112 }
6113
6114 LValue Subobject = This;
6115 if (!HandleLValueMember(Info, E, Subobject, *I))
6116 return false;
6117 Result = APValue(*I);
6118 ImplicitValueInitExpr VIE(I->getType());
6119 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE);
6120 }
6121
6122 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->getNumVBases()) {
6123 Info.FFDiag(E, diag::note_constexpr_virtual_base) << RD;
6124 return false;
6125 }
6126
6127 return HandleClassZeroInitialization(Info, E, RD, This, Result);
6128}
6129
6130bool RecordExprEvaluator::VisitCastExpr(const CastExpr *E) {
6131 switch (E->getCastKind()) {
6132 default:
6133 return ExprEvaluatorBaseTy::VisitCastExpr(E);
6134
6135 case CK_ConstructorConversion:
6136 return Visit(E->getSubExpr());
6137
6138 case CK_DerivedToBase:
6139 case CK_UncheckedDerivedToBase: {
6140 APValue DerivedObject;
6141 if (!Evaluate(DerivedObject, Info, E->getSubExpr()))
6142 return false;
6143 if (!DerivedObject.isStruct())
6144 return Error(E->getSubExpr());
6145
6146 // Derived-to-base rvalue conversion: just slice off the derived part.
6147 APValue *Value = &DerivedObject;
6148 const CXXRecordDecl *RD = E->getSubExpr()->getType()->getAsCXXRecordDecl();
6149 for (CastExpr::path_const_iterator PathI = E->path_begin(),
6150 PathE = E->path_end(); PathI != PathE; ++PathI) {
6151 assert(!(*PathI)->isVirtual() && "record rvalue with virtual base")((!(*PathI)->isVirtual() && "record rvalue with virtual base"
) ? static_cast<void> (0) : __assert_fail ("!(*PathI)->isVirtual() && \"record rvalue with virtual base\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6151, __PRETTY_FUNCTION__))
;
6152 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
6153 Value = &Value->getStructBase(getBaseIndex(RD, Base));
6154 RD = Base;
6155 }
6156 Result = *Value;
6157 return true;
6158 }
6159 }
6160}
6161
6162bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
6163 if (E->isTransparent())
6164 return Visit(E->getInit(0));
6165
6166 const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl();
6167 if (RD->isInvalidDecl()) return false;
6168 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6169
6170 if (RD->isUnion()) {
6171 const FieldDecl *Field = E->getInitializedFieldInUnion();
6172 Result = APValue(Field);
6173 if (!Field)
6174 return true;
6175
6176 // If the initializer list for a union does not contain any elements, the
6177 // first element of the union is value-initialized.
6178 // FIXME: The element should be initialized from an initializer list.
6179 // Is this difference ever observable for initializer lists which
6180 // we don't build?
6181 ImplicitValueInitExpr VIE(Field->getType());
6182 const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE;
6183
6184 LValue Subobject = This;
6185 if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout))
6186 return false;
6187
6188 // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
6189 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
6190 isa<CXXDefaultInitExpr>(InitExpr));
6191
6192 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr);
6193 }
6194
6195 auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
6196 if (Result.isUninit())
6197 Result = APValue(APValue::UninitStruct(), CXXRD ? CXXRD->getNumBases() : 0,
6198 std::distance(RD->field_begin(), RD->field_end()));
6199 unsigned ElementNo = 0;
6200 bool Success = true;
6201
6202 // Initialize base classes.
6203 if (CXXRD) {
6204 for (const auto &Base : CXXRD->bases()) {
6205 assert(ElementNo < E->getNumInits() && "missing init for base class")((ElementNo < E->getNumInits() && "missing init for base class"
) ? static_cast<void> (0) : __assert_fail ("ElementNo < E->getNumInits() && \"missing init for base class\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6205, __PRETTY_FUNCTION__))
;
6206 const Expr *Init = E->getInit(ElementNo);
6207
6208 LValue Subobject = This;
6209 if (!HandleLValueBase(Info, Init, Subobject, CXXRD, &Base))
6210 return false;
6211
6212 APValue &FieldVal = Result.getStructBase(ElementNo);
6213 if (!EvaluateInPlace(FieldVal, Info, Subobject, Init)) {
6214 if (!Info.noteFailure())
6215 return false;
6216 Success = false;
6217 }
6218 ++ElementNo;
6219 }
6220 }
6221
6222 // Initialize members.
6223 for (const auto *Field : RD->fields()) {
6224 // Anonymous bit-fields are not considered members of the class for
6225 // purposes of aggregate initialization.
6226 if (Field->isUnnamedBitfield())
6227 continue;
6228
6229 LValue Subobject = This;
6230
6231 bool HaveInit = ElementNo < E->getNumInits();
6232
6233 // FIXME: Diagnostics here should point to the end of the initializer
6234 // list, not the start.
6235 if (!HandleLValueMember(Info, HaveInit ? E->getInit(ElementNo) : E,
6236 Subobject, Field, &Layout))
6237 return false;
6238
6239 // Perform an implicit value-initialization for members beyond the end of
6240 // the initializer list.
6241 ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType());
6242 const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE;
6243 if (Init->isValueDependent()) {
6244 Success = false;
6245 continue;
6246 }
6247
6248 // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
6249 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
6250 isa<CXXDefaultInitExpr>(Init));
6251
6252 APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
6253 if (!EvaluateInPlace(FieldVal, Info, Subobject, Init) ||
6254 (Field->isBitField() && !truncateBitfieldValue(Info, Init,
6255 FieldVal, Field))) {
6256 if (!Info.noteFailure())
6257 return false;
6258 Success = false;
6259 }
6260 }
6261
6262 return Success;
6263}
6264
6265bool RecordExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
6266 QualType T) {
6267 // Note that E's type is not necessarily the type of our class here; we might
6268 // be initializing an array element instead.
6269 const CXXConstructorDecl *FD = E->getConstructor();
6270 if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl()) return false;
6271
6272 bool ZeroInit = E->requiresZeroInitialization();
6273 if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) {
6274 // If we've already performed zero-initialization, we're already done.
6275 if (!Result.isUninit())
6276 return true;
6277
6278 // We can get here in two different ways:
6279 // 1) We're performing value-initialization, and should zero-initialize
6280 // the object, or
6281 // 2) We're performing default-initialization of an object with a trivial
6282 // constexpr default constructor, in which case we should start the
6283 // lifetimes of all the base subobjects (there can be no data member
6284 // subobjects in this case) per [basic.life]p1.
6285 // Either way, ZeroInitialization is appropriate.
6286 return ZeroInitialization(E, T);
6287 }
6288
6289 const FunctionDecl *Definition = nullptr;
6290 auto Body = FD->getBody(Definition);
6291
6292 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
6293 return false;
6294
6295 // Avoid materializing a temporary for an elidable copy/move constructor.
6296 if (E->isElidable() && !ZeroInit)
6297 if (const MaterializeTemporaryExpr *ME
6298 = dyn_cast<MaterializeTemporaryExpr>(E->getArg(0)))
6299 return Visit(ME->GetTemporaryExpr());
6300
6301 if (ZeroInit && !ZeroInitialization(E, T))
6302 return false;
6303
6304 auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
6305 return HandleConstructorCall(E, This, Args,
6306 cast<CXXConstructorDecl>(Definition), Info,
6307 Result);
6308}
6309
6310bool RecordExprEvaluator::VisitCXXInheritedCtorInitExpr(
6311 const CXXInheritedCtorInitExpr *E) {
6312 if (!Info.CurrentCall) {
6313 assert(Info.checkingPotentialConstantExpression())((Info.checkingPotentialConstantExpression()) ? static_cast<
void> (0) : __assert_fail ("Info.checkingPotentialConstantExpression()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6313, __PRETTY_FUNCTION__))
;
6314 return false;
6315 }
6316
6317 const CXXConstructorDecl *FD = E->getConstructor();
6318 if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl())
6319 return false;
6320
6321 const FunctionDecl *Definition = nullptr;
6322 auto Body = FD->getBody(Definition);
6323
6324 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
6325 return false;
6326
6327 return HandleConstructorCall(E, This, Info.CurrentCall->Arguments,
6328 cast<CXXConstructorDecl>(Definition), Info,
6329 Result);
6330}
6331
6332bool RecordExprEvaluator::VisitCXXStdInitializerListExpr(
6333 const CXXStdInitializerListExpr *E) {
6334 const ConstantArrayType *ArrayType =
6335 Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
6336
6337 LValue Array;
6338 if (!EvaluateLValue(E->getSubExpr(), Array, Info))
6339 return false;
6340
6341 // Get a pointer to the first element of the array.
6342 Array.addArray(Info, E, ArrayType);
6343
6344 // FIXME: Perform the checks on the field types in SemaInit.
6345 RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
6346 RecordDecl::field_iterator Field = Record->field_begin();
6347 if (Field == Record->field_end())
6348 return Error(E);
6349
6350 // Start pointer.
6351 if (!Field->getType()->isPointerType() ||
6352 !Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
6353 ArrayType->getElementType()))
6354 return Error(E);
6355
6356 // FIXME: What if the initializer_list type has base classes, etc?
6357 Result = APValue(APValue::UninitStruct(), 0, 2);
6358 Array.moveInto(Result.getStructField(0));
6359
6360 if (++Field == Record->field_end())
6361 return Error(E);
6362
6363 if (Field->getType()->isPointerType() &&
6364 Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
6365 ArrayType->getElementType())) {
6366 // End pointer.
6367 if (!HandleLValueArrayAdjustment(Info, E, Array,
6368 ArrayType->getElementType(),
6369 ArrayType->getSize().getZExtValue()))
6370 return false;
6371 Array.moveInto(Result.getStructField(1));
6372 } else if (Info.Ctx.hasSameType(Field->getType(), Info.Ctx.getSizeType()))
6373 // Length.
6374 Result.getStructField(1) = APValue(APSInt(ArrayType->getSize()));
6375 else
6376 return Error(E);
6377
6378 if (++Field != Record->field_end())
6379 return Error(E);
6380
6381 return true;
6382}
6383
6384bool RecordExprEvaluator::VisitLambdaExpr(const LambdaExpr *E) {
6385 const CXXRecordDecl *ClosureClass = E->getLambdaClass();
6386 if (ClosureClass->isInvalidDecl()) return false;
6387
6388 if (Info.checkingPotentialConstantExpression()) return true;
6389
6390 const size_t NumFields =
6391 std::distance(ClosureClass->field_begin(), ClosureClass->field_end());
6392
6393 assert(NumFields == (size_t)std::distance(E->capture_init_begin(),((NumFields == (size_t)std::distance(E->capture_init_begin
(), E->capture_init_end()) && "The number of lambda capture initializers should equal the number of "
"fields within the closure type") ? static_cast<void> (
0) : __assert_fail ("NumFields == (size_t)std::distance(E->capture_init_begin(), E->capture_init_end()) && \"The number of lambda capture initializers should equal the number of \" \"fields within the closure type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6396, __PRETTY_FUNCTION__))
6394 E->capture_init_end()) &&((NumFields == (size_t)std::distance(E->capture_init_begin
(), E->capture_init_end()) && "The number of lambda capture initializers should equal the number of "
"fields within the closure type") ? static_cast<void> (
0) : __assert_fail ("NumFields == (size_t)std::distance(E->capture_init_begin(), E->capture_init_end()) && \"The number of lambda capture initializers should equal the number of \" \"fields within the closure type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6396, __PRETTY_FUNCTION__))
6395 "The number of lambda capture initializers should equal the number of "((NumFields == (size_t)std::distance(E->capture_init_begin
(), E->capture_init_end()) && "The number of lambda capture initializers should equal the number of "
"fields within the closure type") ? static_cast<void> (
0) : __assert_fail ("NumFields == (size_t)std::distance(E->capture_init_begin(), E->capture_init_end()) && \"The number of lambda capture initializers should equal the number of \" \"fields within the closure type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6396, __PRETTY_FUNCTION__))
6396 "fields within the closure type")((NumFields == (size_t)std::distance(E->capture_init_begin
(), E->capture_init_end()) && "The number of lambda capture initializers should equal the number of "
"fields within the closure type") ? static_cast<void> (
0) : __assert_fail ("NumFields == (size_t)std::distance(E->capture_init_begin(), E->capture_init_end()) && \"The number of lambda capture initializers should equal the number of \" \"fields within the closure type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6396, __PRETTY_FUNCTION__))
;
6397
6398 Result = APValue(APValue::UninitStruct(), /*NumBases*/0, NumFields);
6399 // Iterate through all the lambda's closure object's fields and initialize
6400 // them.
6401 auto *CaptureInitIt = E->capture_init_begin();
6402 const LambdaCapture *CaptureIt = ClosureClass->captures_begin();
6403 bool Success = true;
6404 for (const auto *Field : ClosureClass->fields()) {
6405 assert(CaptureInitIt != E->capture_init_end())((CaptureInitIt != E->capture_init_end()) ? static_cast<
void> (0) : __assert_fail ("CaptureInitIt != E->capture_init_end()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6405, __PRETTY_FUNCTION__))
;
6406 // Get the initializer for this field
6407 Expr *const CurFieldInit = *CaptureInitIt++;
6408
6409 // If there is no initializer, either this is a VLA or an error has
6410 // occurred.
6411 if (!CurFieldInit)
6412 return Error(E);
6413
6414 APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
6415 if (!EvaluateInPlace(FieldVal, Info, This, CurFieldInit)) {
6416 if (!Info.keepEvaluatingAfterFailure())
6417 return false;
6418 Success = false;
6419 }
6420 ++CaptureIt;
6421 }
6422 return Success;
6423}
6424
6425static bool EvaluateRecord(const Expr *E, const LValue &This,
6426 APValue &Result, EvalInfo &Info) {
6427 assert(E->isRValue() && E->getType()->isRecordType() &&((E->isRValue() && E->getType()->isRecordType
() && "can't evaluate expression as a record rvalue")
? static_cast<void> (0) : __assert_fail ("E->isRValue() && E->getType()->isRecordType() && \"can't evaluate expression as a record rvalue\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6428, __PRETTY_FUNCTION__))
6428 "can't evaluate expression as a record rvalue")((E->isRValue() && E->getType()->isRecordType
() && "can't evaluate expression as a record rvalue")
? static_cast<void> (0) : __assert_fail ("E->isRValue() && E->getType()->isRecordType() && \"can't evaluate expression as a record rvalue\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6428, __PRETTY_FUNCTION__))
;
6429 return RecordExprEvaluator(Info, This, Result).Visit(E);
6430}
6431
6432//===----------------------------------------------------------------------===//
6433// Temporary Evaluation
6434//
6435// Temporaries are represented in the AST as rvalues, but generally behave like
6436// lvalues. The full-object of which the temporary is a subobject is implicitly
6437// materialized so that a reference can bind to it.
6438//===----------------------------------------------------------------------===//
6439namespace {
6440class TemporaryExprEvaluator
6441 : public LValueExprEvaluatorBase<TemporaryExprEvaluator> {
6442public:
6443 TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) :
6444 LValueExprEvaluatorBaseTy(Info, Result, false) {}
6445
6446 /// Visit an expression which constructs the value of this temporary.
6447 bool VisitConstructExpr(const Expr *E) {
6448 Result.set(E, Info.CurrentCall->Index);
6449 return EvaluateInPlace(Info.CurrentCall->createTemporary(E, false),
6450 Info, Result, E);
6451 }
6452
6453 bool VisitCastExpr(const CastExpr *E) {
6454 switch (E->getCastKind()) {
6455 default:
6456 return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
6457
6458 case CK_ConstructorConversion:
6459 return VisitConstructExpr(E->getSubExpr());
6460 }
6461 }
6462 bool VisitInitListExpr(const InitListExpr *E) {
6463 return VisitConstructExpr(E);
6464 }
6465 bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
6466 return VisitConstructExpr(E);
6467 }
6468 bool VisitCallExpr(const CallExpr *E) {
6469 return VisitConstructExpr(E);
6470 }
6471 bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E) {
6472 return VisitConstructExpr(E);
6473 }
6474 bool VisitLambdaExpr(const LambdaExpr *E) {
6475 return VisitConstructExpr(E);
6476 }
6477};
6478} // end anonymous namespace
6479
6480/// Evaluate an expression of record type as a temporary.
6481static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
6482 assert(E->isRValue() && E->getType()->isRecordType())((E->isRValue() && E->getType()->isRecordType
()) ? static_cast<void> (0) : __assert_fail ("E->isRValue() && E->getType()->isRecordType()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6482, __PRETTY_FUNCTION__))
;
6483 return TemporaryExprEvaluator(Info, Result).Visit(E);
6484}
6485
6486//===----------------------------------------------------------------------===//
6487// Vector Evaluation
6488//===----------------------------------------------------------------------===//
6489
6490namespace {
6491 class VectorExprEvaluator
6492 : public ExprEvaluatorBase<VectorExprEvaluator> {
6493 APValue &Result;
6494 public:
6495
6496 VectorExprEvaluator(EvalInfo &info, APValue &Result)
6497 : ExprEvaluatorBaseTy(info), Result(Result) {}
6498
6499 bool Success(ArrayRef<APValue> V, const Expr *E) {
6500 assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements())((V.size() == E->getType()->castAs<VectorType>()->
getNumElements()) ? static_cast<void> (0) : __assert_fail
("V.size() == E->getType()->castAs<VectorType>()->getNumElements()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6500, __PRETTY_FUNCTION__))
;
6501 // FIXME: remove this APValue copy.
6502 Result = APValue(V.data(), V.size());
6503 return true;
6504 }
6505 bool Success(const APValue &V, const Expr *E) {
6506 assert(V.isVector())((V.isVector()) ? static_cast<void> (0) : __assert_fail
("V.isVector()", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6506, __PRETTY_FUNCTION__))
;
6507 Result = V;
6508 return true;
6509 }
6510 bool ZeroInitialization(const Expr *E);
6511
6512 bool VisitUnaryReal(const UnaryOperator *E)
6513 { return Visit(E->getSubExpr()); }
6514 bool VisitCastExpr(const CastExpr* E);
6515 bool VisitInitListExpr(const InitListExpr *E);
6516 bool VisitUnaryImag(const UnaryOperator *E);
6517 // FIXME: Missing: unary -, unary ~, binary add/sub/mul/div,
6518 // binary comparisons, binary and/or/xor,
6519 // shufflevector, ExtVectorElementExpr
6520 };
6521} // end anonymous namespace
6522
6523static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
6524 assert(E->isRValue() && E->getType()->isVectorType() &&"not a vector rvalue")((E->isRValue() && E->getType()->isVectorType
() &&"not a vector rvalue") ? static_cast<void>
(0) : __assert_fail ("E->isRValue() && E->getType()->isVectorType() &&\"not a vector rvalue\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6524, __PRETTY_FUNCTION__))
;
6525 return VectorExprEvaluator(Info, Result).Visit(E);
6526}
6527
6528bool VectorExprEvaluator::VisitCastExpr(const CastExpr *E) {
6529 const VectorType *VTy = E->getType()->castAs<VectorType>();
6530 unsigned NElts = VTy->getNumElements();
6531
6532 const Expr *SE = E->getSubExpr();
6533 QualType SETy = SE->getType();
6534
6535 switch (E->getCastKind()) {
6536 case CK_VectorSplat: {
6537 APValue Val = APValue();
6538 if (SETy->isIntegerType()) {
6539 APSInt IntResult;
6540 if (!EvaluateInteger(SE, IntResult, Info))
6541 return false;
6542 Val = APValue(std::move(IntResult));
6543 } else if (SETy->isRealFloatingType()) {
6544 APFloat FloatResult(0.0);
6545 if (!EvaluateFloat(SE, FloatResult, Info))
6546 return false;
6547 Val = APValue(std::move(FloatResult));
6548 } else {
6549 return Error(E);
6550 }
6551
6552 // Splat and create vector APValue.
6553 SmallVector<APValue, 4> Elts(NElts, Val);
6554 return Success(Elts, E);
6555 }
6556 case CK_BitCast: {
6557 // Evaluate the operand into an APInt we can extract from.
6558 llvm::APInt SValInt;
6559 if (!EvalAndBitcastToAPInt(Info, SE, SValInt))
6560 return false;
6561 // Extract the elements
6562 QualType EltTy = VTy->getElementType();
6563 unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
6564 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
6565 SmallVector<APValue, 4> Elts;
6566 if (EltTy->isRealFloatingType()) {
6567 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy);
6568 unsigned FloatEltSize = EltSize;
6569 if (&Sem == &APFloat::x87DoubleExtended())
6570 FloatEltSize = 80;
6571 for (unsigned i = 0; i < NElts; i++) {
6572 llvm::APInt Elt;
6573 if (BigEndian)
6574 Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize);
6575 else
6576 Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize);
6577 Elts.push_back(APValue(APFloat(Sem, Elt)));
6578 }
6579 } else if (EltTy->isIntegerType()) {
6580 for (unsigned i = 0; i < NElts; i++) {
6581 llvm::APInt Elt;
6582 if (BigEndian)
6583 Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize);
6584 else
6585 Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize);
6586 Elts.push_back(APValue(APSInt(Elt, EltTy->isSignedIntegerType())));
6587 }
6588 } else {
6589 return Error(E);
6590 }
6591 return Success(Elts, E);
6592 }
6593 default:
6594 return ExprEvaluatorBaseTy::VisitCastExpr(E);
6595 }
6596}
6597
6598bool
6599VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
6600 const VectorType *VT = E->getType()->castAs<VectorType>();
6601 unsigned NumInits = E->getNumInits();
6602 unsigned NumElements = VT->getNumElements();
6603
6604 QualType EltTy = VT->getElementType();
6605 SmallVector<APValue, 4> Elements;
6606
6607 // The number of initializers can be less than the number of
6608 // vector elements. For OpenCL, this can be due to nested vector
6609 // initialization. For GCC compatibility, missing trailing elements
6610 // should be initialized with zeroes.
6611 unsigned CountInits = 0, CountElts = 0;
6612 while (CountElts < NumElements) {
6613 // Handle nested vector initialization.
6614 if (CountInits < NumInits
6615 && E->getInit(CountInits)->getType()->isVectorType()) {
6616 APValue v;
6617 if (!EvaluateVector(E->getInit(CountInits), v, Info))
6618 return Error(E);
6619 unsigned vlen = v.getVectorLength();
6620 for (unsigned j = 0; j < vlen; j++)
6621 Elements.push_back(v.getVectorElt(j));
6622 CountElts += vlen;
6623 } else if (EltTy->isIntegerType()) {
6624 llvm::APSInt sInt(32);
6625 if (CountInits < NumInits) {
6626 if (!EvaluateInteger(E->getInit(CountInits), sInt, Info))
6627 return false;
6628 } else // trailing integer zero.
6629 sInt = Info.Ctx.MakeIntValue(0, EltTy);
6630 Elements.push_back(APValue(sInt));
6631 CountElts++;
6632 } else {
6633 llvm::APFloat f(0.0);
6634 if (CountInits < NumInits) {
6635 if (!EvaluateFloat(E->getInit(CountInits), f, Info))
6636 return false;
6637 } else // trailing float zero.
6638 f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
6639 Elements.push_back(APValue(f));
6640 CountElts++;
6641 }
6642 CountInits++;
6643 }
6644 return Success(Elements, E);
6645}
6646
6647bool
6648VectorExprEvaluator::ZeroInitialization(const Expr *E) {
6649 const VectorType *VT = E->getType()->getAs<VectorType>();
6650 QualType EltTy = VT->getElementType();
6651 APValue ZeroElement;
6652 if (EltTy->isIntegerType())
6653 ZeroElement = APValue(Info.Ctx.MakeIntValue(0, EltTy));
6654 else
6655 ZeroElement =
6656 APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
6657
6658 SmallVector<APValue, 4> Elements(VT->getNumElements(), ZeroElement);
6659 return Success(Elements, E);
6660}
6661
6662bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
6663 VisitIgnoredValue(E->getSubExpr());
6664 return ZeroInitialization(E);
6665}
6666
6667//===----------------------------------------------------------------------===//
6668// Array Evaluation
6669//===----------------------------------------------------------------------===//
6670
6671namespace {
6672 class ArrayExprEvaluator
6673 : public ExprEvaluatorBase<ArrayExprEvaluator> {
6674 const LValue &This;
6675 APValue &Result;
6676 public:
6677
6678 ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result)
6679 : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
6680
6681 bool Success(const APValue &V, const Expr *E) {
6682 assert((V.isArray() || V.isLValue()) &&(((V.isArray() || V.isLValue()) && "expected array or string literal"
) ? static_cast<void> (0) : __assert_fail ("(V.isArray() || V.isLValue()) && \"expected array or string literal\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6683, __PRETTY_FUNCTION__))
6683 "expected array or string literal")(((V.isArray() || V.isLValue()) && "expected array or string literal"
) ? static_cast<void> (0) : __assert_fail ("(V.isArray() || V.isLValue()) && \"expected array or string literal\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6683, __PRETTY_FUNCTION__))
;
6684 Result = V;
6685 return true;
6686 }
6687
6688 bool ZeroInitialization(const Expr *E) {
6689 const ConstantArrayType *CAT =
6690 Info.Ctx.getAsConstantArrayType(E->getType());
6691 if (!CAT)
6692 return Error(E);
6693
6694 Result = APValue(APValue::UninitArray(), 0,
6695 CAT->getSize().getZExtValue());
6696 if (!Result.hasArrayFiller()) return true;
6697
6698 // Zero-initialize all elements.
6699 LValue Subobject = This;
6700 Subobject.addArray(Info, E, CAT);
6701 ImplicitValueInitExpr VIE(CAT->getElementType());
6702 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
6703 }
6704
6705 bool VisitCallExpr(const CallExpr *E) {
6706 return handleCallExpr(E, Result, &This);
6707 }
6708 bool VisitInitListExpr(const InitListExpr *E);
6709 bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E);
6710 bool VisitCXXConstructExpr(const CXXConstructExpr *E);
6711 bool VisitCXXConstructExpr(const CXXConstructExpr *E,
6712 const LValue &Subobject,
6713 APValue *Value, QualType Type);
6714 };
6715} // end anonymous namespace
6716
6717static bool EvaluateArray(const Expr *E, const LValue &This,
6718 APValue &Result, EvalInfo &Info) {
6719 assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue")((E->isRValue() && E->getType()->isArrayType
() && "not an array rvalue") ? static_cast<void>
(0) : __assert_fail ("E->isRValue() && E->getType()->isArrayType() && \"not an array rvalue\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6719, __PRETTY_FUNCTION__))
;
6720 return ArrayExprEvaluator(Info, This, Result).Visit(E);
6721}
6722
6723bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
6724 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(E->getType());
6725 if (!CAT)
6726 return Error(E);
6727
6728 // C++11 [dcl.init.string]p1: A char array [...] can be initialized by [...]
6729 // an appropriately-typed string literal enclosed in braces.
6730 if (E->isStringLiteralInit()) {
6731 LValue LV;
6732 if (!EvaluateLValue(E->getInit(0), LV, Info))
6733 return false;
6734 APValue Val;
6735 LV.moveInto(Val);
6736 return Success(Val, E);
6737 }
6738
6739 bool Success = true;
6740
6741 assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) &&(((!Result.isArray() || Result.getArrayInitializedElts() == 0
) && "zero-initialized array shouldn't have any initialized elts"
) ? static_cast<void> (0) : __assert_fail ("(!Result.isArray() || Result.getArrayInitializedElts() == 0) && \"zero-initialized array shouldn't have any initialized elts\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6742, __PRETTY_FUNCTION__))
6742 "zero-initialized array shouldn't have any initialized elts")(((!Result.isArray() || Result.getArrayInitializedElts() == 0
) && "zero-initialized array shouldn't have any initialized elts"
) ? static_cast<void> (0) : __assert_fail ("(!Result.isArray() || Result.getArrayInitializedElts() == 0) && \"zero-initialized array shouldn't have any initialized elts\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6742, __PRETTY_FUNCTION__))
;
6743 APValue Filler;
6744 if (Result.isArray() && Result.hasArrayFiller())
6745 Filler = Result.getArrayFiller();
6746
6747 unsigned NumEltsToInit = E->getNumInits();
6748 unsigned NumElts = CAT->getSize().getZExtValue();
6749 const Expr *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : nullptr;
6750
6751 // If the initializer might depend on the array index, run it for each
6752 // array element. For now, just whitelist non-class value-initialization.
6753 if (NumEltsToInit != NumElts && !isa<ImplicitValueInitExpr>(FillerExpr))
6754 NumEltsToInit = NumElts;
6755
6756 Result = APValue(APValue::UninitArray(), NumEltsToInit, NumElts);
6757
6758 // If the array was previously zero-initialized, preserve the
6759 // zero-initialized values.
6760 if (!Filler.isUninit()) {
6761 for (unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I)
6762 Result.getArrayInitializedElt(I) = Filler;
6763 if (Result.hasArrayFiller())
6764 Result.getArrayFiller() = Filler;
6765 }
6766
6767 LValue Subobject = This;
6768 Subobject.addArray(Info, E, CAT);
6769 for (unsigned Index = 0; Index != NumEltsToInit; ++Index) {
6770 const Expr *Init =
6771 Index < E->getNumInits() ? E->getInit(Index) : FillerExpr;
6772 if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
6773 Info, Subobject, Init) ||
6774 !HandleLValueArrayAdjustment(Info, Init, Subobject,
6775 CAT->getElementType(), 1)) {
6776 if (!Info.noteFailure())
6777 return false;
6778 Success = false;
6779 }
6780 }
6781
6782 if (!Result.hasArrayFiller())
6783 return Success;
6784
6785 // If we get here, we have a trivial filler, which we can just evaluate
6786 // once and splat over the rest of the array elements.
6787 assert(FillerExpr && "no array filler for incomplete init list")((FillerExpr && "no array filler for incomplete init list"
) ? static_cast<void> (0) : __assert_fail ("FillerExpr && \"no array filler for incomplete init list\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6787, __PRETTY_FUNCTION__))
;
6788 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject,
6789 FillerExpr) && Success;
6790}
6791
6792bool ArrayExprEvaluator::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) {
6793 if (E->getCommonExpr() &&
6794 !Evaluate(Info.CurrentCall->createTemporary(E->getCommonExpr(), false),
6795 Info, E->getCommonExpr()->getSourceExpr()))
6796 return false;
6797
6798 auto *CAT = cast<ConstantArrayType>(E->getType()->castAsArrayTypeUnsafe());
6799
6800 uint64_t Elements = CAT->getSize().getZExtValue();
6801 Result = APValue(APValue::UninitArray(), Elements, Elements);
6802
6803 LValue Subobject = This;
6804 Subobject.addArray(Info, E, CAT);
6805
6806 bool Success = true;
6807 for (EvalInfo::ArrayInitLoopIndex Index(Info); Index != Elements; ++Index) {
6808 if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
6809 Info, Subobject, E->getSubExpr()) ||
6810 !HandleLValueArrayAdjustment(Info, E, Subobject,
6811 CAT->getElementType(), 1)) {
6812 if (!Info.noteFailure())
6813 return false;
6814 Success = false;
6815 }
6816 }
6817
6818 return Success;
6819}
6820
6821bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E) {
6822 return VisitCXXConstructExpr(E, This, &Result, E->getType());
6823}
6824
6825bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
6826 const LValue &Subobject,
6827 APValue *Value,
6828 QualType Type) {
6829 bool HadZeroInit = !Value->isUninit();
6830
6831 if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) {
6832 unsigned N = CAT->getSize().getZExtValue();
6833
6834 // Preserve the array filler if we had prior zero-initialization.
6835 APValue Filler =
6836 HadZeroInit && Value->hasArrayFiller() ? Value->getArrayFiller()
6837 : APValue();
6838
6839 *Value = APValue(APValue::UninitArray(), N, N);
6840
6841 if (HadZeroInit)
6842 for (unsigned I = 0; I != N; ++I)
6843 Value->getArrayInitializedElt(I) = Filler;
6844
6845 // Initialize the elements.
6846 LValue ArrayElt = Subobject;
6847 ArrayElt.addArray(Info, E, CAT);
6848 for (unsigned I = 0; I != N; ++I)
6849 if (!VisitCXXConstructExpr(E, ArrayElt, &Value->getArrayInitializedElt(I),
6850 CAT->getElementType()) ||
6851 !HandleLValueArrayAdjustment(Info, E, ArrayElt,
6852 CAT->getElementType(), 1))
6853 return false;
6854
6855 return true;
6856 }
6857
6858 if (!Type->isRecordType())
6859 return Error(E);
6860
6861 return RecordExprEvaluator(Info, Subobject, *Value)
6862 .VisitCXXConstructExpr(E, Type);
6863}
6864
6865//===----------------------------------------------------------------------===//
6866// Integer Evaluation
6867//
6868// As a GNU extension, we support casting pointers to sufficiently-wide integer
6869// types and back in constant folding. Integer values are thus represented
6870// either as an integer-valued APValue, or as an lvalue-valued APValue.
6871//===----------------------------------------------------------------------===//
6872
6873namespace {
6874class IntExprEvaluator
6875 : public ExprEvaluatorBase<IntExprEvaluator> {
6876 APValue &Result;
6877public:
6878 IntExprEvaluator(EvalInfo &info, APValue &result)
6879 : ExprEvaluatorBaseTy(info), Result(result) {}
6880
6881 bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
6882 assert(E->getType()->isIntegralOrEnumerationType() &&((E->getType()->isIntegralOrEnumerationType() &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("E->getType()->isIntegralOrEnumerationType() && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6883, __PRETTY_FUNCTION__))
6883 "Invalid evaluation result.")((E->getType()->isIntegralOrEnumerationType() &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("E->getType()->isIntegralOrEnumerationType() && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6883, __PRETTY_FUNCTION__))
;
6884 assert(SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() &&((SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType
() && "Invalid evaluation result.") ? static_cast<
void> (0) : __assert_fail ("SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6885, __PRETTY_FUNCTION__))
6885 "Invalid evaluation result.")((SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType
() && "Invalid evaluation result.") ? static_cast<
void> (0) : __assert_fail ("SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6885, __PRETTY_FUNCTION__))
;
6886 assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&((SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6887, __PRETTY_FUNCTION__))
6887 "Invalid evaluation result.")((SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6887, __PRETTY_FUNCTION__))
;
6888 Result = APValue(SI);
6889 return true;
6890 }
6891 bool Success(const llvm::APSInt &SI, const Expr *E) {
6892 return Success(SI, E, Result);
6893 }
6894
6895 bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
6896 assert(E->getType()->isIntegralOrEnumerationType() &&((E->getType()->isIntegralOrEnumerationType() &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("E->getType()->isIntegralOrEnumerationType() && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6897, __PRETTY_FUNCTION__))
6897 "Invalid evaluation result.")((E->getType()->isIntegralOrEnumerationType() &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("E->getType()->isIntegralOrEnumerationType() && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6897, __PRETTY_FUNCTION__))
;
6898 assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&((I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6899, __PRETTY_FUNCTION__))
6899 "Invalid evaluation result.")((I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6899, __PRETTY_FUNCTION__))
;
6900 Result = APValue(APSInt(I));
6901 Result.getInt().setIsUnsigned(
6902 E->getType()->isUnsignedIntegerOrEnumerationType());
6903 return true;
6904 }
6905 bool Success(const llvm::APInt &I, const Expr *E) {
6906 return Success(I, E, Result);
6907 }
6908
6909 bool Success(uint64_t Value, const Expr *E, APValue &Result) {
6910 assert(E->getType()->isIntegralOrEnumerationType() &&((E->getType()->isIntegralOrEnumerationType() &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("E->getType()->isIntegralOrEnumerationType() && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6911, __PRETTY_FUNCTION__))
6911 "Invalid evaluation result.")((E->getType()->isIntegralOrEnumerationType() &&
"Invalid evaluation result.") ? static_cast<void> (0) :
__assert_fail ("E->getType()->isIntegralOrEnumerationType() && \"Invalid evaluation result.\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 6911, __PRETTY_FUNCTION__))
;
6912 Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
6913 return true;
6914 }
6915 bool Success(uint64_t Value, const Expr *E) {
6916 return Success(Value, E, Result);
6917 }
6918
6919 bool Success(CharUnits Size, const Expr *E) {
6920 return Success(Size.getQuantity(), E);
6921 }
6922
6923 bool Success(const APValue &V, const Expr *E) {
6924 if (V.isLValue() || V.isAddrLabelDiff()) {
6925 Result = V;
6926 return true;
6927 }
6928 return Success(V.getInt(), E);
6929 }
6930
6931 bool ZeroInitialization(const Expr *E) { return Success(0, E); }
6932
6933 //===--------------------------------------------------------------------===//
6934 // Visitor Methods
6935 //===--------------------------------------------------------------------===//
6936
6937 bool VisitIntegerLiteral(const IntegerLiteral *E) {
6938 return Success(E->getValue(), E);
6939 }
6940 bool VisitCharacterLiteral(const CharacterLiteral *E) {
6941 return Success(E->getValue(), E);
6942 }
6943
6944 bool CheckReferencedDecl(const Expr *E, const Decl *D);
6945 bool VisitDeclRefExpr(const DeclRefExpr *E) {
6946 if (CheckReferencedDecl(E, E->getDecl()))
6947 return true;
6948
6949 return ExprEvaluatorBaseTy::VisitDeclRefExpr(E);
6950 }
6951 bool VisitMemberExpr(const MemberExpr *E) {
6952 if (CheckReferencedDecl(E, E->getMemberDecl())) {
6953 VisitIgnoredBaseExpression(E->getBase());
6954 return true;
6955 }
6956
6957 return ExprEvaluatorBaseTy::VisitMemberExpr(E);
6958 }
6959
6960 bool VisitCallExpr(const CallExpr *E);
6961 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
6962 bool VisitBinaryOperator(const BinaryOperator *E);
6963 bool VisitOffsetOfExpr(const OffsetOfExpr *E);
6964 bool VisitUnaryOperator(const UnaryOperator *E);
6965
6966 bool VisitCastExpr(const CastExpr* E);
6967 bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
6968
6969 bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
6970 return Success(E->getValue(), E);
6971 }
6972
6973 bool VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
6974 return Success(E->getValue(), E);
6975 }
6976
6977 bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) {
6978 if (Info.ArrayInitIndex == uint64_t(-1)) {
6979 // We were asked to evaluate this subexpression independent of the
6980 // enclosing ArrayInitLoopExpr. We can't do that.
6981 Info.FFDiag(E);
6982 return false;
6983 }
6984 return Success(Info.ArrayInitIndex, E);
6985 }
6986
6987 // Note, GNU defines __null as an integer, not a pointer.
6988 bool VisitGNUNullExpr(const GNUNullExpr *E) {
6989 return ZeroInitialization(E);
6990 }
6991
6992 bool VisitTypeTraitExpr(const TypeTraitExpr *E) {
6993 return Success(E->getValue(), E);
6994 }
6995
6996 bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
6997 return Success(E->getValue(), E);
6998 }
6999
7000 bool VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
7001 return Success(E->getValue(), E);
7002 }
7003
7004 bool VisitUnaryReal(const UnaryOperator *E);
7005 bool VisitUnaryImag(const UnaryOperator *E);
7006
7007 bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E);
7008 bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
7009
7010 // FIXME: Missing: array subscript of vector, member of vector
7011};
7012} // end anonymous namespace
7013
7014/// EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and
7015/// produce either the integer value or a pointer.
7016///
7017/// GCC has a heinous extension which folds casts between pointer types and
7018/// pointer-sized integral types. We support this by allowing the evaluation of
7019/// an integer rvalue to produce a pointer (represented as an lvalue) instead.
7020/// Some simple arithmetic on such values is supported (they are treated much
7021/// like char*).
7022static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
7023 EvalInfo &Info) {
7024 assert(E->isRValue() && E->getType()->isIntegralOrEnumerationType())((E->isRValue() && E->getType()->isIntegralOrEnumerationType
()) ? static_cast<void> (0) : __assert_fail ("E->isRValue() && E->getType()->isIntegralOrEnumerationType()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7024, __PRETTY_FUNCTION__))
;
7025 return IntExprEvaluator(Info, Result).Visit(E);
7026}
7027
7028static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
7029 APValue Val;
7030 if (!EvaluateIntegerOrLValue(E, Val, Info))
7031 return false;
7032 if (!Val.isInt()) {
7033 // FIXME: It would be better to produce the diagnostic for casting
7034 // a pointer to an integer.
7035 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
7036 return false;
7037 }
7038 Result = Val.getInt();
7039 return true;
7040}
7041
7042/// Check whether the given declaration can be directly converted to an integral
7043/// rvalue. If not, no diagnostic is produced; there are other things we can
7044/// try.
7045bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) {
7046 // Enums are integer constant exprs.
7047 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) {
7048 // Check for signedness/width mismatches between E type and ECD value.
7049 bool SameSign = (ECD->getInitVal().isSigned()
7050 == E->getType()->isSignedIntegerOrEnumerationType());
7051 bool SameWidth = (ECD->getInitVal().getBitWidth()
7052 == Info.Ctx.getIntWidth(E->getType()));
7053 if (SameSign && SameWidth)
7054 return Success(ECD->getInitVal(), E);
7055 else {
7056 // Get rid of mismatch (otherwise Success assertions will fail)
7057 // by computing a new value matching the type of E.
7058 llvm::APSInt Val = ECD->getInitVal();
7059 if (!SameSign)
7060 Val.setIsSigned(!ECD->getInitVal().isSigned());
7061 if (!SameWidth)
7062 Val = Val.extOrTrunc(Info.Ctx.getIntWidth(E->getType()));
7063 return Success(Val, E);
7064 }
7065 }
7066 return false;
7067}
7068
7069/// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
7070/// as GCC.
7071static int EvaluateBuiltinClassifyType(const CallExpr *E,
7072 const LangOptions &LangOpts) {
7073 // The following enum mimics the values returned by GCC.
7074 // FIXME: Does GCC differ between lvalue and rvalue references here?
7075 enum gcc_type_class {
7076 no_type_class = -1,
7077 void_type_class, integer_type_class, char_type_class,
7078 enumeral_type_class, boolean_type_class,
7079 pointer_type_class, reference_type_class, offset_type_class,
7080 real_type_class, complex_type_class,
7081 function_type_class, method_type_class,
7082 record_type_class, union_type_class,
7083 array_type_class, string_type_class,
7084 lang_type_class
7085 };
7086
7087 // If no argument was supplied, default to "no_type_class". This isn't
7088 // ideal, however it is what gcc does.
7089 if (E->getNumArgs() == 0)
7090 return no_type_class;
7091
7092 QualType CanTy = E->getArg(0)->getType().getCanonicalType();
7093 const BuiltinType *BT = dyn_cast<BuiltinType>(CanTy);
7094
7095 switch (CanTy->getTypeClass()) {
7096#define TYPE(ID, BASE)
7097#define DEPENDENT_TYPE(ID, BASE) case Type::ID:
7098#define NON_CANONICAL_TYPE(ID, BASE) case Type::ID:
7099#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(ID, BASE) case Type::ID:
7100#include "clang/AST/TypeNodes.def"
7101 llvm_unreachable("CallExpr::isBuiltinClassifyType(): unimplemented type")::llvm::llvm_unreachable_internal("CallExpr::isBuiltinClassifyType(): unimplemented type"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7101)
;
7102
7103 case Type::Builtin:
7104 switch (BT->getKind()) {
7105#define BUILTIN_TYPE(ID, SINGLETON_ID)
7106#define SIGNED_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: return integer_type_class;
7107#define FLOATING_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: return real_type_class;
7108#define PLACEHOLDER_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: break;
7109#include "clang/AST/BuiltinTypes.def"
7110 case BuiltinType::Void:
7111 return void_type_class;
7112
7113 case BuiltinType::Bool:
7114 return boolean_type_class;
7115
7116 case BuiltinType::Char_U: // gcc doesn't appear to use char_type_class
7117 case BuiltinType::UChar:
7118 case BuiltinType::UShort:
7119 case BuiltinType::UInt:
7120 case BuiltinType::ULong:
7121 case BuiltinType::ULongLong:
7122 case BuiltinType::UInt128:
7123 return integer_type_class;
7124
7125 case BuiltinType::NullPtr:
7126 return pointer_type_class;
7127
7128 case BuiltinType::WChar_U:
7129 case BuiltinType::Char16:
7130 case BuiltinType::Char32:
7131 case BuiltinType::ObjCId:
7132 case BuiltinType::ObjCClass:
7133 case BuiltinType::ObjCSel:
7134#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7135 case BuiltinType::Id:
7136#include "clang/Basic/OpenCLImageTypes.def"
7137 case BuiltinType::OCLSampler:
7138 case BuiltinType::OCLEvent:
7139 case BuiltinType::OCLClkEvent:
7140 case BuiltinType::OCLQueue:
7141 case BuiltinType::OCLReserveID:
7142 case BuiltinType::Dependent:
7143 llvm_unreachable("CallExpr::isBuiltinClassifyType(): unimplemented type")::llvm::llvm_unreachable_internal("CallExpr::isBuiltinClassifyType(): unimplemented type"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7143)
;
7144 };
7145
7146 case Type::Enum:
7147 return LangOpts.CPlusPlus ? enumeral_type_class : integer_type_class;
7148 break;
7149
7150 case Type::Pointer:
7151 return pointer_type_class;
7152 break;
7153
7154 case Type::MemberPointer:
7155 if (CanTy->isMemberDataPointerType())
7156 return offset_type_class;
7157 else {
7158 // We expect member pointers to be either data or function pointers,
7159 // nothing else.
7160 assert(CanTy->isMemberFunctionPointerType())((CanTy->isMemberFunctionPointerType()) ? static_cast<void
> (0) : __assert_fail ("CanTy->isMemberFunctionPointerType()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7160, __PRETTY_FUNCTION__))
;
7161 return method_type_class;
7162 }
7163
7164 case Type::Complex:
7165 return complex_type_class;
7166
7167 case Type::FunctionNoProto:
7168 case Type::FunctionProto:
7169 return LangOpts.CPlusPlus ? function_type_class : pointer_type_class;
7170
7171 case Type::Record:
7172 if (const RecordType *RT = CanTy->getAs<RecordType>()) {
7173 switch (RT->getDecl()->getTagKind()) {
7174 case TagTypeKind::TTK_Struct:
7175 case TagTypeKind::TTK_Class:
7176 case TagTypeKind::TTK_Interface:
7177 return record_type_class;
7178
7179 case TagTypeKind::TTK_Enum:
7180 return LangOpts.CPlusPlus ? enumeral_type_class : integer_type_class;
7181
7182 case TagTypeKind::TTK_Union:
7183 return union_type_class;
7184 }
7185 }
7186 llvm_unreachable("CallExpr::isBuiltinClassifyType(): unimplemented type")::llvm::llvm_unreachable_internal("CallExpr::isBuiltinClassifyType(): unimplemented type"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7186)
;
7187
7188 case Type::ConstantArray:
7189 case Type::VariableArray:
7190 case Type::IncompleteArray:
7191 return LangOpts.CPlusPlus ? array_type_class : pointer_type_class;
7192
7193 case Type::BlockPointer:
7194 case Type::LValueReference:
7195 case Type::RValueReference:
7196 case Type::Vector:
7197 case Type::ExtVector:
7198 case Type::Auto:
7199 case Type::DeducedTemplateSpecialization:
7200 case Type::ObjCObject:
7201 case Type::ObjCInterface:
7202 case Type::ObjCObjectPointer:
7203 case Type::Pipe:
7204 case Type::Atomic:
7205 llvm_unreachable("CallExpr::isBuiltinClassifyType(): unimplemented type")::llvm::llvm_unreachable_internal("CallExpr::isBuiltinClassifyType(): unimplemented type"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7205)
;
7206 }
7207
7208 llvm_unreachable("CallExpr::isBuiltinClassifyType(): unimplemented type")::llvm::llvm_unreachable_internal("CallExpr::isBuiltinClassifyType(): unimplemented type"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7208)
;
7209}
7210
7211/// EvaluateBuiltinConstantPForLValue - Determine the result of
7212/// __builtin_constant_p when applied to the given lvalue.
7213///
7214/// An lvalue is only "constant" if it is a pointer or reference to the first
7215/// character of a string literal.
7216template<typename LValue>
7217static bool EvaluateBuiltinConstantPForLValue(const LValue &LV) {
7218 const Expr *E = LV.getLValueBase().template dyn_cast<const Expr*>();
7219 return E && isa<StringLiteral>(E) && LV.getLValueOffset().isZero();
7220}
7221
7222/// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to
7223/// GCC as we can manage.
7224static bool EvaluateBuiltinConstantP(ASTContext &Ctx, const Expr *Arg) {
7225 QualType ArgType = Arg->getType();
7226
7227 // __builtin_constant_p always has one operand. The rules which gcc follows
7228 // are not precisely documented, but are as follows:
7229 //
7230 // - If the operand is of integral, floating, complex or enumeration type,
7231 // and can be folded to a known value of that type, it returns 1.
7232 // - If the operand and can be folded to a pointer to the first character
7233 // of a string literal (or such a pointer cast to an integral type), it
7234 // returns 1.
7235 //
7236 // Otherwise, it returns 0.
7237 //
7238 // FIXME: GCC also intends to return 1 for literals of aggregate types, but
7239 // its support for this does not currently work.
7240 if (ArgType->isIntegralOrEnumerationType()) {
7241 Expr::EvalResult Result;
7242 if (!Arg->EvaluateAsRValue(Result, Ctx) || Result.HasSideEffects)
7243 return false;
7244
7245 APValue &V = Result.Val;
7246 if (V.getKind() == APValue::Int)
7247 return true;
7248 if (V.getKind() == APValue::LValue)
7249 return EvaluateBuiltinConstantPForLValue(V);
7250 } else if (ArgType->isFloatingType() || ArgType->isAnyComplexType()) {
7251 return Arg->isEvaluatable(Ctx);
7252 } else if (ArgType->isPointerType() || Arg->isGLValue()) {
7253 LValue LV;
7254 Expr::EvalStatus Status;
7255 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
7256 if ((Arg->isGLValue() ? EvaluateLValue(Arg, LV, Info)
7257 : EvaluatePointer(Arg, LV, Info)) &&
7258 !Status.HasSideEffects)
7259 return EvaluateBuiltinConstantPForLValue(LV);
7260 }
7261
7262 // Anything else isn't considered to be sufficiently constant.
7263 return false;
7264}
7265
7266/// Retrieves the "underlying object type" of the given expression,
7267/// as used by __builtin_object_size.
7268static QualType getObjectType(APValue::LValueBase B) {
7269 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
7270 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
7271 return VD->getType();
7272 } else if (const Expr *E = B.get<const Expr*>()) {
7273 if (isa<CompoundLiteralExpr>(E))
7274 return E->getType();
7275 }
7276
7277 return QualType();
7278}
7279
7280/// A more selective version of E->IgnoreParenCasts for
7281/// tryEvaluateBuiltinObjectSize. This ignores some casts/parens that serve only
7282/// to change the type of E.
7283/// Ex. For E = `(short*)((char*)(&foo))`, returns `&foo`
7284///
7285/// Always returns an RValue with a pointer representation.
7286static const Expr *ignorePointerCastsAndParens(const Expr *E) {
7287 assert(E->isRValue() && E->getType()->hasPointerRepresentation())((E->isRValue() && E->getType()->hasPointerRepresentation
()) ? static_cast<void> (0) : __assert_fail ("E->isRValue() && E->getType()->hasPointerRepresentation()"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7287, __PRETTY_FUNCTION__))
;
7288
7289 auto *NoParens = E->IgnoreParens();
7290 auto *Cast = dyn_cast<CastExpr>(NoParens);
7291 if (Cast == nullptr)
7292 return NoParens;
7293
7294 // We only conservatively allow a few kinds of casts, because this code is
7295 // inherently a simple solution that seeks to support the common case.
7296 auto CastKind = Cast->getCastKind();
7297 if (CastKind != CK_NoOp && CastKind != CK_BitCast &&
7298 CastKind != CK_AddressSpaceConversion)
7299 return NoParens;
7300
7301 auto *SubExpr = Cast->getSubExpr();
7302 if (!SubExpr->getType()->hasPointerRepresentation() || !SubExpr->isRValue())
7303 return NoParens;
7304 return ignorePointerCastsAndParens(SubExpr);
7305}
7306
7307/// Checks to see if the given LValue's Designator is at the end of the LValue's
7308/// record layout. e.g.
7309/// struct { struct { int a, b; } fst, snd; } obj;
7310/// obj.fst // no
7311/// obj.snd // yes
7312/// obj.fst.a // no
7313/// obj.fst.b // no
7314/// obj.snd.a // no
7315/// obj.snd.b // yes
7316///
7317/// Please note: this function is specialized for how __builtin_object_size
7318/// views "objects".
7319///
7320/// If this encounters an invalid RecordDecl, it will always return true.
7321static bool isDesignatorAtObjectEnd(const ASTContext &Ctx, const LValue &LVal) {
7322 assert(!LVal.Designator.Invalid)((!LVal.Designator.Invalid) ? static_cast<void> (0) : __assert_fail
("!LVal.Designator.Invalid", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7322, __PRETTY_FUNCTION__))
;
7323
7324 auto IsLastOrInvalidFieldDecl = [&Ctx](const FieldDecl *FD, bool &Invalid) {
7325 const RecordDecl *Parent = FD->getParent();
7326 Invalid = Parent->isInvalidDecl();
7327 if (Invalid || Parent->isUnion())
7328 return true;
7329 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(Parent);
7330 return FD->getFieldIndex() + 1 == Layout.getFieldCount();
7331 };
7332
7333 auto &Base = LVal.getLValueBase();
7334 if (auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<const Expr *>())) {
7335 if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
7336 bool Invalid;
7337 if (!IsLastOrInvalidFieldDecl(FD, Invalid))
7338 return Invalid;
7339 } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(ME->getMemberDecl())) {
7340 for (auto *FD : IFD->chain()) {
7341 bool Invalid;
7342 if (!IsLastOrInvalidFieldDecl(cast<FieldDecl>(FD), Invalid))
7343 return Invalid;
7344 }
7345 }
7346 }
7347
7348 unsigned I = 0;
7349 QualType BaseType = getType(Base);
7350 if (LVal.Designator.FirstEntryIsAnUnsizedArray) {
7351 assert(isBaseAnAllocSizeCall(Base) &&((isBaseAnAllocSizeCall(Base) && "Unsized array in non-alloc_size call?"
) ? static_cast<void> (0) : __assert_fail ("isBaseAnAllocSizeCall(Base) && \"Unsized array in non-alloc_size call?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7352, __PRETTY_FUNCTION__))
7352 "Unsized array in non-alloc_size call?")((isBaseAnAllocSizeCall(Base) && "Unsized array in non-alloc_size call?"
) ? static_cast<void> (0) : __assert_fail ("isBaseAnAllocSizeCall(Base) && \"Unsized array in non-alloc_size call?\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7352, __PRETTY_FUNCTION__))
;
7353 // If this is an alloc_size base, we should ignore the initial array index
7354 ++I;
7355 BaseType = BaseType->castAs<PointerType>()->getPointeeType();
7356 }
7357
7358 for (unsigned E = LVal.Designator.Entries.size(); I != E; ++I) {
7359 const auto &Entry = LVal.Designator.Entries[I];
7360 if (BaseType->isArrayType()) {
7361 // Because __builtin_object_size treats arrays as objects, we can ignore
7362 // the index iff this is the last array in the Designator.
7363 if (I + 1 == E)
7364 return true;
7365 const auto *CAT = cast<ConstantArrayType>(Ctx.getAsArrayType(BaseType));
7366 uint64_t Index = Entry.ArrayIndex;
7367 if (Index + 1 != CAT->getSize())
7368 return false;
7369 BaseType = CAT->getElementType();
7370 } else if (BaseType->isAnyComplexType()) {
7371 const auto *CT = BaseType->castAs<ComplexType>();
7372 uint64_t Index = Entry.ArrayIndex;
7373 if (Index != 1)
7374 return false;
7375 BaseType = CT->getElementType();
7376 } else if (auto *FD = getAsField(Entry)) {
7377 bool Invalid;
7378 if (!IsLastOrInvalidFieldDecl(FD, Invalid))
7379 return Invalid;
7380 BaseType = FD->getType();
7381 } else {
7382 assert(getAsBaseClass(Entry) && "Expecting cast to a base class")((getAsBaseClass(Entry) && "Expecting cast to a base class"
) ? static_cast<void> (0) : __assert_fail ("getAsBaseClass(Entry) && \"Expecting cast to a base class\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7382, __PRETTY_FUNCTION__))
;
7383 return false;
7384 }
7385 }
7386 return true;
7387}
7388
7389/// Tests to see if the LValue has a user-specified designator (that isn't
7390/// necessarily valid). Note that this always returns 'true' if the LValue has
7391/// an unsized array as its first designator entry, because there's currently no
7392/// way to tell if the user typed *foo or foo[0].
7393static bool refersToCompleteObject(const LValue &LVal) {
7394 if (LVal.Designator.Invalid)
7395 return false;
7396
7397 if (!LVal.Designator.Entries.empty())
7398 return LVal.Designator.isMostDerivedAnUnsizedArray();
7399
7400 if (!LVal.InvalidBase)
7401 return true;
7402
7403 // If `E` is a MemberExpr, then the first part of the designator is hiding in
7404 // the LValueBase.
7405 const auto *E = LVal.Base.dyn_cast<const Expr *>();
7406 return !E || !isa<MemberExpr>(E);
7407}
7408
7409/// Attempts to detect a user writing into a piece of memory that's impossible
7410/// to figure out the size of by just using types.
7411static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal) {
7412 const SubobjectDesignator &Designator = LVal.Designator;
7413 // Notes:
7414 // - Users can only write off of the end when we have an invalid base. Invalid
7415 // bases imply we don't know where the memory came from.
7416 // - We used to be a bit more aggressive here; we'd only be conservative if
7417 // the array at the end was flexible, or if it had 0 or 1 elements. This
7418 // broke some common standard library extensions (PR30346), but was
7419 // otherwise seemingly fine. It may be useful to reintroduce this behavior
7420 // with some sort of whitelist. OTOH, it seems that GCC is always
7421 // conservative with the last element in structs (if it's an array), so our
7422 // current behavior is more compatible than a whitelisting approach would
7423 // be.
7424 return LVal.InvalidBase &&
7425 Designator.Entries.size() == Designator.MostDerivedPathLength &&
7426 Designator.MostDerivedIsArrayElement &&
7427 isDesignatorAtObjectEnd(Ctx, LVal);
7428}
7429
7430/// Converts the given APInt to CharUnits, assuming the APInt is unsigned.
7431/// Fails if the conversion would cause loss of precision.
7432static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int,
7433 CharUnits &Result) {
7434 auto CharUnitsMax = std::numeric_limits<CharUnits::QuantityType>::max();
7435 if (Int.ugt(CharUnitsMax))
7436 return false;
7437 Result = CharUnits::fromQuantity(Int.getZExtValue());
7438 return true;
7439}
7440
7441/// Helper for tryEvaluateBuiltinObjectSize -- Given an LValue, this will
7442/// determine how many bytes exist from the beginning of the object to either
7443/// the end of the current subobject, or the end of the object itself, depending
7444/// on what the LValue looks like + the value of Type.
7445///
7446/// If this returns false, the value of Result is undefined.
7447static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc,
7448 unsigned Type, const LValue &LVal,
7449 CharUnits &EndOffset) {
7450 bool DetermineForCompleteObject = refersToCompleteObject(LVal);
7451
7452 auto CheckedHandleSizeof = [&](QualType Ty, CharUnits &Result) {
7453 if (Ty.isNull() || Ty->isIncompleteType() || Ty->isFunctionType())
7454 return false;
7455 return HandleSizeof(Info, ExprLoc, Ty, Result);
7456 };
7457
7458 // We want to evaluate the size of the entire object. This is a valid fallback
7459 // for when Type=1 and the designator is invalid, because we're asked for an
7460 // upper-bound.
7461 if (!(Type & 1) || LVal.Designator.Invalid || DetermineForCompleteObject) {
7462 // Type=3 wants a lower bound, so we can't fall back to this.
7463 if (Type == 3 && !DetermineForCompleteObject)
7464 return false;
7465
7466 llvm::APInt APEndOffset;
7467 if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
7468 getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
7469 return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
7470
7471 if (LVal.InvalidBase)
7472 return false;
7473
7474 QualType BaseTy = getObjectType(LVal.getLValueBase());
7475 return CheckedHandleSizeof(BaseTy, EndOffset);
7476 }
7477
7478 // We want to evaluate the size of a subobject.
7479 const SubobjectDesignator &Designator = LVal.Designator;
7480
7481 // The following is a moderately common idiom in C:
7482 //
7483 // struct Foo { int a; char c[1]; };
7484 // struct Foo *F = (struct Foo *)malloc(sizeof(struct Foo) + strlen(Bar));
7485 // strcpy(&F->c[0], Bar);
7486 //
7487 // In order to not break too much legacy code, we need to support it.
7488 if (isUserWritingOffTheEnd(Info.Ctx, LVal)) {
7489 // If we can resolve this to an alloc_size call, we can hand that back,
7490 // because we know for certain how many bytes there are to write to.
7491 llvm::APInt APEndOffset;
7492 if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
7493 getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
7494 return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
7495
7496 // If we cannot determine the size of the initial allocation, then we can't
7497 // given an accurate upper-bound. However, we are still able to give
7498 // conservative lower-bounds for Type=3.
7499 if (Type == 1)
7500 return false;
7501 }
7502
7503 CharUnits BytesPerElem;
7504 if (!CheckedHandleSizeof(Designator.MostDerivedType, BytesPerElem))
7505 return false;
7506
7507 // According to the GCC documentation, we want the size of the subobject
7508 // denoted by the pointer. But that's not quite right -- what we actually
7509 // want is the size of the immediately-enclosing array, if there is one.
7510 int64_t ElemsRemaining;
7511 if (Designator.MostDerivedIsArrayElement &&
7512 Designator.Entries.size() == Designator.MostDerivedPathLength) {
7513 uint64_t ArraySize = Designator.getMostDerivedArraySize();
7514 uint64_t ArrayIndex = Designator.Entries.back().ArrayIndex;
7515 ElemsRemaining = ArraySize <= ArrayIndex ? 0 : ArraySize - ArrayIndex;
7516 } else {
7517 ElemsRemaining = Designator.isOnePastTheEnd() ? 0 : 1;
7518 }
7519
7520 EndOffset = LVal.getLValueOffset() + BytesPerElem * ElemsRemaining;
7521 return true;
7522}
7523
7524/// \brief Tries to evaluate the __builtin_object_size for @p E. If successful,
7525/// returns true and stores the result in @p Size.
7526///
7527/// If @p WasError is non-null, this will report whether the failure to evaluate
7528/// is to be treated as an Error in IntExprEvaluator.
7529static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type,
7530 EvalInfo &Info, uint64_t &Size) {
7531 // Determine the denoted object.
7532 LValue LVal;
7533 {
7534 // The operand of __builtin_object_size is never evaluated for side-effects.
7535 // If there are any, but we can determine the pointed-to object anyway, then
7536 // ignore the side-effects.
7537 SpeculativeEvaluationRAII SpeculativeEval(Info);
7538 FoldOffsetRAII Fold(Info);
7539
7540 if (E->isGLValue()) {
7541 // It's possible for us to be given GLValues if we're called via
7542 // Expr::tryEvaluateObjectSize.
7543 APValue RVal;
7544 if (!EvaluateAsRValue(Info, E, RVal))
7545 return false;
7546 LVal.setFrom(Info.Ctx, RVal);
7547 } else if (!EvaluatePointer(ignorePointerCastsAndParens(E), LVal, Info,
7548 /*InvalidBaseOK=*/true))
7549 return false;
7550 }
7551
7552 // If we point to before the start of the object, there are no accessible
7553 // bytes.
7554 if (LVal.getLValueOffset().isNegative()) {
7555 Size = 0;
7556 return true;
7557 }
7558
7559 CharUnits EndOffset;
7560 if (!determineEndOffset(Info, E->getExprLoc(), Type, LVal, EndOffset))
7561 return false;
7562
7563 // If we've fallen outside of the end offset, just pretend there's nothing to
7564 // write to/read from.
7565 if (EndOffset <= LVal.getLValueOffset())
7566 Size = 0;
7567 else
7568 Size = (EndOffset - LVal.getLValueOffset()).getQuantity();
7569 return true;
7570}
7571
7572bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
7573 if (unsigned BuiltinOp = E->getBuiltinCallee())
7574 return VisitBuiltinCallExpr(E, BuiltinOp);
7575
7576 return ExprEvaluatorBaseTy::VisitCallExpr(E);
7577}
7578
7579bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
7580 unsigned BuiltinOp) {
7581 switch (unsigned BuiltinOp = E->getBuiltinCallee()) {
7582 default:
7583 return ExprEvaluatorBaseTy::VisitCallExpr(E);
7584
7585 case Builtin::BI__builtin_object_size: {
7586 // The type was checked when we built the expression.
7587 unsigned Type =
7588 E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
7589 assert(Type <= 3 && "unexpected type")((Type <= 3 && "unexpected type") ? static_cast<
void> (0) : __assert_fail ("Type <= 3 && \"unexpected type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7589, __PRETTY_FUNCTION__))
;
7590
7591 uint64_t Size;
7592 if (tryEvaluateBuiltinObjectSize(E->getArg(0), Type, Info, Size))
7593 return Success(Size, E);
7594
7595 if (E->getArg(0)->HasSideEffects(Info.Ctx))
7596 return Success((Type & 2) ? 0 : -1, E);
7597
7598 // Expression had no side effects, but we couldn't statically determine the
7599 // size of the referenced object.
7600 switch (Info.EvalMode) {
7601 case EvalInfo::EM_ConstantExpression:
7602 case EvalInfo::EM_PotentialConstantExpression:
7603 case EvalInfo::EM_ConstantFold:
7604 case EvalInfo::EM_EvaluateForOverflow:
7605 case EvalInfo::EM_IgnoreSideEffects:
7606 case EvalInfo::EM_OffsetFold:
7607 // Leave it to IR generation.
7608 return Error(E);
7609 case EvalInfo::EM_ConstantExpressionUnevaluated:
7610 case EvalInfo::EM_PotentialConstantExpressionUnevaluated:
7611 // Reduce it to a constant now.
7612 return Success((Type & 2) ? 0 : -1, E);
7613 }
7614
7615 llvm_unreachable("unexpected EvalMode")::llvm::llvm_unreachable_internal("unexpected EvalMode", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn303373/tools/clang/lib/AST/ExprConstant.cpp"
, 7615)
;
7616 }
7617
7618 case Builtin::BI__builtin_bswap16:
7619 case Builtin::BI__builtin_bswap32:
7620 case Builtin::BI__builtin_bswap64: {
7621 APSInt Val;
7622 if (!EvaluateInteger(E->getArg(0), Val, Info))
7623 return false;
7624
7625 return Success(Val.byteSwap(), E);
7626 }
7627
7628 case Builtin::BI__builtin_classify_type:
7629 return Success(EvaluateBuiltinClassifyType(E, Info.getLangOpts()), E);
7630
7631 // FIXME: BI__builtin_clrsb
7632 // FIXME: BI__builtin_clrsbl
7633 // FIXME: BI__builtin_clrsbll
7634
7635 case Builtin::BI__builtin_clz:
7636 case Builtin::BI__builtin_clzl:
7637 case Builtin::BI__builtin_clzll:
7638 case Builtin::BI__builtin_clzs: {
7639 APSInt Val;
7640 if (!EvaluateInteger(E->getArg(0), Val, Info))
7641 return false;
7642 if (!Val)
7643 return Error(E);
7644
7645 return Success(Val.countLeadingZeros(), E);
7646 }
7647
7648 case Builtin::BI__builtin_constant_p:
7649 return Success(EvaluateBuiltinConstantP(Info.Ctx, E->getArg(0)), E);
7650
7651 case Builtin::BI__builtin_ctz:
7652 case Builtin::BI__builtin_ctzl:
7653 case Builtin::BI__builtin_ctzll:
7654 case Builtin::BI__builtin_ctzs: {
7655 APSInt Val;
7656 if (!EvaluateInteger(E->getArg(0), Val, Info))
7657 return false;
7658 if (!Val)
7659 return Error(E);
7660
7661 return Success(Val.countTrailingZeros(), E);
7662 }
7663
7664 case Builtin::BI__builtin_eh_return_data_regno: {
7665 int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
7666 Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand);
7667 return Success(Operand, E);
7668 }
7669
7670 case Builtin::BI__builtin_expect:
7671 return Visit(E->getArg(0));
7672
7673 case Builtin::BI__builtin_ffs:
7674 case Builtin::BI__builtin_ffsl:
7675 case Builtin::BI__builtin_ffsll: {
7676 APSInt Val;
7677 if (!EvaluateInteger(E->getArg(0), Val, Info))
7678 return false;
7679
7680 unsigned N = Val.countTrailingZeros();
7681 return Success(N == Val.getBitWidth() ? 0 : N + 1, E);
7682 }
7683
7684 case Builtin::BI__builtin_fpclassify: {